Update Darwin to Python 3.5 (64bit)
This commit is contained in:
parent
1f23120cc3
commit
c8252cce16
2576 changed files with 138841 additions and 63771 deletions
143
Darwin/lib/python3.5/idlelib/idle_test/README.txt
Normal file
143
Darwin/lib/python3.5/idlelib/idle_test/README.txt
Normal file
|
|
@ -0,0 +1,143 @@
|
|||
README FOR IDLE TESTS IN IDLELIB.IDLE_TEST
|
||||
|
||||
0. Quick Start
|
||||
|
||||
Automated unit tests were added in 2.7 for Python 2.x and 3.3 for Python 3.x.
|
||||
To run the tests from a command line:
|
||||
|
||||
python -m test.test_idle
|
||||
|
||||
Human-mediated tests were added later in 2.7 and in 3.4.
|
||||
|
||||
python -m idlelib.idle_test.htest
|
||||
|
||||
|
||||
1. Test Files
|
||||
|
||||
The idle directory, idlelib, has over 60 xyz.py files. The idle_test
|
||||
subdirectory should contain a test_xyz.py for each, where 'xyz' is lowercased
|
||||
even if xyz.py is not. Here is a possible template, with the blanks after after
|
||||
'.' and 'as', and before and after '_' to be filled in.
|
||||
|
||||
import unittest
|
||||
from test.support import requires
|
||||
import idlelib. as
|
||||
|
||||
class _Test(unittest.TestCase):
|
||||
|
||||
def test_(self):
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2)
|
||||
|
||||
Add the following at the end of xyy.py, with the appropriate name added after
|
||||
'test_'. Some files already have something like this for htest. If so, insert
|
||||
the import and unittest.main lines before the htest lines.
|
||||
|
||||
if __name__ == "__main__":
|
||||
import unittest
|
||||
unittest.main('idlelib.idle_test.test_', verbosity=2, exit=False)
|
||||
|
||||
|
||||
|
||||
2. GUI Tests
|
||||
|
||||
When run as part of the Python test suite, Idle gui tests need to run
|
||||
test.support.requires('gui') (test.test_support in 2.7). A test is a gui test
|
||||
if it creates a Tk root or master object either directly or indirectly by
|
||||
instantiating a tkinter or idle class. For the benefit of test processes that
|
||||
either have no graphical environment available or are not allowed to use it, gui
|
||||
tests must be 'guarded' by "requires('gui')" in a setUp function or method.
|
||||
This will typically be setUpClass.
|
||||
|
||||
To avoid interfering with other gui tests, all gui objects must be destroyed and
|
||||
deleted by the end of the test. Widgets, such as a Tk root, created in a setUpX
|
||||
function, should be destroyed in the corresponding tearDownX. Module and class
|
||||
widget attributes should also be deleted..
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
requires('gui')
|
||||
cls.root = tk.Tk()
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.root.destroy()
|
||||
del cls.root
|
||||
|
||||
|
||||
Requires('gui') causes the test(s) it guards to be skipped if any of
|
||||
a few conditions are met:
|
||||
|
||||
- The tests are being run by regrtest.py, and it was started without enabling
|
||||
the "gui" resource with the "-u" command line option.
|
||||
|
||||
- The tests are being run on Windows by a service that is not allowed to
|
||||
interact with the graphical environment.
|
||||
|
||||
- The tests are being run on Mac OSX in a process that cannot make a window
|
||||
manager connection.
|
||||
|
||||
- tkinter.Tk cannot be successfully instantiated for some reason.
|
||||
|
||||
- test.support.use_resources has been set by something other than
|
||||
regrtest.py and does not contain "gui".
|
||||
|
||||
Tests of non-gui operations should avoid creating tk widgets. Incidental uses of
|
||||
tk variables and messageboxes can be replaced by the mock classes in
|
||||
idle_test/mock_tk.py. The mock text handles some uses of the tk Text widget.
|
||||
|
||||
|
||||
3. Running Unit Tests
|
||||
|
||||
Assume that xyz.py and test_xyz.py both end with a unittest.main() call.
|
||||
Running either from an Idle editor runs all tests in the test_xyz file with the
|
||||
version of Python running Idle. Test output appears in the Shell window. The
|
||||
'verbosity=2' option lists all test methods in the file, which is appropriate
|
||||
when developing tests. The 'exit=False' option is needed in xyx.py files when an
|
||||
htest follows.
|
||||
|
||||
The following command lines also run all test methods, including
|
||||
gui tests, in test_xyz.py. (Both '-m idlelib' and '-m idlelib.idle' start
|
||||
Idle and so cannot run tests.)
|
||||
|
||||
python -m idlelib.xyz
|
||||
python -m idlelib.idle_test.test_xyz
|
||||
|
||||
The following runs all idle_test/test_*.py tests interactively.
|
||||
|
||||
>>> import unittest
|
||||
>>> unittest.main('idlelib.idle_test', verbosity=2)
|
||||
|
||||
The following run all Idle tests at a command line. Option '-v' is the same as
|
||||
'verbosity=2'. (For 2.7, replace 'test' in the second line with
|
||||
'test.regrtest'.)
|
||||
|
||||
python -m unittest -v idlelib.idle_test
|
||||
python -m test -v -ugui test_idle
|
||||
python -m test.test_idle
|
||||
|
||||
The idle tests are 'discovered' by idlelib.idle_test.__init__.load_tests,
|
||||
which is also imported into test.test_idle. Normally, neither file should be
|
||||
changed when working on individual test modules. The third command runs
|
||||
unittest indirectly through regrtest. The same happens when the entire test
|
||||
suite is run with 'python -m test'. So that command must work for buildbots
|
||||
to stay green. Idle tests must not disturb the environment in a way that
|
||||
makes other tests fail (issue 18081).
|
||||
|
||||
To run an individual Testcase or test method, extend the dotted name given to
|
||||
unittest on the command line.
|
||||
|
||||
python -m unittest -v idlelib.idle_test.test_xyz.Test_case.test_meth
|
||||
|
||||
|
||||
4. Human-mediated Tests
|
||||
|
||||
Human-mediated tests are widget tests that cannot be automated but need human
|
||||
verification. They are contained in idlelib/idle_test/htest.py, which has
|
||||
instructions. (Some modules need an auxiliary function, identified with # htest
|
||||
# on the header line.) The set is about complete, though some tests need
|
||||
improvement. To run all htests, run the htest file from an editor or from the
|
||||
command line with:
|
||||
|
||||
python -m idlelib.idle_test.htest
|
||||
9
Darwin/lib/python3.5/idlelib/idle_test/__init__.py
Normal file
9
Darwin/lib/python3.5/idlelib/idle_test/__init__.py
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
from os.path import dirname
|
||||
|
||||
def load_tests(loader, standard_tests, pattern):
|
||||
this_dir = dirname(__file__)
|
||||
top_dir = dirname(dirname(this_dir))
|
||||
package_tests = loader.discover(start_dir=this_dir, pattern='test*.py',
|
||||
top_level_dir=top_dir)
|
||||
standard_tests.addTests(package_tests)
|
||||
return standard_tests
|
||||
407
Darwin/lib/python3.5/idlelib/idle_test/htest.py
Normal file
407
Darwin/lib/python3.5/idlelib/idle_test/htest.py
Normal file
|
|
@ -0,0 +1,407 @@
|
|||
'''Run human tests of Idle's window, dialog, and popup widgets.
|
||||
|
||||
run(*tests)
|
||||
Create a master Tk window. Within that, run each callable in tests
|
||||
after finding the matching test spec in this file. If tests is empty,
|
||||
run an htest for each spec dict in this file after finding the matching
|
||||
callable in the module named in the spec. Close the window to skip or
|
||||
end the test.
|
||||
|
||||
In a tested module, let X be a global name bound to a callable (class
|
||||
or function) whose .__name__ attrubute is also X (the usual situation).
|
||||
The first parameter of X must be 'parent'. When called, the parent
|
||||
argument will be the root window. X must create a child Toplevel
|
||||
window (or subclass thereof). The Toplevel may be a test widget or
|
||||
dialog, in which case the callable is the corresonding class. Or the
|
||||
Toplevel may contain the widget to be tested or set up a context in
|
||||
which a test widget is invoked. In this latter case, the callable is a
|
||||
wrapper function that sets up the Toplevel and other objects. Wrapper
|
||||
function names, such as _editor_window', should start with '_'.
|
||||
|
||||
|
||||
End the module with
|
||||
|
||||
if __name__ == '__main__':
|
||||
<unittest, if there is one>
|
||||
from idlelib.idle_test.htest import run
|
||||
run(X)
|
||||
|
||||
To have wrapper functions and test invocation code ignored by coveragepy
|
||||
reports, put '# htest #' on the def statement header line.
|
||||
|
||||
def _wrapper(parent): # htest #
|
||||
|
||||
Also make sure that the 'if __name__' line matches the above. Then have
|
||||
make sure that .coveragerc includes the following.
|
||||
|
||||
[report]
|
||||
exclude_lines =
|
||||
.*# htest #
|
||||
if __name__ == .__main__.:
|
||||
|
||||
(The "." instead of "'" is intentional and necessary.)
|
||||
|
||||
|
||||
To run any X, this file must contain a matching instance of the
|
||||
following template, with X.__name__ prepended to '_spec'.
|
||||
When all tests are run, the prefix is use to get X.
|
||||
|
||||
_spec = {
|
||||
'file': '',
|
||||
'kwds': {'title': ''},
|
||||
'msg': ""
|
||||
}
|
||||
|
||||
file (no .py): run() imports file.py.
|
||||
kwds: augmented with {'parent':root} and passed to X as **kwds.
|
||||
title: an example kwd; some widgets need this, delete if not.
|
||||
msg: master window hints about testing the widget.
|
||||
|
||||
|
||||
Modules and classes not being tested at the moment:
|
||||
PyShell.PyShellEditorWindow
|
||||
Debugger.Debugger
|
||||
AutoCompleteWindow.AutoCompleteWindow
|
||||
OutputWindow.OutputWindow (indirectly being tested with grep test)
|
||||
'''
|
||||
|
||||
from importlib import import_module
|
||||
from idlelib.macosxSupport import _initializeTkVariantTests
|
||||
import tkinter as tk
|
||||
|
||||
AboutDialog_spec = {
|
||||
'file': 'aboutDialog',
|
||||
'kwds': {'title': 'aboutDialog test',
|
||||
'_htest': True,
|
||||
},
|
||||
'msg': "Test every button. Ensure Python, TK and IDLE versions "
|
||||
"are correctly displayed.\n [Close] to exit.",
|
||||
}
|
||||
|
||||
_calltip_window_spec = {
|
||||
'file': 'CallTipWindow',
|
||||
'kwds': {},
|
||||
'msg': "Typing '(' should display a calltip.\n"
|
||||
"Typing ') should hide the calltip.\n"
|
||||
}
|
||||
|
||||
_class_browser_spec = {
|
||||
'file': 'ClassBrowser',
|
||||
'kwds': {},
|
||||
'msg': "Inspect names of module, class(with superclass if "
|
||||
"applicable), methods and functions.\nToggle nested items.\n"
|
||||
"Double clicking on items prints a traceback for an exception "
|
||||
"that is ignored."
|
||||
}
|
||||
ConfigExtensionsDialog_spec = {
|
||||
'file': 'configDialog',
|
||||
'kwds': {'title': 'Test Extension Configuration',
|
||||
'_htest': True,},
|
||||
'msg': "IDLE extensions dialog.\n"
|
||||
"\n[Ok] to close the dialog.[Apply] to apply the settings and "
|
||||
"and [Cancel] to revert all changes.\nRe-run the test to ensure "
|
||||
"changes made have persisted."
|
||||
}
|
||||
|
||||
_color_delegator_spec = {
|
||||
'file': 'ColorDelegator',
|
||||
'kwds': {},
|
||||
'msg': "The text is sample Python code.\n"
|
||||
"Ensure components like comments, keywords, builtins,\n"
|
||||
"string, definitions, and break are correctly colored.\n"
|
||||
"The default color scheme is in idlelib/config-highlight.def"
|
||||
}
|
||||
|
||||
ConfigDialog_spec = {
|
||||
'file': 'configDialog',
|
||||
'kwds': {'title': 'ConfigDialogTest',
|
||||
'_htest': True,},
|
||||
'msg': "IDLE preferences dialog.\n"
|
||||
"In the 'Fonts/Tabs' tab, changing font face, should update the "
|
||||
"font face of the text in the area below it.\nIn the "
|
||||
"'Highlighting' tab, try different color schemes. Clicking "
|
||||
"items in the sample program should update the choices above it."
|
||||
"\nIn the 'Keys' and 'General' tab, test settings of interest."
|
||||
"\n[Ok] to close the dialog.[Apply] to apply the settings and "
|
||||
"and [Cancel] to revert all changes.\nRe-run the test to ensure "
|
||||
"changes made have persisted."
|
||||
}
|
||||
|
||||
# TODO Improve message
|
||||
_dyn_option_menu_spec = {
|
||||
'file': 'dynOptionMenuWidget',
|
||||
'kwds': {},
|
||||
'msg': "Select one of the many options in the 'old option set'.\n"
|
||||
"Click the button to change the option set.\n"
|
||||
"Select one of the many options in the 'new option set'."
|
||||
}
|
||||
|
||||
# TODO edit wrapper
|
||||
_editor_window_spec = {
|
||||
'file': 'EditorWindow',
|
||||
'kwds': {},
|
||||
'msg': "Test editor functions of interest.\n"
|
||||
"Best to close editor first."
|
||||
}
|
||||
|
||||
GetCfgSectionNameDialog_spec = {
|
||||
'file': 'configSectionNameDialog',
|
||||
'kwds': {'title':'Get Name',
|
||||
'message':'Enter something',
|
||||
'used_names': {'abc'},
|
||||
'_htest': True},
|
||||
'msg': "After the text entered with [Ok] is stripped, <nothing>, "
|
||||
"'abc', or more that 30 chars are errors.\n"
|
||||
"Close 'Get Name' with a valid entry (printed to Shell), "
|
||||
"[Cancel], or [X]",
|
||||
}
|
||||
|
||||
GetHelpSourceDialog_spec = {
|
||||
'file': 'configHelpSourceEdit',
|
||||
'kwds': {'title': 'Get helpsource',
|
||||
'_htest': True},
|
||||
'msg': "Enter menu item name and help file path\n "
|
||||
"<nothing> and more than 30 chars are invalid menu item names.\n"
|
||||
"<nothing>, file does not exist are invalid path items.\n"
|
||||
"Test for incomplete web address for help file path.\n"
|
||||
"A valid entry will be printed to shell with [0k].\n"
|
||||
"[Cancel] will print None to shell",
|
||||
}
|
||||
|
||||
# Update once issue21519 is resolved.
|
||||
GetKeysDialog_spec = {
|
||||
'file': 'keybindingDialog',
|
||||
'kwds': {'title': 'Test keybindings',
|
||||
'action': 'find-again',
|
||||
'currentKeySequences': [''] ,
|
||||
'_htest': True,
|
||||
},
|
||||
'msg': "Test for different key modifier sequences.\n"
|
||||
"<nothing> is invalid.\n"
|
||||
"No modifier key is invalid.\n"
|
||||
"Shift key with [a-z],[0-9], function key, move key, tab, space"
|
||||
"is invalid.\nNo validity checking if advanced key binding "
|
||||
"entry is used."
|
||||
}
|
||||
|
||||
_grep_dialog_spec = {
|
||||
'file': 'GrepDialog',
|
||||
'kwds': {},
|
||||
'msg': "Click the 'Show GrepDialog' button.\n"
|
||||
"Test the various 'Find-in-files' functions.\n"
|
||||
"The results should be displayed in a new '*Output*' window.\n"
|
||||
"'Right-click'->'Goto file/line' anywhere in the search results "
|
||||
"should open that file \nin a new EditorWindow."
|
||||
}
|
||||
|
||||
_help_dialog_spec = {
|
||||
'file': 'EditorWindow',
|
||||
'kwds': {},
|
||||
'msg': "If the help text displays, this works.\n"
|
||||
"Text is selectable. Window is scrollable."
|
||||
}
|
||||
|
||||
_io_binding_spec = {
|
||||
'file': 'IOBinding',
|
||||
'kwds': {},
|
||||
'msg': "Test the following bindings\n"
|
||||
"<Control-o> to display open window from file dialog.\n"
|
||||
"<Control-s> to save the file\n"
|
||||
}
|
||||
|
||||
_multi_call_spec = {
|
||||
'file': 'MultiCall',
|
||||
'kwds': {},
|
||||
'msg': "The following actions should trigger a print to console or IDLE"
|
||||
" Shell.\nEntering and leaving the text area, key entry, "
|
||||
"<Control-Key>,\n<Alt-Key-a>, <Control-Key-a>, "
|
||||
"<Alt-Control-Key-a>, \n<Control-Button-1>, <Alt-Button-1> and "
|
||||
"focusing out of the window\nare sequences to be tested."
|
||||
}
|
||||
|
||||
_multistatus_bar_spec = {
|
||||
'file': 'MultiStatusBar',
|
||||
'kwds': {},
|
||||
'msg': "Ensure presence of multi-status bar below text area.\n"
|
||||
"Click 'Update Status' to change the multi-status text"
|
||||
}
|
||||
|
||||
_object_browser_spec = {
|
||||
'file': 'ObjectBrowser',
|
||||
'kwds': {},
|
||||
'msg': "Double click on items upto the lowest level.\n"
|
||||
"Attributes of the objects and related information "
|
||||
"will be displayed side-by-side at each level."
|
||||
}
|
||||
|
||||
_path_browser_spec = {
|
||||
'file': 'PathBrowser',
|
||||
'kwds': {},
|
||||
'msg': "Test for correct display of all paths in sys.path.\n"
|
||||
"Toggle nested items upto the lowest level.\n"
|
||||
"Double clicking on an item prints a traceback\n"
|
||||
"for an exception that is ignored."
|
||||
}
|
||||
|
||||
_percolator_spec = {
|
||||
'file': 'Percolator',
|
||||
'kwds': {},
|
||||
'msg': "There are two tracers which can be toggled using a checkbox.\n"
|
||||
"Toggling a tracer 'on' by checking it should print tracer"
|
||||
"output to the console or to the IDLE shell.\n"
|
||||
"If both the tracers are 'on', the output from the tracer which "
|
||||
"was switched 'on' later, should be printed first\n"
|
||||
"Test for actions like text entry, and removal."
|
||||
}
|
||||
|
||||
_replace_dialog_spec = {
|
||||
'file': 'ReplaceDialog',
|
||||
'kwds': {},
|
||||
'msg': "Click the 'Replace' button.\n"
|
||||
"Test various replace options in the 'Replace dialog'.\n"
|
||||
"Click [Close] or [X] to close the 'Replace Dialog'."
|
||||
}
|
||||
|
||||
_search_dialog_spec = {
|
||||
'file': 'SearchDialog',
|
||||
'kwds': {},
|
||||
'msg': "Click the 'Search' button.\n"
|
||||
"Test various search options in the 'Search dialog'.\n"
|
||||
"Click [Close] or [X] to close the 'Search Dialog'."
|
||||
}
|
||||
|
||||
_scrolled_list_spec = {
|
||||
'file': 'ScrolledList',
|
||||
'kwds': {},
|
||||
'msg': "You should see a scrollable list of items\n"
|
||||
"Selecting (clicking) or double clicking an item "
|
||||
"prints the name to the console or Idle shell.\n"
|
||||
"Right clicking an item will display a popup."
|
||||
}
|
||||
|
||||
_stack_viewer_spec = {
|
||||
'file': 'StackViewer',
|
||||
'kwds': {},
|
||||
'msg': "A stacktrace for a NameError exception.\n"
|
||||
"Expand 'idlelib ...' and '<locals>'.\n"
|
||||
"Check that exc_value, exc_tb, and exc_type are correct.\n"
|
||||
}
|
||||
|
||||
_tabbed_pages_spec = {
|
||||
'file': 'tabbedpages',
|
||||
'kwds': {},
|
||||
'msg': "Toggle between the two tabs 'foo' and 'bar'\n"
|
||||
"Add a tab by entering a suitable name for it.\n"
|
||||
"Remove an existing tab by entering its name.\n"
|
||||
"Remove all existing tabs.\n"
|
||||
"<nothing> is an invalid add page and remove page name.\n"
|
||||
}
|
||||
|
||||
TextViewer_spec = {
|
||||
'file': 'textView',
|
||||
'kwds': {'title': 'Test textView',
|
||||
'text':'The quick brown fox jumps over the lazy dog.\n'*35,
|
||||
'_htest': True},
|
||||
'msg': "Test for read-only property of text.\n"
|
||||
"Text is selectable. Window is scrollable.",
|
||||
}
|
||||
|
||||
_tooltip_spec = {
|
||||
'file': 'ToolTip',
|
||||
'kwds': {},
|
||||
'msg': "Place mouse cursor over both the buttons\n"
|
||||
"A tooltip should appear with some text."
|
||||
}
|
||||
|
||||
_tree_widget_spec = {
|
||||
'file': 'TreeWidget',
|
||||
'kwds': {},
|
||||
'msg': "The canvas is scrollable.\n"
|
||||
"Click on folders upto to the lowest level."
|
||||
}
|
||||
|
||||
_undo_delegator_spec = {
|
||||
'file': 'UndoDelegator',
|
||||
'kwds': {},
|
||||
'msg': "Click [Undo] to undo any action.\n"
|
||||
"Click [Redo] to redo any action.\n"
|
||||
"Click [Dump] to dump the current state "
|
||||
"by printing to the console or the IDLE shell.\n"
|
||||
}
|
||||
|
||||
_widget_redirector_spec = {
|
||||
'file': 'WidgetRedirector',
|
||||
'kwds': {},
|
||||
'msg': "Every text insert should be printed to the console."
|
||||
"or the IDLE shell."
|
||||
}
|
||||
|
||||
def run(*tests):
|
||||
root = tk.Tk()
|
||||
root.title('IDLE htest')
|
||||
root.resizable(0, 0)
|
||||
_initializeTkVariantTests(root)
|
||||
|
||||
# a scrollable Label like constant width text widget.
|
||||
frameLabel = tk.Frame(root, padx=10)
|
||||
frameLabel.pack()
|
||||
text = tk.Text(frameLabel, wrap='word')
|
||||
text.configure(bg=root.cget('bg'), relief='flat', height=4, width=70)
|
||||
scrollbar = tk.Scrollbar(frameLabel, command=text.yview)
|
||||
text.config(yscrollcommand=scrollbar.set)
|
||||
scrollbar.pack(side='right', fill='y', expand=False)
|
||||
text.pack(side='left', fill='both', expand=True)
|
||||
|
||||
test_list = [] # List of tuples of the form (spec, callable widget)
|
||||
if tests:
|
||||
for test in tests:
|
||||
test_spec = globals()[test.__name__ + '_spec']
|
||||
test_spec['name'] = test.__name__
|
||||
test_list.append((test_spec, test))
|
||||
else:
|
||||
for k, d in globals().items():
|
||||
if k.endswith('_spec'):
|
||||
test_name = k[:-5]
|
||||
test_spec = d
|
||||
test_spec['name'] = test_name
|
||||
mod = import_module('idlelib.' + test_spec['file'])
|
||||
test = getattr(mod, test_name)
|
||||
test_list.append((test_spec, test))
|
||||
|
||||
test_name = tk.StringVar('')
|
||||
callable_object = None
|
||||
test_kwds = None
|
||||
|
||||
def next():
|
||||
|
||||
nonlocal test_name, callable_object, test_kwds
|
||||
if len(test_list) == 1:
|
||||
next_button.pack_forget()
|
||||
test_spec, callable_object = test_list.pop()
|
||||
test_kwds = test_spec['kwds']
|
||||
test_kwds['parent'] = root
|
||||
test_name.set('Test ' + test_spec['name'])
|
||||
|
||||
text.configure(state='normal') # enable text editing
|
||||
text.delete('1.0','end')
|
||||
text.insert("1.0",test_spec['msg'])
|
||||
text.configure(state='disabled') # preserve read-only property
|
||||
|
||||
def run_test():
|
||||
widget = callable_object(**test_kwds)
|
||||
try:
|
||||
print(widget.result)
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
button = tk.Button(root, textvariable=test_name, command=run_test)
|
||||
button.pack()
|
||||
next_button = tk.Button(root, text="Next", command=next)
|
||||
next_button.pack()
|
||||
|
||||
next()
|
||||
|
||||
root.mainloop()
|
||||
|
||||
if __name__ == '__main__':
|
||||
run()
|
||||
55
Darwin/lib/python3.5/idlelib/idle_test/mock_idle.py
Normal file
55
Darwin/lib/python3.5/idlelib/idle_test/mock_idle.py
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
'''Mock classes that imitate idlelib modules or classes.
|
||||
|
||||
Attributes and methods will be added as needed for tests.
|
||||
'''
|
||||
|
||||
from idlelib.idle_test.mock_tk import Text
|
||||
|
||||
class Func:
|
||||
'''Mock function captures args and returns result set by test.
|
||||
|
||||
Attributes:
|
||||
self.called - records call even if no args, kwds passed.
|
||||
self.result - set by init, returned by call.
|
||||
self.args - captures positional arguments.
|
||||
self.kwds - captures keyword arguments.
|
||||
|
||||
Most common use will probably be to mock methods.
|
||||
Mock_tk.Var and Mbox_func are special variants of this.
|
||||
'''
|
||||
def __init__(self, result=None):
|
||||
self.called = False
|
||||
self.result = result
|
||||
self.args = None
|
||||
self.kwds = None
|
||||
def __call__(self, *args, **kwds):
|
||||
self.called = True
|
||||
self.args = args
|
||||
self.kwds = kwds
|
||||
if isinstance(self.result, BaseException):
|
||||
raise self.result
|
||||
else:
|
||||
return self.result
|
||||
|
||||
|
||||
class Editor:
|
||||
'''Minimally imitate EditorWindow.EditorWindow class.
|
||||
'''
|
||||
def __init__(self, flist=None, filename=None, key=None, root=None):
|
||||
self.text = Text()
|
||||
self.undo = UndoDelegator()
|
||||
|
||||
def get_selection_indices(self):
|
||||
first = self.text.index('1.0')
|
||||
last = self.text.index('end')
|
||||
return first, last
|
||||
|
||||
|
||||
class UndoDelegator:
|
||||
'''Minimally imitate UndoDelegator,UndoDelegator class.
|
||||
'''
|
||||
# A real undo block is only needed for user interaction.
|
||||
def undo_block_start(*args):
|
||||
pass
|
||||
def undo_block_stop(*args):
|
||||
pass
|
||||
298
Darwin/lib/python3.5/idlelib/idle_test/mock_tk.py
Normal file
298
Darwin/lib/python3.5/idlelib/idle_test/mock_tk.py
Normal file
|
|
@ -0,0 +1,298 @@
|
|||
"""Classes that replace tkinter gui objects used by an object being tested.
|
||||
|
||||
A gui object is anything with a master or parent parameter, which is
|
||||
typically required in spite of what the doc strings say.
|
||||
"""
|
||||
|
||||
class Event:
|
||||
'''Minimal mock with attributes for testing event handlers.
|
||||
|
||||
This is not a gui object, but is used as an argument for callbacks
|
||||
that access attributes of the event passed. If a callback ignores
|
||||
the event, other than the fact that is happened, pass 'event'.
|
||||
|
||||
Keyboard, mouse, window, and other sources generate Event instances.
|
||||
Event instances have the following attributes: serial (number of
|
||||
event), time (of event), type (of event as number), widget (in which
|
||||
event occurred), and x,y (position of mouse). There are other
|
||||
attributes for specific events, such as keycode for key events.
|
||||
tkinter.Event.__doc__ has more but is still not complete.
|
||||
'''
|
||||
def __init__(self, **kwds):
|
||||
"Create event with attributes needed for test"
|
||||
self.__dict__.update(kwds)
|
||||
|
||||
class Var:
|
||||
"Use for String/Int/BooleanVar: incomplete"
|
||||
def __init__(self, master=None, value=None, name=None):
|
||||
self.master = master
|
||||
self.value = value
|
||||
self.name = name
|
||||
def set(self, value):
|
||||
self.value = value
|
||||
def get(self):
|
||||
return self.value
|
||||
|
||||
class Mbox_func:
|
||||
"""Generic mock for messagebox functions, which all have the same signature.
|
||||
|
||||
Instead of displaying a message box, the mock's call method saves the
|
||||
arguments as instance attributes, which test functions can then examime.
|
||||
The test can set the result returned to ask function
|
||||
"""
|
||||
def __init__(self, result=None):
|
||||
self.result = result # Return None for all show funcs
|
||||
def __call__(self, title, message, *args, **kwds):
|
||||
# Save all args for possible examination by tester
|
||||
self.title = title
|
||||
self.message = message
|
||||
self.args = args
|
||||
self.kwds = kwds
|
||||
return self.result # Set by tester for ask functions
|
||||
|
||||
class Mbox:
|
||||
"""Mock for tkinter.messagebox with an Mbox_func for each function.
|
||||
|
||||
This module was 'tkMessageBox' in 2.x; hence the 'import as' in 3.x.
|
||||
Example usage in test_module.py for testing functions in module.py:
|
||||
---
|
||||
from idlelib.idle_test.mock_tk import Mbox
|
||||
import module
|
||||
|
||||
orig_mbox = module.tkMessageBox
|
||||
showerror = Mbox.showerror # example, for attribute access in test methods
|
||||
|
||||
class Test(unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
module.tkMessageBox = Mbox
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
module.tkMessageBox = orig_mbox
|
||||
---
|
||||
For 'ask' functions, set func.result return value before calling the method
|
||||
that uses the message function. When tkMessageBox functions are the
|
||||
only gui alls in a method, this replacement makes the method gui-free,
|
||||
"""
|
||||
askokcancel = Mbox_func() # True or False
|
||||
askquestion = Mbox_func() # 'yes' or 'no'
|
||||
askretrycancel = Mbox_func() # True or False
|
||||
askyesno = Mbox_func() # True or False
|
||||
askyesnocancel = Mbox_func() # True, False, or None
|
||||
showerror = Mbox_func() # None
|
||||
showinfo = Mbox_func() # None
|
||||
showwarning = Mbox_func() # None
|
||||
|
||||
from _tkinter import TclError
|
||||
|
||||
class Text:
|
||||
"""A semi-functional non-gui replacement for tkinter.Text text editors.
|
||||
|
||||
The mock's data model is that a text is a list of \n-terminated lines.
|
||||
The mock adds an empty string at the beginning of the list so that the
|
||||
index of actual lines start at 1, as with Tk. The methods never see this.
|
||||
Tk initializes files with a terminal \n that cannot be deleted. It is
|
||||
invisible in the sense that one cannot move the cursor beyond it.
|
||||
|
||||
This class is only tested (and valid) with strings of ascii chars.
|
||||
For testing, we are not concerned with Tk Text's treatment of,
|
||||
for instance, 0-width characters or character + accent.
|
||||
"""
|
||||
def __init__(self, master=None, cnf={}, **kw):
|
||||
'''Initialize mock, non-gui, text-only Text widget.
|
||||
|
||||
At present, all args are ignored. Almost all affect visual behavior.
|
||||
There are just a few Text-only options that affect text behavior.
|
||||
'''
|
||||
self.data = ['', '\n']
|
||||
|
||||
def index(self, index):
|
||||
"Return string version of index decoded according to current text."
|
||||
return "%s.%s" % self._decode(index, endflag=1)
|
||||
|
||||
def _decode(self, index, endflag=0):
|
||||
"""Return a (line, char) tuple of int indexes into self.data.
|
||||
|
||||
This implements .index without converting the result back to a string.
|
||||
The result is constrained by the number of lines and linelengths of
|
||||
self.data. For many indexes, the result is initially (1, 0).
|
||||
|
||||
The input index may have any of several possible forms:
|
||||
* line.char float: converted to 'line.char' string;
|
||||
* 'line.char' string, where line and char are decimal integers;
|
||||
* 'line.char lineend', where lineend='lineend' (and char is ignored);
|
||||
* 'line.end', where end='end' (same as above);
|
||||
* 'insert', the positions before terminal \n;
|
||||
* 'end', whose meaning depends on the endflag passed to ._endex.
|
||||
* 'sel.first' or 'sel.last', where sel is a tag -- not implemented.
|
||||
"""
|
||||
if isinstance(index, (float, bytes)):
|
||||
index = str(index)
|
||||
try:
|
||||
index=index.lower()
|
||||
except AttributeError:
|
||||
raise TclError('bad text index "%s"' % index) from None
|
||||
|
||||
lastline = len(self.data) - 1 # same as number of text lines
|
||||
if index == 'insert':
|
||||
return lastline, len(self.data[lastline]) - 1
|
||||
elif index == 'end':
|
||||
return self._endex(endflag)
|
||||
|
||||
line, char = index.split('.')
|
||||
line = int(line)
|
||||
|
||||
# Out of bounds line becomes first or last ('end') index
|
||||
if line < 1:
|
||||
return 1, 0
|
||||
elif line > lastline:
|
||||
return self._endex(endflag)
|
||||
|
||||
linelength = len(self.data[line]) -1 # position before/at \n
|
||||
if char.endswith(' lineend') or char == 'end':
|
||||
return line, linelength
|
||||
# Tk requires that ignored chars before ' lineend' be valid int
|
||||
|
||||
# Out of bounds char becomes first or last index of line
|
||||
char = int(char)
|
||||
if char < 0:
|
||||
char = 0
|
||||
elif char > linelength:
|
||||
char = linelength
|
||||
return line, char
|
||||
|
||||
def _endex(self, endflag):
|
||||
'''Return position for 'end' or line overflow corresponding to endflag.
|
||||
|
||||
-1: position before terminal \n; for .insert(), .delete
|
||||
0: position after terminal \n; for .get, .delete index 1
|
||||
1: same viewed as beginning of non-existent next line (for .index)
|
||||
'''
|
||||
n = len(self.data)
|
||||
if endflag == 1:
|
||||
return n, 0
|
||||
else:
|
||||
n -= 1
|
||||
return n, len(self.data[n]) + endflag
|
||||
|
||||
|
||||
def insert(self, index, chars):
|
||||
"Insert chars before the character at index."
|
||||
|
||||
if not chars: # ''.splitlines() is [], not ['']
|
||||
return
|
||||
chars = chars.splitlines(True)
|
||||
if chars[-1][-1] == '\n':
|
||||
chars.append('')
|
||||
line, char = self._decode(index, -1)
|
||||
before = self.data[line][:char]
|
||||
after = self.data[line][char:]
|
||||
self.data[line] = before + chars[0]
|
||||
self.data[line+1:line+1] = chars[1:]
|
||||
self.data[line+len(chars)-1] += after
|
||||
|
||||
|
||||
def get(self, index1, index2=None):
|
||||
"Return slice from index1 to index2 (default is 'index1+1')."
|
||||
|
||||
startline, startchar = self._decode(index1)
|
||||
if index2 is None:
|
||||
endline, endchar = startline, startchar+1
|
||||
else:
|
||||
endline, endchar = self._decode(index2)
|
||||
|
||||
if startline == endline:
|
||||
return self.data[startline][startchar:endchar]
|
||||
else:
|
||||
lines = [self.data[startline][startchar:]]
|
||||
for i in range(startline+1, endline):
|
||||
lines.append(self.data[i])
|
||||
lines.append(self.data[endline][:endchar])
|
||||
return ''.join(lines)
|
||||
|
||||
|
||||
def delete(self, index1, index2=None):
|
||||
'''Delete slice from index1 to index2 (default is 'index1+1').
|
||||
|
||||
Adjust default index2 ('index+1) for line ends.
|
||||
Do not delete the terminal \n at the very end of self.data ([-1][-1]).
|
||||
'''
|
||||
startline, startchar = self._decode(index1, -1)
|
||||
if index2 is None:
|
||||
if startchar < len(self.data[startline])-1:
|
||||
# not deleting \n
|
||||
endline, endchar = startline, startchar+1
|
||||
elif startline < len(self.data) - 1:
|
||||
# deleting non-terminal \n, convert 'index1+1 to start of next line
|
||||
endline, endchar = startline+1, 0
|
||||
else:
|
||||
# do not delete terminal \n if index1 == 'insert'
|
||||
return
|
||||
else:
|
||||
endline, endchar = self._decode(index2, -1)
|
||||
# restricting end position to insert position excludes terminal \n
|
||||
|
||||
if startline == endline and startchar < endchar:
|
||||
self.data[startline] = self.data[startline][:startchar] + \
|
||||
self.data[startline][endchar:]
|
||||
elif startline < endline:
|
||||
self.data[startline] = self.data[startline][:startchar] + \
|
||||
self.data[endline][endchar:]
|
||||
startline += 1
|
||||
for i in range(startline, endline+1):
|
||||
del self.data[startline]
|
||||
|
||||
def compare(self, index1, op, index2):
|
||||
line1, char1 = self._decode(index1)
|
||||
line2, char2 = self._decode(index2)
|
||||
if op == '<':
|
||||
return line1 < line2 or line1 == line2 and char1 < char2
|
||||
elif op == '<=':
|
||||
return line1 < line2 or line1 == line2 and char1 <= char2
|
||||
elif op == '>':
|
||||
return line1 > line2 or line1 == line2 and char1 > char2
|
||||
elif op == '>=':
|
||||
return line1 > line2 or line1 == line2 and char1 >= char2
|
||||
elif op == '==':
|
||||
return line1 == line2 and char1 == char2
|
||||
elif op == '!=':
|
||||
return line1 != line2 or char1 != char2
|
||||
else:
|
||||
raise TclError('''bad comparison operator "%s":'''
|
||||
'''must be <, <=, ==, >=, >, or !=''' % op)
|
||||
|
||||
# The following Text methods normally do something and return None.
|
||||
# Whether doing nothing is sufficient for a test will depend on the test.
|
||||
|
||||
def mark_set(self, name, index):
|
||||
"Set mark *name* before the character at index."
|
||||
pass
|
||||
|
||||
def mark_unset(self, *markNames):
|
||||
"Delete all marks in markNames."
|
||||
|
||||
def tag_remove(self, tagName, index1, index2=None):
|
||||
"Remove tag tagName from all characters between index1 and index2."
|
||||
pass
|
||||
|
||||
# The following Text methods affect the graphics screen and return None.
|
||||
# Doing nothing should always be sufficient for tests.
|
||||
|
||||
def scan_dragto(self, x, y):
|
||||
"Adjust the view of the text according to scan_mark"
|
||||
|
||||
def scan_mark(self, x, y):
|
||||
"Remember the current X, Y coordinates."
|
||||
|
||||
def see(self, index):
|
||||
"Scroll screen to make the character at INDEX is visible."
|
||||
pass
|
||||
|
||||
# The following is a Misc method inherited by Text.
|
||||
# It should properly go in a Misc mock, but is included here for now.
|
||||
|
||||
def bind(sequence=None, func=None, add=None):
|
||||
"Bind to this widget at event sequence a call to function func."
|
||||
pass
|
||||
143
Darwin/lib/python3.5/idlelib/idle_test/test_autocomplete.py
Normal file
143
Darwin/lib/python3.5/idlelib/idle_test/test_autocomplete.py
Normal file
|
|
@ -0,0 +1,143 @@
|
|||
import unittest
|
||||
from test.support import requires
|
||||
from tkinter import Tk, Text
|
||||
|
||||
import idlelib.AutoComplete as ac
|
||||
import idlelib.AutoCompleteWindow as acw
|
||||
import idlelib.macosxSupport as mac
|
||||
from idlelib.idle_test.mock_idle import Func
|
||||
from idlelib.idle_test.mock_tk import Event
|
||||
|
||||
class AutoCompleteWindow:
|
||||
def complete():
|
||||
return
|
||||
|
||||
class DummyEditwin:
|
||||
def __init__(self, root, text):
|
||||
self.root = root
|
||||
self.text = text
|
||||
self.indentwidth = 8
|
||||
self.tabwidth = 8
|
||||
self.context_use_ps1 = True
|
||||
|
||||
|
||||
class AutoCompleteTest(unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
requires('gui')
|
||||
cls.root = Tk()
|
||||
mac.setupApp(cls.root, None)
|
||||
cls.text = Text(cls.root)
|
||||
cls.editor = DummyEditwin(cls.root, cls.text)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.root.destroy()
|
||||
del cls.text
|
||||
del cls.editor
|
||||
del cls.root
|
||||
|
||||
def setUp(self):
|
||||
self.editor.text.delete('1.0', 'end')
|
||||
self.autocomplete = ac.AutoComplete(self.editor)
|
||||
|
||||
def test_init(self):
|
||||
self.assertEqual(self.autocomplete.editwin, self.editor)
|
||||
|
||||
def test_make_autocomplete_window(self):
|
||||
testwin = self.autocomplete._make_autocomplete_window()
|
||||
self.assertIsInstance(testwin, acw.AutoCompleteWindow)
|
||||
|
||||
def test_remove_autocomplete_window(self):
|
||||
self.autocomplete.autocompletewindow = (
|
||||
self.autocomplete._make_autocomplete_window())
|
||||
self.autocomplete._remove_autocomplete_window()
|
||||
self.assertIsNone(self.autocomplete.autocompletewindow)
|
||||
|
||||
def test_force_open_completions_event(self):
|
||||
# Test that force_open_completions_event calls _open_completions
|
||||
o_cs = Func()
|
||||
self.autocomplete.open_completions = o_cs
|
||||
self.autocomplete.force_open_completions_event('event')
|
||||
self.assertEqual(o_cs.args, (True, False, True))
|
||||
|
||||
def test_try_open_completions_event(self):
|
||||
Equal = self.assertEqual
|
||||
autocomplete = self.autocomplete
|
||||
trycompletions = self.autocomplete.try_open_completions_event
|
||||
o_c_l = Func()
|
||||
autocomplete._open_completions_later = o_c_l
|
||||
|
||||
# _open_completions_later should not be called with no text in editor
|
||||
trycompletions('event')
|
||||
Equal(o_c_l.args, None)
|
||||
|
||||
# _open_completions_later should be called with COMPLETE_ATTRIBUTES (1)
|
||||
self.text.insert('1.0', 're.')
|
||||
trycompletions('event')
|
||||
Equal(o_c_l.args, (False, False, False, 1))
|
||||
|
||||
# _open_completions_later should be called with COMPLETE_FILES (2)
|
||||
self.text.delete('1.0', 'end')
|
||||
self.text.insert('1.0', '"./Lib/')
|
||||
trycompletions('event')
|
||||
Equal(o_c_l.args, (False, False, False, 2))
|
||||
|
||||
def test_autocomplete_event(self):
|
||||
Equal = self.assertEqual
|
||||
autocomplete = self.autocomplete
|
||||
|
||||
# Test that the autocomplete event is ignored if user is pressing a
|
||||
# modifier key in addition to the tab key
|
||||
ev = Event(mc_state=True)
|
||||
self.assertIsNone(autocomplete.autocomplete_event(ev))
|
||||
del ev.mc_state
|
||||
|
||||
# If autocomplete window is open, complete() method is called
|
||||
self.text.insert('1.0', 're.')
|
||||
# This must call autocomplete._make_autocomplete_window()
|
||||
Equal(self.autocomplete.autocomplete_event(ev), 'break')
|
||||
|
||||
# If autocomplete window is not active or does not exist,
|
||||
# open_completions is called. Return depends on its return.
|
||||
autocomplete._remove_autocomplete_window()
|
||||
o_cs = Func() # .result = None
|
||||
autocomplete.open_completions = o_cs
|
||||
Equal(self.autocomplete.autocomplete_event(ev), None)
|
||||
Equal(o_cs.args, (False, True, True))
|
||||
o_cs.result = True
|
||||
Equal(self.autocomplete.autocomplete_event(ev), 'break')
|
||||
Equal(o_cs.args, (False, True, True))
|
||||
|
||||
def test_open_completions_later(self):
|
||||
# Test that autocomplete._delayed_completion_id is set
|
||||
pass
|
||||
|
||||
def test_delayed_open_completions(self):
|
||||
# Test that autocomplete._delayed_completion_id set to None and that
|
||||
# open_completions only called if insertion index is the same as
|
||||
# _delayed_completion_index
|
||||
pass
|
||||
|
||||
def test_open_completions(self):
|
||||
# Test completions of files and attributes as well as non-completion
|
||||
# of errors
|
||||
pass
|
||||
|
||||
def test_fetch_completions(self):
|
||||
# Test that fetch_completions returns 2 lists:
|
||||
# For attribute completion, a large list containing all variables, and
|
||||
# a small list containing non-private variables.
|
||||
# For file completion, a large list containing all files in the path,
|
||||
# and a small list containing files that do not start with '.'
|
||||
pass
|
||||
|
||||
def test_get_entity(self):
|
||||
# Test that a name is in the namespace of sys.modules and
|
||||
# __main__.__dict__
|
||||
pass
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2)
|
||||
141
Darwin/lib/python3.5/idlelib/idle_test/test_autoexpand.py
Normal file
141
Darwin/lib/python3.5/idlelib/idle_test/test_autoexpand.py
Normal file
|
|
@ -0,0 +1,141 @@
|
|||
"""Unit tests for idlelib.AutoExpand"""
|
||||
import unittest
|
||||
from test.support import requires
|
||||
from tkinter import Text, Tk
|
||||
#from idlelib.idle_test.mock_tk import Text
|
||||
from idlelib.AutoExpand import AutoExpand
|
||||
|
||||
|
||||
class Dummy_Editwin:
|
||||
# AutoExpand.__init__ only needs .text
|
||||
def __init__(self, text):
|
||||
self.text = text
|
||||
|
||||
class AutoExpandTest(unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
if 'tkinter' in str(Text):
|
||||
requires('gui')
|
||||
cls.tk = Tk()
|
||||
cls.text = Text(cls.tk)
|
||||
else:
|
||||
cls.text = Text()
|
||||
cls.auto_expand = AutoExpand(Dummy_Editwin(cls.text))
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
if hasattr(cls, 'tk'):
|
||||
cls.tk.destroy()
|
||||
del cls.tk
|
||||
del cls.text, cls.auto_expand
|
||||
|
||||
def tearDown(self):
|
||||
self.text.delete('1.0', 'end')
|
||||
|
||||
def test_get_prevword(self):
|
||||
text = self.text
|
||||
previous = self.auto_expand.getprevword
|
||||
equal = self.assertEqual
|
||||
|
||||
equal(previous(), '')
|
||||
|
||||
text.insert('insert', 't')
|
||||
equal(previous(), 't')
|
||||
|
||||
text.insert('insert', 'his')
|
||||
equal(previous(), 'this')
|
||||
|
||||
text.insert('insert', ' ')
|
||||
equal(previous(), '')
|
||||
|
||||
text.insert('insert', 'is')
|
||||
equal(previous(), 'is')
|
||||
|
||||
text.insert('insert', '\nsample\nstring')
|
||||
equal(previous(), 'string')
|
||||
|
||||
text.delete('3.0', 'insert')
|
||||
equal(previous(), '')
|
||||
|
||||
text.delete('1.0', 'end')
|
||||
equal(previous(), '')
|
||||
|
||||
def test_before_only(self):
|
||||
previous = self.auto_expand.getprevword
|
||||
expand = self.auto_expand.expand_word_event
|
||||
equal = self.assertEqual
|
||||
|
||||
self.text.insert('insert', 'ab ac bx ad ab a')
|
||||
equal(self.auto_expand.getwords(), ['ab', 'ad', 'ac', 'a'])
|
||||
expand('event')
|
||||
equal(previous(), 'ab')
|
||||
expand('event')
|
||||
equal(previous(), 'ad')
|
||||
expand('event')
|
||||
equal(previous(), 'ac')
|
||||
expand('event')
|
||||
equal(previous(), 'a')
|
||||
|
||||
def test_after_only(self):
|
||||
# Also add punctuation 'noise' that should be ignored.
|
||||
text = self.text
|
||||
previous = self.auto_expand.getprevword
|
||||
expand = self.auto_expand.expand_word_event
|
||||
equal = self.assertEqual
|
||||
|
||||
text.insert('insert', 'a, [ab] ac: () bx"" cd ac= ad ya')
|
||||
text.mark_set('insert', '1.1')
|
||||
equal(self.auto_expand.getwords(), ['ab', 'ac', 'ad', 'a'])
|
||||
expand('event')
|
||||
equal(previous(), 'ab')
|
||||
expand('event')
|
||||
equal(previous(), 'ac')
|
||||
expand('event')
|
||||
equal(previous(), 'ad')
|
||||
expand('event')
|
||||
equal(previous(), 'a')
|
||||
|
||||
def test_both_before_after(self):
|
||||
text = self.text
|
||||
previous = self.auto_expand.getprevword
|
||||
expand = self.auto_expand.expand_word_event
|
||||
equal = self.assertEqual
|
||||
|
||||
text.insert('insert', 'ab xy yz\n')
|
||||
text.insert('insert', 'a ac by ac')
|
||||
|
||||
text.mark_set('insert', '2.1')
|
||||
equal(self.auto_expand.getwords(), ['ab', 'ac', 'a'])
|
||||
expand('event')
|
||||
equal(previous(), 'ab')
|
||||
expand('event')
|
||||
equal(previous(), 'ac')
|
||||
expand('event')
|
||||
equal(previous(), 'a')
|
||||
|
||||
def test_other_expand_cases(self):
|
||||
text = self.text
|
||||
expand = self.auto_expand.expand_word_event
|
||||
equal = self.assertEqual
|
||||
|
||||
# no expansion candidate found
|
||||
equal(self.auto_expand.getwords(), [])
|
||||
equal(expand('event'), 'break')
|
||||
|
||||
text.insert('insert', 'bx cy dz a')
|
||||
equal(self.auto_expand.getwords(), [])
|
||||
|
||||
# reset state by successfully expanding once
|
||||
# move cursor to another position and expand again
|
||||
text.insert('insert', 'ac xy a ac ad a')
|
||||
text.mark_set('insert', '1.7')
|
||||
expand('event')
|
||||
initial_state = self.auto_expand.state
|
||||
text.mark_set('insert', '1.end')
|
||||
expand('event')
|
||||
new_state = self.auto_expand.state
|
||||
self.assertNotEqual(initial_state, new_state)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2)
|
||||
177
Darwin/lib/python3.5/idlelib/idle_test/test_calltips.py
Normal file
177
Darwin/lib/python3.5/idlelib/idle_test/test_calltips.py
Normal file
|
|
@ -0,0 +1,177 @@
|
|||
import unittest
|
||||
import idlelib.CallTips as ct
|
||||
import textwrap
|
||||
import types
|
||||
|
||||
default_tip = ct._default_callable_argspec
|
||||
|
||||
# Test Class TC is used in multiple get_argspec test methods
|
||||
class TC():
|
||||
'doc'
|
||||
tip = "(ai=None, *b)"
|
||||
def __init__(self, ai=None, *b): 'doc'
|
||||
__init__.tip = "(self, ai=None, *b)"
|
||||
def t1(self): 'doc'
|
||||
t1.tip = "(self)"
|
||||
def t2(self, ai, b=None): 'doc'
|
||||
t2.tip = "(self, ai, b=None)"
|
||||
def t3(self, ai, *args): 'doc'
|
||||
t3.tip = "(self, ai, *args)"
|
||||
def t4(self, *args): 'doc'
|
||||
t4.tip = "(self, *args)"
|
||||
def t5(self, ai, b=None, *args, **kw): 'doc'
|
||||
t5.tip = "(self, ai, b=None, *args, **kw)"
|
||||
def t6(no, self): 'doc'
|
||||
t6.tip = "(no, self)"
|
||||
def __call__(self, ci): 'doc'
|
||||
__call__.tip = "(self, ci)"
|
||||
# attaching .tip to wrapped methods does not work
|
||||
@classmethod
|
||||
def cm(cls, a): 'doc'
|
||||
@staticmethod
|
||||
def sm(b): 'doc'
|
||||
|
||||
tc = TC()
|
||||
|
||||
signature = ct.get_argspec # 2.7 and 3.x use different functions
|
||||
class Get_signatureTest(unittest.TestCase):
|
||||
# The signature function must return a string, even if blank.
|
||||
# Test a variety of objects to be sure that none cause it to raise
|
||||
# (quite aside from getting as correct an answer as possible).
|
||||
# The tests of builtins may break if inspect or the docstrings change,
|
||||
# but a red buildbot is better than a user crash (as has happened).
|
||||
# For a simple mismatch, change the expected output to the actual.
|
||||
|
||||
def test_builtins(self):
|
||||
|
||||
# Python class that inherits builtin methods
|
||||
class List(list): "List() doc"
|
||||
# Simulate builtin with no docstring for default tip test
|
||||
class SB: __call__ = None
|
||||
|
||||
def gtest(obj, out):
|
||||
self.assertEqual(signature(obj), out)
|
||||
|
||||
if List.__doc__ is not None:
|
||||
gtest(List, List.__doc__)
|
||||
gtest(list.__new__,
|
||||
'Create and return a new object. See help(type) for accurate signature.')
|
||||
gtest(list.__init__,
|
||||
'Initialize self. See help(type(self)) for accurate signature.')
|
||||
append_doc = "L.append(object) -> None -- append object to end"
|
||||
gtest(list.append, append_doc)
|
||||
gtest([].append, append_doc)
|
||||
gtest(List.append, append_doc)
|
||||
|
||||
gtest(types.MethodType, "method(function, instance)")
|
||||
gtest(SB(), default_tip)
|
||||
|
||||
def test_signature_wrap(self):
|
||||
if textwrap.TextWrapper.__doc__ is not None:
|
||||
self.assertEqual(signature(textwrap.TextWrapper), '''\
|
||||
(width=70, initial_indent='', subsequent_indent='', expand_tabs=True,
|
||||
replace_whitespace=True, fix_sentence_endings=False, break_long_words=True,
|
||||
drop_whitespace=True, break_on_hyphens=True, tabsize=8, *, max_lines=None,
|
||||
placeholder=' [...]')''')
|
||||
|
||||
def test_docline_truncation(self):
|
||||
def f(): pass
|
||||
f.__doc__ = 'a'*300
|
||||
self.assertEqual(signature(f), '()\n' + 'a' * (ct._MAX_COLS-3) + '...')
|
||||
|
||||
def test_multiline_docstring(self):
|
||||
# Test fewer lines than max.
|
||||
self.assertEqual(signature(list),
|
||||
"list() -> new empty list\n"
|
||||
"list(iterable) -> new list initialized from iterable's items")
|
||||
|
||||
# Test max lines
|
||||
self.assertEqual(signature(bytes), '''\
|
||||
bytes(iterable_of_ints) -> bytes
|
||||
bytes(string, encoding[, errors]) -> bytes
|
||||
bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
|
||||
bytes(int) -> bytes object of size given by the parameter initialized with null bytes
|
||||
bytes() -> empty bytes object''')
|
||||
|
||||
# Test more than max lines
|
||||
def f(): pass
|
||||
f.__doc__ = 'a\n' * 15
|
||||
self.assertEqual(signature(f), '()' + '\na' * ct._MAX_LINES)
|
||||
|
||||
def test_functions(self):
|
||||
def t1(): 'doc'
|
||||
t1.tip = "()"
|
||||
def t2(a, b=None): 'doc'
|
||||
t2.tip = "(a, b=None)"
|
||||
def t3(a, *args): 'doc'
|
||||
t3.tip = "(a, *args)"
|
||||
def t4(*args): 'doc'
|
||||
t4.tip = "(*args)"
|
||||
def t5(a, b=None, *args, **kw): 'doc'
|
||||
t5.tip = "(a, b=None, *args, **kw)"
|
||||
|
||||
doc = '\ndoc' if t1.__doc__ is not None else ''
|
||||
for func in (t1, t2, t3, t4, t5, TC):
|
||||
self.assertEqual(signature(func), func.tip + doc)
|
||||
|
||||
def test_methods(self):
|
||||
doc = '\ndoc' if TC.__doc__ is not None else ''
|
||||
for meth in (TC.t1, TC.t2, TC.t3, TC.t4, TC.t5, TC.t6, TC.__call__):
|
||||
self.assertEqual(signature(meth), meth.tip + doc)
|
||||
self.assertEqual(signature(TC.cm), "(a)" + doc)
|
||||
self.assertEqual(signature(TC.sm), "(b)" + doc)
|
||||
|
||||
def test_bound_methods(self):
|
||||
# test that first parameter is correctly removed from argspec
|
||||
doc = '\ndoc' if TC.__doc__ is not None else ''
|
||||
for meth, mtip in ((tc.t1, "()"), (tc.t4, "(*args)"), (tc.t6, "(self)"),
|
||||
(tc.__call__, '(ci)'), (tc, '(ci)'), (TC.cm, "(a)"),):
|
||||
self.assertEqual(signature(meth), mtip + doc)
|
||||
|
||||
def test_starred_parameter(self):
|
||||
# test that starred first parameter is *not* removed from argspec
|
||||
class C:
|
||||
def m1(*args): pass
|
||||
def m2(**kwds): pass
|
||||
c = C()
|
||||
for meth, mtip in ((C.m1, '(*args)'), (c.m1, "(*args)"),
|
||||
(C.m2, "(**kwds)"), (c.m2, "(**kwds)"),):
|
||||
self.assertEqual(signature(meth), mtip)
|
||||
|
||||
def test_non_ascii_name(self):
|
||||
# test that re works to delete a first parameter name that
|
||||
# includes non-ascii chars, such as various forms of A.
|
||||
uni = "(A\u0391\u0410\u05d0\u0627\u0905\u1e00\u3042, a)"
|
||||
assert ct._first_param.sub('', uni) == '(a)'
|
||||
|
||||
def test_no_docstring(self):
|
||||
def nd(s):
|
||||
pass
|
||||
TC.nd = nd
|
||||
self.assertEqual(signature(nd), "(s)")
|
||||
self.assertEqual(signature(TC.nd), "(s)")
|
||||
self.assertEqual(signature(tc.nd), "()")
|
||||
|
||||
def test_attribute_exception(self):
|
||||
class NoCall:
|
||||
def __getattr__(self, name):
|
||||
raise BaseException
|
||||
class Call(NoCall):
|
||||
def __call__(self, ci):
|
||||
pass
|
||||
for meth, mtip in ((NoCall, default_tip), (Call, default_tip),
|
||||
(NoCall(), ''), (Call(), '(ci)')):
|
||||
self.assertEqual(signature(meth), mtip)
|
||||
|
||||
def test_non_callables(self):
|
||||
for obj in (0, 0.0, '0', b'0', [], {}):
|
||||
self.assertEqual(signature(obj), '')
|
||||
|
||||
class Get_entityTest(unittest.TestCase):
|
||||
def test_bad_entity(self):
|
||||
self.assertIsNone(ct.get_entity('1/0'))
|
||||
def test_good_entity(self):
|
||||
self.assertIs(ct.get_entity('int'), int)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2, exit=False)
|
||||
75
Darwin/lib/python3.5/idlelib/idle_test/test_config_name.py
Normal file
75
Darwin/lib/python3.5/idlelib/idle_test/test_config_name.py
Normal file
|
|
@ -0,0 +1,75 @@
|
|||
"""Unit tests for idlelib.configSectionNameDialog"""
|
||||
import unittest
|
||||
from idlelib.idle_test.mock_tk import Var, Mbox
|
||||
from idlelib import configSectionNameDialog as name_dialog_module
|
||||
|
||||
name_dialog = name_dialog_module.GetCfgSectionNameDialog
|
||||
|
||||
class Dummy_name_dialog:
|
||||
# Mock for testing the following methods of name_dialog
|
||||
name_ok = name_dialog.name_ok
|
||||
Ok = name_dialog.Ok
|
||||
Cancel = name_dialog.Cancel
|
||||
# Attributes, constant or variable, needed for tests
|
||||
used_names = ['used']
|
||||
name = Var()
|
||||
result = None
|
||||
destroyed = False
|
||||
def destroy(self):
|
||||
self.destroyed = True
|
||||
|
||||
# name_ok calls Mbox.showerror if name is not ok
|
||||
orig_mbox = name_dialog_module.tkMessageBox
|
||||
showerror = Mbox.showerror
|
||||
|
||||
class ConfigNameTest(unittest.TestCase):
|
||||
dialog = Dummy_name_dialog()
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
name_dialog_module.tkMessageBox = Mbox
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
name_dialog_module.tkMessageBox = orig_mbox
|
||||
|
||||
def test_blank_name(self):
|
||||
self.dialog.name.set(' ')
|
||||
self.assertEqual(self.dialog.name_ok(), '')
|
||||
self.assertEqual(showerror.title, 'Name Error')
|
||||
self.assertIn('No', showerror.message)
|
||||
|
||||
def test_used_name(self):
|
||||
self.dialog.name.set('used')
|
||||
self.assertEqual(self.dialog.name_ok(), '')
|
||||
self.assertEqual(showerror.title, 'Name Error')
|
||||
self.assertIn('use', showerror.message)
|
||||
|
||||
def test_long_name(self):
|
||||
self.dialog.name.set('good'*8)
|
||||
self.assertEqual(self.dialog.name_ok(), '')
|
||||
self.assertEqual(showerror.title, 'Name Error')
|
||||
self.assertIn('too long', showerror.message)
|
||||
|
||||
def test_good_name(self):
|
||||
self.dialog.name.set(' good ')
|
||||
showerror.title = 'No Error' # should not be called
|
||||
self.assertEqual(self.dialog.name_ok(), 'good')
|
||||
self.assertEqual(showerror.title, 'No Error')
|
||||
|
||||
def test_ok(self):
|
||||
self.dialog.destroyed = False
|
||||
self.dialog.name.set('good')
|
||||
self.dialog.Ok()
|
||||
self.assertEqual(self.dialog.result, 'good')
|
||||
self.assertTrue(self.dialog.destroyed)
|
||||
|
||||
def test_cancel(self):
|
||||
self.dialog.destroyed = False
|
||||
self.dialog.Cancel()
|
||||
self.assertEqual(self.dialog.result, '')
|
||||
self.assertTrue(self.dialog.destroyed)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2, exit=False)
|
||||
32
Darwin/lib/python3.5/idlelib/idle_test/test_configdialog.py
Normal file
32
Darwin/lib/python3.5/idlelib/idle_test/test_configdialog.py
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
'''Unittests for idlelib/configHandler.py
|
||||
|
||||
Coverage: 46% just by creating dialog. The other half is change code.
|
||||
|
||||
'''
|
||||
import unittest
|
||||
from test.support import requires
|
||||
from tkinter import Tk
|
||||
from idlelib.configDialog import ConfigDialog
|
||||
from idlelib.macosxSupport import _initializeTkVariantTests
|
||||
|
||||
|
||||
class ConfigDialogTest(unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
requires('gui')
|
||||
cls.root = Tk()
|
||||
_initializeTkVariantTests(cls.root)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.root.destroy()
|
||||
del cls.root
|
||||
|
||||
def test_dialog(self):
|
||||
d=ConfigDialog(self.root, 'Test', _utest=True)
|
||||
d.destroy()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2)
|
||||
37
Darwin/lib/python3.5/idlelib/idle_test/test_delegator.py
Normal file
37
Darwin/lib/python3.5/idlelib/idle_test/test_delegator.py
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
import unittest
|
||||
from idlelib.Delegator import Delegator
|
||||
|
||||
class DelegatorTest(unittest.TestCase):
|
||||
|
||||
def test_mydel(self):
|
||||
# test a simple use scenario
|
||||
|
||||
# initialize
|
||||
mydel = Delegator(int)
|
||||
self.assertIs(mydel.delegate, int)
|
||||
self.assertEqual(mydel._Delegator__cache, set())
|
||||
|
||||
# add an attribute:
|
||||
self.assertRaises(AttributeError, mydel.__getattr__, 'xyz')
|
||||
bl = mydel.bit_length
|
||||
self.assertIs(bl, int.bit_length)
|
||||
self.assertIs(mydel.__dict__['bit_length'], int.bit_length)
|
||||
self.assertEqual(mydel._Delegator__cache, {'bit_length'})
|
||||
|
||||
# add a second attribute
|
||||
mydel.numerator
|
||||
self.assertEqual(mydel._Delegator__cache, {'bit_length', 'numerator'})
|
||||
|
||||
# delete the second (which, however, leaves it in the name cache)
|
||||
del mydel.numerator
|
||||
self.assertNotIn('numerator', mydel.__dict__)
|
||||
self.assertIn('numerator', mydel._Delegator__cache)
|
||||
|
||||
# reset by calling .setdelegate, which calls .resetcache
|
||||
mydel.setdelegate(float)
|
||||
self.assertIs(mydel.delegate, float)
|
||||
self.assertNotIn('bit_length', mydel.__dict__)
|
||||
self.assertEqual(mydel._Delegator__cache, set())
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2, exit=2)
|
||||
16
Darwin/lib/python3.5/idlelib/idle_test/test_editor.py
Normal file
16
Darwin/lib/python3.5/idlelib/idle_test/test_editor.py
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
import unittest
|
||||
from tkinter import Tk, Text
|
||||
from idlelib.EditorWindow import EditorWindow
|
||||
from test.support import requires
|
||||
|
||||
class Editor_func_test(unittest.TestCase):
|
||||
def test_filename_to_unicode(self):
|
||||
func = EditorWindow._filename_to_unicode
|
||||
class dummy(): filesystemencoding = 'utf-8'
|
||||
pairs = (('abc', 'abc'), ('a\U00011111c', 'a\ufffdc'),
|
||||
(b'abc', 'abc'), (b'a\xf0\x91\x84\x91c', 'a\ufffdc'))
|
||||
for inp, out in pairs:
|
||||
self.assertEqual(func(dummy, inp), out)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2)
|
||||
377
Darwin/lib/python3.5/idlelib/idle_test/test_formatparagraph.py
Normal file
377
Darwin/lib/python3.5/idlelib/idle_test/test_formatparagraph.py
Normal file
|
|
@ -0,0 +1,377 @@
|
|||
# Test the functions and main class method of FormatParagraph.py
|
||||
import unittest
|
||||
from idlelib import FormatParagraph as fp
|
||||
from idlelib.EditorWindow import EditorWindow
|
||||
from tkinter import Tk, Text
|
||||
from test.support import requires
|
||||
|
||||
|
||||
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(fp.is_all_white(''))
|
||||
self.assertTrue(fp.is_all_white('\t\n\r\f\v'))
|
||||
self.assertFalse(fp.is_all_white(self.test_comment))
|
||||
|
||||
def test_get_indent(self):
|
||||
Equal = self.assertEqual
|
||||
Equal(fp.get_indent(self.test_comment), '')
|
||||
Equal(fp.get_indent(self.trailingws_comment), '')
|
||||
Equal(fp.get_indent(self.leadingws_comment), ' ')
|
||||
Equal(fp.get_indent(self.leadingws_nocomment), ' ')
|
||||
|
||||
def test_get_comment_header(self):
|
||||
Equal = self.assertEqual
|
||||
# Test comment strings
|
||||
Equal(fp.get_comment_header(self.test_comment), '#')
|
||||
Equal(fp.get_comment_header(self.trailingws_comment), '#')
|
||||
Equal(fp.get_comment_header(self.leadingws_comment), ' #')
|
||||
# Test non-comment strings
|
||||
Equal(fp.get_comment_header(self.leadingws_nocomment), ' ')
|
||||
Equal(fp.get_comment_header(self.test_nocomment), '')
|
||||
|
||||
|
||||
class FindTest(unittest.TestCase):
|
||||
"""Test the find_paragraph function in FormatParagraph.
|
||||
|
||||
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(fp.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_paragrah(self):
|
||||
Equal = self.assertEqual
|
||||
reform = fp.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 = fp.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 = fp.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 = fp.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()
|
||||
editor = Editor(root=cls.root)
|
||||
cls.text = editor.text.text # Test code does not need the wrapper.
|
||||
cls.formatter = fp.FormatParagraph(editor).format_paragraph_event
|
||||
# Sets the insert mark just after the re-wrapped and inserted text.
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.root.destroy()
|
||||
del cls.root
|
||||
del cls.text
|
||||
del cls.formatter
|
||||
|
||||
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)
|
||||
80
Darwin/lib/python3.5/idlelib/idle_test/test_grep.py
Normal file
80
Darwin/lib/python3.5/idlelib/idle_test/test_grep.py
Normal file
|
|
@ -0,0 +1,80 @@
|
|||
""" !Changing this line will break Test_findfile.test_found!
|
||||
Non-gui unit tests for idlelib.GrepDialog methods.
|
||||
dummy_command calls grep_it calls findfiles.
|
||||
An exception raised in one method will fail callers.
|
||||
Otherwise, tests are mostly independent.
|
||||
*** Currently only test grep_it.
|
||||
"""
|
||||
import unittest
|
||||
from test.support import captured_stdout
|
||||
from idlelib.idle_test.mock_tk import Var
|
||||
from idlelib.GrepDialog import GrepDialog
|
||||
import re
|
||||
|
||||
class Dummy_searchengine:
|
||||
'''GrepDialog.__init__ calls parent SearchDiabolBase which attaches the
|
||||
passed in SearchEngine instance as attribute 'engine'. Only a few of the
|
||||
many possible self.engine.x attributes are needed here.
|
||||
'''
|
||||
def getpat(self):
|
||||
return self._pat
|
||||
|
||||
searchengine = Dummy_searchengine()
|
||||
|
||||
class Dummy_grep:
|
||||
# Methods tested
|
||||
#default_command = GrepDialog.default_command
|
||||
grep_it = GrepDialog.grep_it
|
||||
findfiles = GrepDialog.findfiles
|
||||
# Other stuff needed
|
||||
recvar = Var(False)
|
||||
engine = searchengine
|
||||
def close(self): # gui method
|
||||
pass
|
||||
|
||||
grep = Dummy_grep()
|
||||
|
||||
class FindfilesTest(unittest.TestCase):
|
||||
# findfiles is really a function, not a method, could be iterator
|
||||
# test that filename return filename
|
||||
# test that idlelib has many .py files
|
||||
# test that recursive flag adds idle_test .py files
|
||||
pass
|
||||
|
||||
class Grep_itTest(unittest.TestCase):
|
||||
# Test captured reports with 0 and some hits.
|
||||
# Should test file names, but Windows reports have mixed / and \ separators
|
||||
# from incomplete replacement, so 'later'.
|
||||
|
||||
def report(self, pat):
|
||||
grep.engine._pat = pat
|
||||
with captured_stdout() as s:
|
||||
grep.grep_it(re.compile(pat), __file__)
|
||||
lines = s.getvalue().split('\n')
|
||||
lines.pop() # remove bogus '' after last \n
|
||||
return lines
|
||||
|
||||
def test_unfound(self):
|
||||
pat = 'xyz*'*7
|
||||
lines = self.report(pat)
|
||||
self.assertEqual(len(lines), 2)
|
||||
self.assertIn(pat, lines[0])
|
||||
self.assertEqual(lines[1], 'No hits.')
|
||||
|
||||
def test_found(self):
|
||||
|
||||
pat = '""" !Changing this line will break Test_findfile.test_found!'
|
||||
lines = self.report(pat)
|
||||
self.assertEqual(len(lines), 5)
|
||||
self.assertIn(pat, lines[0])
|
||||
self.assertIn('py: 1:', lines[1]) # line number 1
|
||||
self.assertIn('2', lines[3]) # hits found 2
|
||||
self.assertTrue(lines[4].startswith('(Hint:'))
|
||||
|
||||
class Default_commandTest(unittest.TestCase):
|
||||
# To write this, mode OutputWindow import to top of GrepDialog
|
||||
# so it can be replaced by captured_stdout in class setup/teardown.
|
||||
pass
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2, exit=False)
|
||||
273
Darwin/lib/python3.5/idlelib/idle_test/test_hyperparser.py
Normal file
273
Darwin/lib/python3.5/idlelib/idle_test/test_hyperparser.py
Normal file
|
|
@ -0,0 +1,273 @@
|
|||
"""Unittest for idlelib.HyperParser"""
|
||||
import unittest
|
||||
from test.support import requires
|
||||
from tkinter import Tk, Text
|
||||
from idlelib.EditorWindow import EditorWindow
|
||||
from idlelib.HyperParser import HyperParser
|
||||
|
||||
class DummyEditwin:
|
||||
def __init__(self, text):
|
||||
self.text = text
|
||||
self.indentwidth = 8
|
||||
self.tabwidth = 8
|
||||
self.context_use_ps1 = True
|
||||
self.num_context_lines = 50, 500, 1000
|
||||
|
||||
_build_char_in_string_func = EditorWindow._build_char_in_string_func
|
||||
is_char_in_string = EditorWindow.is_char_in_string
|
||||
|
||||
|
||||
class HyperParserTest(unittest.TestCase):
|
||||
code = (
|
||||
'"""This is a module docstring"""\n'
|
||||
'# this line is a comment\n'
|
||||
'x = "this is a string"\n'
|
||||
"y = 'this is also a string'\n"
|
||||
'l = [i for i in range(10)]\n'
|
||||
'm = [py*py for # comment\n'
|
||||
' py in l]\n'
|
||||
'x.__len__\n'
|
||||
"z = ((r'asdf')+('a')))\n"
|
||||
'[x for x in\n'
|
||||
'for = False\n'
|
||||
'cliché = "this is a string with unicode, what a cliché"'
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
requires('gui')
|
||||
cls.root = Tk()
|
||||
cls.text = Text(cls.root)
|
||||
cls.editwin = DummyEditwin(cls.text)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
del cls.text, cls.editwin
|
||||
cls.root.destroy()
|
||||
del cls.root
|
||||
|
||||
def setUp(self):
|
||||
self.text.insert('insert', self.code)
|
||||
|
||||
def tearDown(self):
|
||||
self.text.delete('1.0', 'end')
|
||||
self.editwin.context_use_ps1 = True
|
||||
|
||||
def get_parser(self, index):
|
||||
"""
|
||||
Return a parser object with index at 'index'
|
||||
"""
|
||||
return HyperParser(self.editwin, index)
|
||||
|
||||
def test_init(self):
|
||||
"""
|
||||
test corner cases in the init method
|
||||
"""
|
||||
with self.assertRaises(ValueError) as ve:
|
||||
self.text.tag_add('console', '1.0', '1.end')
|
||||
p = self.get_parser('1.5')
|
||||
self.assertIn('precedes', str(ve.exception))
|
||||
|
||||
# test without ps1
|
||||
self.editwin.context_use_ps1 = False
|
||||
|
||||
# number of lines lesser than 50
|
||||
p = self.get_parser('end')
|
||||
self.assertEqual(p.rawtext, self.text.get('1.0', 'end'))
|
||||
|
||||
# number of lines greater than 50
|
||||
self.text.insert('end', self.text.get('1.0', 'end')*4)
|
||||
p = self.get_parser('54.5')
|
||||
|
||||
def test_is_in_string(self):
|
||||
get = self.get_parser
|
||||
|
||||
p = get('1.0')
|
||||
self.assertFalse(p.is_in_string())
|
||||
p = get('1.4')
|
||||
self.assertTrue(p.is_in_string())
|
||||
p = get('2.3')
|
||||
self.assertFalse(p.is_in_string())
|
||||
p = get('3.3')
|
||||
self.assertFalse(p.is_in_string())
|
||||
p = get('3.7')
|
||||
self.assertTrue(p.is_in_string())
|
||||
p = get('4.6')
|
||||
self.assertTrue(p.is_in_string())
|
||||
p = get('12.54')
|
||||
self.assertTrue(p.is_in_string())
|
||||
|
||||
def test_is_in_code(self):
|
||||
get = self.get_parser
|
||||
|
||||
p = get('1.0')
|
||||
self.assertTrue(p.is_in_code())
|
||||
p = get('1.1')
|
||||
self.assertFalse(p.is_in_code())
|
||||
p = get('2.5')
|
||||
self.assertFalse(p.is_in_code())
|
||||
p = get('3.4')
|
||||
self.assertTrue(p.is_in_code())
|
||||
p = get('3.6')
|
||||
self.assertFalse(p.is_in_code())
|
||||
p = get('4.14')
|
||||
self.assertFalse(p.is_in_code())
|
||||
|
||||
def test_get_surrounding_bracket(self):
|
||||
get = self.get_parser
|
||||
|
||||
def without_mustclose(parser):
|
||||
# a utility function to get surrounding bracket
|
||||
# with mustclose=False
|
||||
return parser.get_surrounding_brackets(mustclose=False)
|
||||
|
||||
def with_mustclose(parser):
|
||||
# a utility function to get surrounding bracket
|
||||
# with mustclose=True
|
||||
return parser.get_surrounding_brackets(mustclose=True)
|
||||
|
||||
p = get('3.2')
|
||||
self.assertIsNone(with_mustclose(p))
|
||||
self.assertIsNone(without_mustclose(p))
|
||||
|
||||
p = get('5.6')
|
||||
self.assertTupleEqual(without_mustclose(p), ('5.4', '5.25'))
|
||||
self.assertTupleEqual(without_mustclose(p), with_mustclose(p))
|
||||
|
||||
p = get('5.23')
|
||||
self.assertTupleEqual(without_mustclose(p), ('5.21', '5.24'))
|
||||
self.assertTupleEqual(without_mustclose(p), with_mustclose(p))
|
||||
|
||||
p = get('6.15')
|
||||
self.assertTupleEqual(without_mustclose(p), ('6.4', '6.end'))
|
||||
self.assertIsNone(with_mustclose(p))
|
||||
|
||||
p = get('9.end')
|
||||
self.assertIsNone(with_mustclose(p))
|
||||
self.assertIsNone(without_mustclose(p))
|
||||
|
||||
def test_get_expression(self):
|
||||
get = self.get_parser
|
||||
|
||||
p = get('4.2')
|
||||
self.assertEqual(p.get_expression(), 'y ')
|
||||
|
||||
p = get('4.7')
|
||||
with self.assertRaises(ValueError) as ve:
|
||||
p.get_expression()
|
||||
self.assertIn('is inside a code', str(ve.exception))
|
||||
|
||||
p = get('5.25')
|
||||
self.assertEqual(p.get_expression(), 'range(10)')
|
||||
|
||||
p = get('6.7')
|
||||
self.assertEqual(p.get_expression(), 'py')
|
||||
|
||||
p = get('6.8')
|
||||
self.assertEqual(p.get_expression(), '')
|
||||
|
||||
p = get('7.9')
|
||||
self.assertEqual(p.get_expression(), 'py')
|
||||
|
||||
p = get('8.end')
|
||||
self.assertEqual(p.get_expression(), 'x.__len__')
|
||||
|
||||
p = get('9.13')
|
||||
self.assertEqual(p.get_expression(), "r'asdf'")
|
||||
|
||||
p = get('9.17')
|
||||
with self.assertRaises(ValueError) as ve:
|
||||
p.get_expression()
|
||||
self.assertIn('is inside a code', str(ve.exception))
|
||||
|
||||
p = get('10.0')
|
||||
self.assertEqual(p.get_expression(), '')
|
||||
|
||||
p = get('10.6')
|
||||
self.assertEqual(p.get_expression(), '')
|
||||
|
||||
p = get('10.11')
|
||||
self.assertEqual(p.get_expression(), '')
|
||||
|
||||
p = get('11.3')
|
||||
self.assertEqual(p.get_expression(), '')
|
||||
|
||||
p = get('11.11')
|
||||
self.assertEqual(p.get_expression(), 'False')
|
||||
|
||||
p = get('12.6')
|
||||
self.assertEqual(p.get_expression(), 'cliché')
|
||||
|
||||
def test_eat_identifier(self):
|
||||
def is_valid_id(candidate):
|
||||
result = HyperParser._eat_identifier(candidate, 0, len(candidate))
|
||||
if result == len(candidate):
|
||||
return True
|
||||
elif result == 0:
|
||||
return False
|
||||
else:
|
||||
err_msg = "Unexpected result: {} (expected 0 or {}".format(
|
||||
result, len(candidate)
|
||||
)
|
||||
raise Exception(err_msg)
|
||||
|
||||
# invalid first character which is valid elsewhere in an identifier
|
||||
self.assertFalse(is_valid_id('2notid'))
|
||||
|
||||
# ASCII-only valid identifiers
|
||||
self.assertTrue(is_valid_id('valid_id'))
|
||||
self.assertTrue(is_valid_id('_valid_id'))
|
||||
self.assertTrue(is_valid_id('valid_id_'))
|
||||
self.assertTrue(is_valid_id('_2valid_id'))
|
||||
|
||||
# keywords which should be "eaten"
|
||||
self.assertTrue(is_valid_id('True'))
|
||||
self.assertTrue(is_valid_id('False'))
|
||||
self.assertTrue(is_valid_id('None'))
|
||||
|
||||
# keywords which should not be "eaten"
|
||||
self.assertFalse(is_valid_id('for'))
|
||||
self.assertFalse(is_valid_id('import'))
|
||||
self.assertFalse(is_valid_id('return'))
|
||||
|
||||
# valid unicode identifiers
|
||||
self.assertTrue(is_valid_id('cliche'))
|
||||
self.assertTrue(is_valid_id('cliché'))
|
||||
self.assertTrue(is_valid_id('a٢'))
|
||||
|
||||
# invalid unicode identifiers
|
||||
self.assertFalse(is_valid_id('2a'))
|
||||
self.assertFalse(is_valid_id('٢a'))
|
||||
self.assertFalse(is_valid_id('a²'))
|
||||
|
||||
# valid identifier after "punctuation"
|
||||
self.assertEqual(HyperParser._eat_identifier('+ var', 0, 5), len('var'))
|
||||
self.assertEqual(HyperParser._eat_identifier('+var', 0, 4), len('var'))
|
||||
self.assertEqual(HyperParser._eat_identifier('.var', 0, 4), len('var'))
|
||||
|
||||
# invalid identifiers
|
||||
self.assertFalse(is_valid_id('+'))
|
||||
self.assertFalse(is_valid_id(' '))
|
||||
self.assertFalse(is_valid_id(':'))
|
||||
self.assertFalse(is_valid_id('?'))
|
||||
self.assertFalse(is_valid_id('^'))
|
||||
self.assertFalse(is_valid_id('\\'))
|
||||
self.assertFalse(is_valid_id('"'))
|
||||
self.assertFalse(is_valid_id('"a string"'))
|
||||
|
||||
def test_eat_identifier_various_lengths(self):
|
||||
eat_id = HyperParser._eat_identifier
|
||||
|
||||
for length in range(1, 21):
|
||||
self.assertEqual(eat_id('a' * length, 0, length), length)
|
||||
self.assertEqual(eat_id('é' * length, 0, length), length)
|
||||
self.assertEqual(eat_id('a' + '2' * (length - 1), 0, length), length)
|
||||
self.assertEqual(eat_id('é' + '2' * (length - 1), 0, length), length)
|
||||
self.assertEqual(eat_id('é' + 'a' * (length - 1), 0, length), length)
|
||||
self.assertEqual(eat_id('é' * (length - 1) + 'a', 0, length), length)
|
||||
self.assertEqual(eat_id('+' * length, 0, length), 0)
|
||||
self.assertEqual(eat_id('2' + 'a' * (length - 1), 0, length), 0)
|
||||
self.assertEqual(eat_id('2' + 'é' * (length - 1), 0, length), 0)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2)
|
||||
167
Darwin/lib/python3.5/idlelib/idle_test/test_idlehistory.py
Normal file
167
Darwin/lib/python3.5/idlelib/idle_test/test_idlehistory.py
Normal file
|
|
@ -0,0 +1,167 @@
|
|||
import unittest
|
||||
from test.support import requires
|
||||
|
||||
import tkinter as tk
|
||||
from tkinter import Text as tkText
|
||||
from idlelib.idle_test.mock_tk import Text as mkText
|
||||
from idlelib.IdleHistory import History
|
||||
from idlelib.configHandler import idleConf
|
||||
|
||||
line1 = 'a = 7'
|
||||
line2 = 'b = a'
|
||||
|
||||
class StoreTest(unittest.TestCase):
|
||||
'''Tests History.__init__ and History.store with mock Text'''
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.text = mkText()
|
||||
cls.history = History(cls.text)
|
||||
|
||||
def tearDown(self):
|
||||
self.text.delete('1.0', 'end')
|
||||
self.history.history = []
|
||||
|
||||
def test_init(self):
|
||||
self.assertIs(self.history.text, self.text)
|
||||
self.assertEqual(self.history.history, [])
|
||||
self.assertIsNone(self.history.prefix)
|
||||
self.assertIsNone(self.history.pointer)
|
||||
self.assertEqual(self.history.cyclic,
|
||||
idleConf.GetOption("main", "History", "cyclic", 1, "bool"))
|
||||
|
||||
def test_store_short(self):
|
||||
self.history.store('a')
|
||||
self.assertEqual(self.history.history, [])
|
||||
self.history.store(' a ')
|
||||
self.assertEqual(self.history.history, [])
|
||||
|
||||
def test_store_dup(self):
|
||||
self.history.store(line1)
|
||||
self.assertEqual(self.history.history, [line1])
|
||||
self.history.store(line2)
|
||||
self.assertEqual(self.history.history, [line1, line2])
|
||||
self.history.store(line1)
|
||||
self.assertEqual(self.history.history, [line2, line1])
|
||||
|
||||
def test_store_reset(self):
|
||||
self.history.prefix = line1
|
||||
self.history.pointer = 0
|
||||
self.history.store(line2)
|
||||
self.assertIsNone(self.history.prefix)
|
||||
self.assertIsNone(self.history.pointer)
|
||||
|
||||
|
||||
class TextWrapper:
|
||||
def __init__(self, master):
|
||||
self.text = tkText(master=master)
|
||||
self._bell = False
|
||||
def __getattr__(self, name):
|
||||
return getattr(self.text, name)
|
||||
def bell(self):
|
||||
self._bell = True
|
||||
|
||||
class FetchTest(unittest.TestCase):
|
||||
'''Test History.fetch with wrapped tk.Text.
|
||||
'''
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
requires('gui')
|
||||
cls.root = tk.Tk()
|
||||
|
||||
def setUp(self):
|
||||
self.text = text = TextWrapper(self.root)
|
||||
text.insert('1.0', ">>> ")
|
||||
text.mark_set('iomark', '1.4')
|
||||
text.mark_gravity('iomark', 'left')
|
||||
self.history = History(text)
|
||||
self.history.history = [line1, line2]
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.root.destroy()
|
||||
del cls.root
|
||||
|
||||
def fetch_test(self, reverse, line, prefix, index, *, bell=False):
|
||||
# Perform one fetch as invoked by Alt-N or Alt-P
|
||||
# Test the result. The line test is the most important.
|
||||
# The last two are diagnostic of fetch internals.
|
||||
History = self.history
|
||||
History.fetch(reverse)
|
||||
|
||||
Equal = self.assertEqual
|
||||
Equal(self.text.get('iomark', 'end-1c'), line)
|
||||
Equal(self.text._bell, bell)
|
||||
if bell:
|
||||
self.text._bell = False
|
||||
Equal(History.prefix, prefix)
|
||||
Equal(History.pointer, index)
|
||||
Equal(self.text.compare("insert", '==', "end-1c"), 1)
|
||||
|
||||
def test_fetch_prev_cyclic(self):
|
||||
prefix = ''
|
||||
test = self.fetch_test
|
||||
test(True, line2, prefix, 1)
|
||||
test(True, line1, prefix, 0)
|
||||
test(True, prefix, None, None, bell=True)
|
||||
|
||||
def test_fetch_next_cyclic(self):
|
||||
prefix = ''
|
||||
test = self.fetch_test
|
||||
test(False, line1, prefix, 0)
|
||||
test(False, line2, prefix, 1)
|
||||
test(False, prefix, None, None, bell=True)
|
||||
|
||||
# Prefix 'a' tests skip line2, which starts with 'b'
|
||||
def test_fetch_prev_prefix(self):
|
||||
prefix = 'a'
|
||||
self.text.insert('iomark', prefix)
|
||||
self.fetch_test(True, line1, prefix, 0)
|
||||
self.fetch_test(True, prefix, None, None, bell=True)
|
||||
|
||||
def test_fetch_next_prefix(self):
|
||||
prefix = 'a'
|
||||
self.text.insert('iomark', prefix)
|
||||
self.fetch_test(False, line1, prefix, 0)
|
||||
self.fetch_test(False, prefix, None, None, bell=True)
|
||||
|
||||
def test_fetch_prev_noncyclic(self):
|
||||
prefix = ''
|
||||
self.history.cyclic = False
|
||||
test = self.fetch_test
|
||||
test(True, line2, prefix, 1)
|
||||
test(True, line1, prefix, 0)
|
||||
test(True, line1, prefix, 0, bell=True)
|
||||
|
||||
def test_fetch_next_noncyclic(self):
|
||||
prefix = ''
|
||||
self.history.cyclic = False
|
||||
test = self.fetch_test
|
||||
test(False, prefix, None, None, bell=True)
|
||||
test(True, line2, prefix, 1)
|
||||
test(False, prefix, None, None, bell=True)
|
||||
test(False, prefix, None, None, bell=True)
|
||||
|
||||
def test_fetch_cursor_move(self):
|
||||
# Move cursor after fetch
|
||||
self.history.fetch(reverse=True) # initialization
|
||||
self.text.mark_set('insert', 'iomark')
|
||||
self.fetch_test(True, line2, None, None, bell=True)
|
||||
|
||||
def test_fetch_edit(self):
|
||||
# Edit after fetch
|
||||
self.history.fetch(reverse=True) # initialization
|
||||
self.text.delete('iomark', 'insert', )
|
||||
self.text.insert('iomark', 'a =')
|
||||
self.fetch_test(True, line1, 'a =', 0) # prefix is reset
|
||||
|
||||
def test_history_prev_next(self):
|
||||
# Minimally test functions bound to events
|
||||
self.history.history_prev('dummy event')
|
||||
self.assertEqual(self.history.pointer, 1)
|
||||
self.history.history_next('dummy event')
|
||||
self.assertEqual(self.history.pointer, None)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2, exit=2)
|
||||
233
Darwin/lib/python3.5/idlelib/idle_test/test_io.py
Normal file
233
Darwin/lib/python3.5/idlelib/idle_test/test_io.py
Normal file
|
|
@ -0,0 +1,233 @@
|
|||
import unittest
|
||||
import io
|
||||
from idlelib.PyShell import PseudoInputFile, PseudoOutputFile
|
||||
|
||||
|
||||
class S(str):
|
||||
def __str__(self):
|
||||
return '%s:str' % type(self).__name__
|
||||
def __unicode__(self):
|
||||
return '%s:unicode' % type(self).__name__
|
||||
def __len__(self):
|
||||
return 3
|
||||
def __iter__(self):
|
||||
return iter('abc')
|
||||
def __getitem__(self, *args):
|
||||
return '%s:item' % type(self).__name__
|
||||
def __getslice__(self, *args):
|
||||
return '%s:slice' % type(self).__name__
|
||||
|
||||
class MockShell:
|
||||
def __init__(self):
|
||||
self.reset()
|
||||
|
||||
def write(self, *args):
|
||||
self.written.append(args)
|
||||
|
||||
def readline(self):
|
||||
return self.lines.pop()
|
||||
|
||||
def close(self):
|
||||
pass
|
||||
|
||||
def reset(self):
|
||||
self.written = []
|
||||
|
||||
def push(self, lines):
|
||||
self.lines = list(lines)[::-1]
|
||||
|
||||
|
||||
class PseudeOutputFilesTest(unittest.TestCase):
|
||||
def test_misc(self):
|
||||
shell = MockShell()
|
||||
f = PseudoOutputFile(shell, 'stdout', 'utf-8')
|
||||
self.assertIsInstance(f, io.TextIOBase)
|
||||
self.assertEqual(f.encoding, 'utf-8')
|
||||
self.assertIsNone(f.errors)
|
||||
self.assertIsNone(f.newlines)
|
||||
self.assertEqual(f.name, '<stdout>')
|
||||
self.assertFalse(f.closed)
|
||||
self.assertTrue(f.isatty())
|
||||
self.assertFalse(f.readable())
|
||||
self.assertTrue(f.writable())
|
||||
self.assertFalse(f.seekable())
|
||||
|
||||
def test_unsupported(self):
|
||||
shell = MockShell()
|
||||
f = PseudoOutputFile(shell, 'stdout', 'utf-8')
|
||||
self.assertRaises(OSError, f.fileno)
|
||||
self.assertRaises(OSError, f.tell)
|
||||
self.assertRaises(OSError, f.seek, 0)
|
||||
self.assertRaises(OSError, f.read, 0)
|
||||
self.assertRaises(OSError, f.readline, 0)
|
||||
|
||||
def test_write(self):
|
||||
shell = MockShell()
|
||||
f = PseudoOutputFile(shell, 'stdout', 'utf-8')
|
||||
f.write('test')
|
||||
self.assertEqual(shell.written, [('test', 'stdout')])
|
||||
shell.reset()
|
||||
f.write('t\xe8st')
|
||||
self.assertEqual(shell.written, [('t\xe8st', 'stdout')])
|
||||
shell.reset()
|
||||
|
||||
f.write(S('t\xe8st'))
|
||||
self.assertEqual(shell.written, [('t\xe8st', 'stdout')])
|
||||
self.assertEqual(type(shell.written[0][0]), str)
|
||||
shell.reset()
|
||||
|
||||
self.assertRaises(TypeError, f.write)
|
||||
self.assertEqual(shell.written, [])
|
||||
self.assertRaises(TypeError, f.write, b'test')
|
||||
self.assertRaises(TypeError, f.write, 123)
|
||||
self.assertEqual(shell.written, [])
|
||||
self.assertRaises(TypeError, f.write, 'test', 'spam')
|
||||
self.assertEqual(shell.written, [])
|
||||
|
||||
def test_writelines(self):
|
||||
shell = MockShell()
|
||||
f = PseudoOutputFile(shell, 'stdout', 'utf-8')
|
||||
f.writelines([])
|
||||
self.assertEqual(shell.written, [])
|
||||
shell.reset()
|
||||
f.writelines(['one\n', 'two'])
|
||||
self.assertEqual(shell.written,
|
||||
[('one\n', 'stdout'), ('two', 'stdout')])
|
||||
shell.reset()
|
||||
f.writelines(['on\xe8\n', 'tw\xf2'])
|
||||
self.assertEqual(shell.written,
|
||||
[('on\xe8\n', 'stdout'), ('tw\xf2', 'stdout')])
|
||||
shell.reset()
|
||||
|
||||
f.writelines([S('t\xe8st')])
|
||||
self.assertEqual(shell.written, [('t\xe8st', 'stdout')])
|
||||
self.assertEqual(type(shell.written[0][0]), str)
|
||||
shell.reset()
|
||||
|
||||
self.assertRaises(TypeError, f.writelines)
|
||||
self.assertEqual(shell.written, [])
|
||||
self.assertRaises(TypeError, f.writelines, 123)
|
||||
self.assertEqual(shell.written, [])
|
||||
self.assertRaises(TypeError, f.writelines, [b'test'])
|
||||
self.assertRaises(TypeError, f.writelines, [123])
|
||||
self.assertEqual(shell.written, [])
|
||||
self.assertRaises(TypeError, f.writelines, [], [])
|
||||
self.assertEqual(shell.written, [])
|
||||
|
||||
def test_close(self):
|
||||
shell = MockShell()
|
||||
f = PseudoOutputFile(shell, 'stdout', 'utf-8')
|
||||
self.assertFalse(f.closed)
|
||||
f.write('test')
|
||||
f.close()
|
||||
self.assertTrue(f.closed)
|
||||
self.assertRaises(ValueError, f.write, 'x')
|
||||
self.assertEqual(shell.written, [('test', 'stdout')])
|
||||
f.close()
|
||||
self.assertRaises(TypeError, f.close, 1)
|
||||
|
||||
|
||||
class PseudeInputFilesTest(unittest.TestCase):
|
||||
def test_misc(self):
|
||||
shell = MockShell()
|
||||
f = PseudoInputFile(shell, 'stdin', 'utf-8')
|
||||
self.assertIsInstance(f, io.TextIOBase)
|
||||
self.assertEqual(f.encoding, 'utf-8')
|
||||
self.assertIsNone(f.errors)
|
||||
self.assertIsNone(f.newlines)
|
||||
self.assertEqual(f.name, '<stdin>')
|
||||
self.assertFalse(f.closed)
|
||||
self.assertTrue(f.isatty())
|
||||
self.assertTrue(f.readable())
|
||||
self.assertFalse(f.writable())
|
||||
self.assertFalse(f.seekable())
|
||||
|
||||
def test_unsupported(self):
|
||||
shell = MockShell()
|
||||
f = PseudoInputFile(shell, 'stdin', 'utf-8')
|
||||
self.assertRaises(OSError, f.fileno)
|
||||
self.assertRaises(OSError, f.tell)
|
||||
self.assertRaises(OSError, f.seek, 0)
|
||||
self.assertRaises(OSError, f.write, 'x')
|
||||
self.assertRaises(OSError, f.writelines, ['x'])
|
||||
|
||||
def test_read(self):
|
||||
shell = MockShell()
|
||||
f = PseudoInputFile(shell, 'stdin', 'utf-8')
|
||||
shell.push(['one\n', 'two\n', ''])
|
||||
self.assertEqual(f.read(), 'one\ntwo\n')
|
||||
shell.push(['one\n', 'two\n', ''])
|
||||
self.assertEqual(f.read(-1), 'one\ntwo\n')
|
||||
shell.push(['one\n', 'two\n', ''])
|
||||
self.assertEqual(f.read(None), 'one\ntwo\n')
|
||||
shell.push(['one\n', 'two\n', 'three\n', ''])
|
||||
self.assertEqual(f.read(2), 'on')
|
||||
self.assertEqual(f.read(3), 'e\nt')
|
||||
self.assertEqual(f.read(10), 'wo\nthree\n')
|
||||
|
||||
shell.push(['one\n', 'two\n'])
|
||||
self.assertEqual(f.read(0), '')
|
||||
self.assertRaises(TypeError, f.read, 1.5)
|
||||
self.assertRaises(TypeError, f.read, '1')
|
||||
self.assertRaises(TypeError, f.read, 1, 1)
|
||||
|
||||
def test_readline(self):
|
||||
shell = MockShell()
|
||||
f = PseudoInputFile(shell, 'stdin', 'utf-8')
|
||||
shell.push(['one\n', 'two\n', 'three\n', 'four\n'])
|
||||
self.assertEqual(f.readline(), 'one\n')
|
||||
self.assertEqual(f.readline(-1), 'two\n')
|
||||
self.assertEqual(f.readline(None), 'three\n')
|
||||
shell.push(['one\ntwo\n'])
|
||||
self.assertEqual(f.readline(), 'one\n')
|
||||
self.assertEqual(f.readline(), 'two\n')
|
||||
shell.push(['one', 'two', 'three'])
|
||||
self.assertEqual(f.readline(), 'one')
|
||||
self.assertEqual(f.readline(), 'two')
|
||||
shell.push(['one\n', 'two\n', 'three\n'])
|
||||
self.assertEqual(f.readline(2), 'on')
|
||||
self.assertEqual(f.readline(1), 'e')
|
||||
self.assertEqual(f.readline(1), '\n')
|
||||
self.assertEqual(f.readline(10), 'two\n')
|
||||
|
||||
shell.push(['one\n', 'two\n'])
|
||||
self.assertEqual(f.readline(0), '')
|
||||
self.assertRaises(TypeError, f.readlines, 1.5)
|
||||
self.assertRaises(TypeError, f.readlines, '1')
|
||||
self.assertRaises(TypeError, f.readlines, 1, 1)
|
||||
|
||||
def test_readlines(self):
|
||||
shell = MockShell()
|
||||
f = PseudoInputFile(shell, 'stdin', 'utf-8')
|
||||
shell.push(['one\n', 'two\n', ''])
|
||||
self.assertEqual(f.readlines(), ['one\n', 'two\n'])
|
||||
shell.push(['one\n', 'two\n', ''])
|
||||
self.assertEqual(f.readlines(-1), ['one\n', 'two\n'])
|
||||
shell.push(['one\n', 'two\n', ''])
|
||||
self.assertEqual(f.readlines(None), ['one\n', 'two\n'])
|
||||
shell.push(['one\n', 'two\n', ''])
|
||||
self.assertEqual(f.readlines(0), ['one\n', 'two\n'])
|
||||
shell.push(['one\n', 'two\n', ''])
|
||||
self.assertEqual(f.readlines(3), ['one\n'])
|
||||
shell.push(['one\n', 'two\n', ''])
|
||||
self.assertEqual(f.readlines(4), ['one\n', 'two\n'])
|
||||
|
||||
shell.push(['one\n', 'two\n', ''])
|
||||
self.assertRaises(TypeError, f.readlines, 1.5)
|
||||
self.assertRaises(TypeError, f.readlines, '1')
|
||||
self.assertRaises(TypeError, f.readlines, 1, 1)
|
||||
|
||||
def test_close(self):
|
||||
shell = MockShell()
|
||||
f = PseudoInputFile(shell, 'stdin', 'utf-8')
|
||||
shell.push(['one\n', 'two\n', ''])
|
||||
self.assertFalse(f.closed)
|
||||
self.assertEqual(f.readline(), 'one\n')
|
||||
f.close()
|
||||
self.assertFalse(f.closed)
|
||||
self.assertEqual(f.readline(), 'two\n')
|
||||
self.assertRaises(TypeError, f.close, 1)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
109
Darwin/lib/python3.5/idlelib/idle_test/test_parenmatch.py
Normal file
109
Darwin/lib/python3.5/idlelib/idle_test/test_parenmatch.py
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
"""Test idlelib.ParenMatch."""
|
||||
# This must currently be a gui test because ParenMatch methods use
|
||||
# several text methods not defined on idlelib.idle_test.mock_tk.Text.
|
||||
|
||||
import unittest
|
||||
from unittest.mock import Mock
|
||||
from test.support import requires
|
||||
from tkinter import Tk, Text
|
||||
from idlelib.ParenMatch import ParenMatch
|
||||
|
||||
class DummyEditwin:
|
||||
def __init__(self, text):
|
||||
self.text = text
|
||||
self.indentwidth = 8
|
||||
self.tabwidth = 8
|
||||
self.context_use_ps1 = True
|
||||
|
||||
|
||||
class ParenMatchTest(unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
requires('gui')
|
||||
cls.root = Tk()
|
||||
cls.text = Text(cls.root)
|
||||
cls.editwin = DummyEditwin(cls.text)
|
||||
cls.editwin.text_frame = Mock()
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
del cls.text, cls.editwin
|
||||
cls.root.destroy()
|
||||
del cls.root
|
||||
|
||||
def tearDown(self):
|
||||
self.text.delete('1.0', 'end')
|
||||
|
||||
def test_paren_expression(self):
|
||||
"""
|
||||
Test ParenMatch with 'expression' style.
|
||||
"""
|
||||
text = self.text
|
||||
pm = ParenMatch(self.editwin)
|
||||
pm.set_style('expression')
|
||||
|
||||
text.insert('insert', 'def foobar(a, b')
|
||||
pm.flash_paren_event('event')
|
||||
self.assertIn('<<parenmatch-check-restore>>', text.event_info())
|
||||
self.assertTupleEqual(text.tag_prevrange('paren', 'end'),
|
||||
('1.10', '1.15'))
|
||||
text.insert('insert', ')')
|
||||
pm.restore_event()
|
||||
self.assertNotIn('<<parenmatch-check-restore>>', text.event_info())
|
||||
self.assertEqual(text.tag_prevrange('paren', 'end'), ())
|
||||
|
||||
# paren_closed_event can only be tested as below
|
||||
pm.paren_closed_event('event')
|
||||
self.assertTupleEqual(text.tag_prevrange('paren', 'end'),
|
||||
('1.10', '1.16'))
|
||||
|
||||
def test_paren_default(self):
|
||||
"""
|
||||
Test ParenMatch with 'default' style.
|
||||
"""
|
||||
text = self.text
|
||||
pm = ParenMatch(self.editwin)
|
||||
pm.set_style('default')
|
||||
|
||||
text.insert('insert', 'def foobar(a, b')
|
||||
pm.flash_paren_event('event')
|
||||
self.assertIn('<<parenmatch-check-restore>>', text.event_info())
|
||||
self.assertTupleEqual(text.tag_prevrange('paren', 'end'),
|
||||
('1.10', '1.11'))
|
||||
text.insert('insert', ')')
|
||||
pm.restore_event()
|
||||
self.assertNotIn('<<parenmatch-check-restore>>', text.event_info())
|
||||
self.assertEqual(text.tag_prevrange('paren', 'end'), ())
|
||||
|
||||
def test_paren_corner(self):
|
||||
"""
|
||||
Test corner cases in flash_paren_event and paren_closed_event.
|
||||
|
||||
These cases force conditional expression and alternate paths.
|
||||
"""
|
||||
text = self.text
|
||||
pm = ParenMatch(self.editwin)
|
||||
|
||||
text.insert('insert', '# this is a commen)')
|
||||
self.assertIsNone(pm.paren_closed_event('event'))
|
||||
|
||||
text.insert('insert', '\ndef')
|
||||
self.assertIsNone(pm.flash_paren_event('event'))
|
||||
self.assertIsNone(pm.paren_closed_event('event'))
|
||||
|
||||
text.insert('insert', ' a, *arg)')
|
||||
self.assertIsNone(pm.paren_closed_event('event'))
|
||||
|
||||
def test_handle_restore_timer(self):
|
||||
pm = ParenMatch(self.editwin)
|
||||
pm.restore_event = Mock()
|
||||
pm.handle_restore_timer(0)
|
||||
self.assertTrue(pm.restore_event.called)
|
||||
pm.restore_event.reset_mock()
|
||||
pm.handle_restore_timer(1)
|
||||
self.assertFalse(pm.restore_event.called)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2)
|
||||
27
Darwin/lib/python3.5/idlelib/idle_test/test_pathbrowser.py
Normal file
27
Darwin/lib/python3.5/idlelib/idle_test/test_pathbrowser.py
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
import unittest
|
||||
import os
|
||||
import sys
|
||||
import idlelib
|
||||
from idlelib import PathBrowser
|
||||
|
||||
class PathBrowserTest(unittest.TestCase):
|
||||
|
||||
def test_DirBrowserTreeItem(self):
|
||||
# Issue16226 - make sure that getting a sublist works
|
||||
d = PathBrowser.DirBrowserTreeItem('')
|
||||
d.GetSubList()
|
||||
self.assertEqual('', d.GetText())
|
||||
|
||||
dir = os.path.split(os.path.abspath(idlelib.__file__))[0]
|
||||
self.assertEqual(d.ispackagedir(dir), True)
|
||||
self.assertEqual(d.ispackagedir(dir + '/Icons'), False)
|
||||
|
||||
def test_PathBrowserTreeItem(self):
|
||||
p = PathBrowser.PathBrowserTreeItem()
|
||||
self.assertEqual(p.GetText(), 'sys.path')
|
||||
sub = p.GetSubList()
|
||||
self.assertEqual(len(sub), len(sys.path))
|
||||
self.assertEqual(type(sub[0]), PathBrowser.DirBrowserTreeItem)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2, exit=False)
|
||||
49
Darwin/lib/python3.5/idlelib/idle_test/test_rstrip.py
Normal file
49
Darwin/lib/python3.5/idlelib/idle_test/test_rstrip.py
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
import unittest
|
||||
import idlelib.RstripExtension as rs
|
||||
from idlelib.idle_test.mock_idle import Editor
|
||||
|
||||
class rstripTest(unittest.TestCase):
|
||||
|
||||
def test_rstrip_line(self):
|
||||
editor = Editor()
|
||||
text = editor.text
|
||||
do_rstrip = rs.RstripExtension(editor).do_rstrip
|
||||
|
||||
do_rstrip()
|
||||
self.assertEqual(text.get('1.0', 'insert'), '')
|
||||
text.insert('1.0', ' ')
|
||||
do_rstrip()
|
||||
self.assertEqual(text.get('1.0', 'insert'), '')
|
||||
text.insert('1.0', ' \n')
|
||||
do_rstrip()
|
||||
self.assertEqual(text.get('1.0', 'insert'), '\n')
|
||||
|
||||
def test_rstrip_multiple(self):
|
||||
editor = Editor()
|
||||
# Uncomment following to verify that test passes with real widgets.
|
||||
## from idlelib.EditorWindow import EditorWindow as Editor
|
||||
## from tkinter import Tk
|
||||
## editor = Editor(root=Tk())
|
||||
text = editor.text
|
||||
do_rstrip = rs.RstripExtension(editor).do_rstrip
|
||||
|
||||
original = (
|
||||
"Line with an ending tab \n"
|
||||
"Line ending in 5 spaces \n"
|
||||
"Linewithnospaces\n"
|
||||
" indented line\n"
|
||||
" indented line with trailing space \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")
|
||||
|
||||
text.insert('1.0', original)
|
||||
do_rstrip()
|
||||
self.assertEqual(text.get('1.0', 'insert'), stripped)
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2, exit=False)
|
||||
165
Darwin/lib/python3.5/idlelib/idle_test/test_searchdialogbase.py
Normal file
165
Darwin/lib/python3.5/idlelib/idle_test/test_searchdialogbase.py
Normal file
|
|
@ -0,0 +1,165 @@
|
|||
'''Unittests for idlelib/SearchDialogBase.py
|
||||
|
||||
Coverage: 99%. The only thing not covered is inconsequential --
|
||||
testing skipping of suite when self.needwrapbutton is false.
|
||||
|
||||
'''
|
||||
import unittest
|
||||
from test.support import requires
|
||||
from tkinter import Tk, Toplevel, Frame ##, BooleanVar, StringVar
|
||||
from idlelib import SearchEngine as se
|
||||
from idlelib import SearchDialogBase as sdb
|
||||
from idlelib.idle_test.mock_idle import Func
|
||||
## from idlelib.idle_test.mock_tk import Var
|
||||
|
||||
# The ## imports above & following could help make some tests gui-free.
|
||||
# However, they currently make radiobutton tests fail.
|
||||
##def setUpModule():
|
||||
## # Replace tk objects used to initialize se.SearchEngine.
|
||||
## se.BooleanVar = Var
|
||||
## se.StringVar = Var
|
||||
##
|
||||
##def tearDownModule():
|
||||
## se.BooleanVar = BooleanVar
|
||||
## se.StringVar = StringVar
|
||||
|
||||
class SearchDialogBaseTest(unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
requires('gui')
|
||||
cls.root = Tk()
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.root.destroy()
|
||||
del cls.root
|
||||
|
||||
def setUp(self):
|
||||
self.engine = se.SearchEngine(self.root) # None also seems to work
|
||||
self.dialog = sdb.SearchDialogBase(root=self.root, engine=self.engine)
|
||||
|
||||
def tearDown(self):
|
||||
self.dialog.close()
|
||||
|
||||
def test_open_and_close(self):
|
||||
# open calls create_widgets, which needs default_command
|
||||
self.dialog.default_command = None
|
||||
|
||||
# Since text parameter of .open is not used in base class,
|
||||
# pass dummy 'text' instead of tk.Text().
|
||||
self.dialog.open('text')
|
||||
self.assertEqual(self.dialog.top.state(), 'normal')
|
||||
self.dialog.close()
|
||||
self.assertEqual(self.dialog.top.state(), 'withdrawn')
|
||||
|
||||
self.dialog.open('text', searchphrase="hello")
|
||||
self.assertEqual(self.dialog.ent.get(), 'hello')
|
||||
self.dialog.close()
|
||||
|
||||
def test_create_widgets(self):
|
||||
self.dialog.create_entries = Func()
|
||||
self.dialog.create_option_buttons = Func()
|
||||
self.dialog.create_other_buttons = Func()
|
||||
self.dialog.create_command_buttons = Func()
|
||||
|
||||
self.dialog.default_command = None
|
||||
self.dialog.create_widgets()
|
||||
|
||||
self.assertTrue(self.dialog.create_entries.called)
|
||||
self.assertTrue(self.dialog.create_option_buttons.called)
|
||||
self.assertTrue(self.dialog.create_other_buttons.called)
|
||||
self.assertTrue(self.dialog.create_command_buttons.called)
|
||||
|
||||
def test_make_entry(self):
|
||||
equal = self.assertEqual
|
||||
self.dialog.row = 0
|
||||
self.dialog.top = Toplevel(self.root)
|
||||
entry, label = self.dialog.make_entry("Test:", 'hello')
|
||||
equal(label['text'], 'Test:')
|
||||
|
||||
self.assertIn(entry.get(), 'hello')
|
||||
egi = entry.grid_info()
|
||||
equal(int(egi['row']), 0)
|
||||
equal(int(egi['column']), 1)
|
||||
equal(int(egi['rowspan']), 1)
|
||||
equal(int(egi['columnspan']), 1)
|
||||
equal(self.dialog.row, 1)
|
||||
|
||||
def test_create_entries(self):
|
||||
self.dialog.row = 0
|
||||
self.engine.setpat('hello')
|
||||
self.dialog.create_entries()
|
||||
self.assertIn(self.dialog.ent.get(), 'hello')
|
||||
|
||||
def test_make_frame(self):
|
||||
self.dialog.row = 0
|
||||
self.dialog.top = Toplevel(self.root)
|
||||
frame, label = self.dialog.make_frame()
|
||||
self.assertEqual(label, '')
|
||||
self.assertIsInstance(frame, Frame)
|
||||
|
||||
frame, label = self.dialog.make_frame('testlabel')
|
||||
self.assertEqual(label['text'], 'testlabel')
|
||||
self.assertIsInstance(frame, Frame)
|
||||
|
||||
def btn_test_setup(self, meth):
|
||||
self.dialog.top = Toplevel(self.root)
|
||||
self.dialog.row = 0
|
||||
return meth()
|
||||
|
||||
def test_create_option_buttons(self):
|
||||
e = self.engine
|
||||
for state in (0, 1):
|
||||
for var in (e.revar, e.casevar, e.wordvar, e.wrapvar):
|
||||
var.set(state)
|
||||
frame, options = self.btn_test_setup(
|
||||
self.dialog.create_option_buttons)
|
||||
for spec, button in zip (options, frame.pack_slaves()):
|
||||
var, label = spec
|
||||
self.assertEqual(button['text'], label)
|
||||
self.assertEqual(var.get(), state)
|
||||
if state == 1:
|
||||
button.deselect()
|
||||
else:
|
||||
button.select()
|
||||
self.assertEqual(var.get(), 1 - state)
|
||||
|
||||
def test_create_other_buttons(self):
|
||||
for state in (False, True):
|
||||
var = self.engine.backvar
|
||||
var.set(state)
|
||||
frame, others = self.btn_test_setup(
|
||||
self.dialog.create_other_buttons)
|
||||
buttons = frame.pack_slaves()
|
||||
for spec, button in zip(others, buttons):
|
||||
val, label = spec
|
||||
self.assertEqual(button['text'], label)
|
||||
if val == state:
|
||||
# hit other button, then this one
|
||||
# indexes depend on button order
|
||||
self.assertEqual(var.get(), state)
|
||||
buttons[val].select()
|
||||
self.assertEqual(var.get(), 1 - state)
|
||||
buttons[1-val].select()
|
||||
self.assertEqual(var.get(), state)
|
||||
|
||||
def test_make_button(self):
|
||||
self.dialog.top = Toplevel(self.root)
|
||||
self.dialog.buttonframe = Frame(self.dialog.top)
|
||||
btn = self.dialog.make_button('Test', self.dialog.close)
|
||||
self.assertEqual(btn['text'], 'Test')
|
||||
|
||||
def test_create_command_buttons(self):
|
||||
self.dialog.create_command_buttons()
|
||||
# Look for close button command in buttonframe
|
||||
closebuttoncommand = ''
|
||||
for child in self.dialog.buttonframe.winfo_children():
|
||||
if child['text'] == 'close':
|
||||
closebuttoncommand = child['command']
|
||||
self.assertIn('close', closebuttoncommand)
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2, exit=2)
|
||||
329
Darwin/lib/python3.5/idlelib/idle_test/test_searchengine.py
Normal file
329
Darwin/lib/python3.5/idlelib/idle_test/test_searchengine.py
Normal file
|
|
@ -0,0 +1,329 @@
|
|||
'''Test functions and SearchEngine class in SearchEngine.py.'''
|
||||
|
||||
# With mock replacements, the module does not use any gui widgets.
|
||||
# The use of tk.Text is avoided (for now, until mock Text is improved)
|
||||
# by patching instances with an index function returning what is needed.
|
||||
# This works because mock Text.get does not use .index.
|
||||
|
||||
import re
|
||||
import unittest
|
||||
# from test.support import requires
|
||||
from tkinter import BooleanVar, StringVar, TclError # ,Tk, Text
|
||||
import tkinter.messagebox as tkMessageBox
|
||||
from idlelib import SearchEngine as se
|
||||
from idlelib.idle_test.mock_tk import Var, Mbox
|
||||
from idlelib.idle_test.mock_tk import Text as mockText
|
||||
|
||||
def setUpModule():
|
||||
# Replace s-e module tkinter imports other than non-gui TclError.
|
||||
se.BooleanVar = Var
|
||||
se.StringVar = Var
|
||||
se.tkMessageBox = Mbox
|
||||
|
||||
def tearDownModule():
|
||||
# Restore 'just in case', though other tests should also replace.
|
||||
se.BooleanVar = BooleanVar
|
||||
se.StringVar = StringVar
|
||||
se.tkMessageBox = tkMessageBox
|
||||
|
||||
|
||||
class Mock:
|
||||
def __init__(self, *args, **kwargs): pass
|
||||
|
||||
class GetTest(unittest.TestCase):
|
||||
# SearchEngine.get returns singleton created & saved on first call.
|
||||
def test_get(self):
|
||||
saved_Engine = se.SearchEngine
|
||||
se.SearchEngine = Mock # monkey-patch class
|
||||
try:
|
||||
root = Mock()
|
||||
engine = se.get(root)
|
||||
self.assertIsInstance(engine, se.SearchEngine)
|
||||
self.assertIs(root._searchengine, engine)
|
||||
self.assertIs(se.get(root), engine)
|
||||
finally:
|
||||
se.SearchEngine = saved_Engine # restore class to module
|
||||
|
||||
class GetLineColTest(unittest.TestCase):
|
||||
# Test simple text-independent helper function
|
||||
def test_get_line_col(self):
|
||||
self.assertEqual(se.get_line_col('1.0'), (1, 0))
|
||||
self.assertEqual(se.get_line_col('1.11'), (1, 11))
|
||||
|
||||
self.assertRaises(ValueError, se.get_line_col, ('1.0 lineend'))
|
||||
self.assertRaises(ValueError, se.get_line_col, ('end'))
|
||||
|
||||
class GetSelectionTest(unittest.TestCase):
|
||||
# Test text-dependent helper function.
|
||||
## # Need gui for text.index('sel.first/sel.last/insert').
|
||||
## @classmethod
|
||||
## def setUpClass(cls):
|
||||
## requires('gui')
|
||||
## cls.root = Tk()
|
||||
##
|
||||
## @classmethod
|
||||
## def tearDownClass(cls):
|
||||
## cls.root.destroy()
|
||||
## del cls.root
|
||||
|
||||
def test_get_selection(self):
|
||||
# text = Text(master=self.root)
|
||||
text = mockText()
|
||||
text.insert('1.0', 'Hello World!')
|
||||
|
||||
# fix text.index result when called in get_selection
|
||||
def sel(s):
|
||||
# select entire text, cursor irrelevant
|
||||
if s == 'sel.first': return '1.0'
|
||||
if s == 'sel.last': return '1.12'
|
||||
raise TclError
|
||||
text.index = sel # replaces .tag_add('sel', '1.0, '1.12')
|
||||
self.assertEqual(se.get_selection(text), ('1.0', '1.12'))
|
||||
|
||||
def mark(s):
|
||||
# no selection, cursor after 'Hello'
|
||||
if s == 'insert': return '1.5'
|
||||
raise TclError
|
||||
text.index = mark # replaces .mark_set('insert', '1.5')
|
||||
self.assertEqual(se.get_selection(text), ('1.5', '1.5'))
|
||||
|
||||
|
||||
class ReverseSearchTest(unittest.TestCase):
|
||||
# Test helper function that searches backwards within a line.
|
||||
def test_search_reverse(self):
|
||||
Equal = self.assertEqual
|
||||
line = "Here is an 'is' test text."
|
||||
prog = re.compile('is')
|
||||
Equal(se.search_reverse(prog, line, len(line)).span(), (12, 14))
|
||||
Equal(se.search_reverse(prog, line, 14).span(), (12, 14))
|
||||
Equal(se.search_reverse(prog, line, 13).span(), (5, 7))
|
||||
Equal(se.search_reverse(prog, line, 7).span(), (5, 7))
|
||||
Equal(se.search_reverse(prog, line, 6), None)
|
||||
|
||||
|
||||
class SearchEngineTest(unittest.TestCase):
|
||||
# Test class methods that do not use Text widget.
|
||||
|
||||
def setUp(self):
|
||||
self.engine = se.SearchEngine(root=None)
|
||||
# Engine.root is only used to create error message boxes.
|
||||
# The mock replacement ignores the root argument.
|
||||
|
||||
def test_is_get(self):
|
||||
engine = self.engine
|
||||
Equal = self.assertEqual
|
||||
|
||||
Equal(engine.getpat(), '')
|
||||
engine.setpat('hello')
|
||||
Equal(engine.getpat(), 'hello')
|
||||
|
||||
Equal(engine.isre(), False)
|
||||
engine.revar.set(1)
|
||||
Equal(engine.isre(), True)
|
||||
|
||||
Equal(engine.iscase(), False)
|
||||
engine.casevar.set(1)
|
||||
Equal(engine.iscase(), True)
|
||||
|
||||
Equal(engine.isword(), False)
|
||||
engine.wordvar.set(1)
|
||||
Equal(engine.isword(), True)
|
||||
|
||||
Equal(engine.iswrap(), True)
|
||||
engine.wrapvar.set(0)
|
||||
Equal(engine.iswrap(), False)
|
||||
|
||||
Equal(engine.isback(), False)
|
||||
engine.backvar.set(1)
|
||||
Equal(engine.isback(), True)
|
||||
|
||||
def test_setcookedpat(self):
|
||||
engine = self.engine
|
||||
engine.setcookedpat('\s')
|
||||
self.assertEqual(engine.getpat(), '\s')
|
||||
engine.revar.set(1)
|
||||
engine.setcookedpat('\s')
|
||||
self.assertEqual(engine.getpat(), r'\\s')
|
||||
|
||||
def test_getcookedpat(self):
|
||||
engine = self.engine
|
||||
Equal = self.assertEqual
|
||||
|
||||
Equal(engine.getcookedpat(), '')
|
||||
engine.setpat('hello')
|
||||
Equal(engine.getcookedpat(), 'hello')
|
||||
engine.wordvar.set(True)
|
||||
Equal(engine.getcookedpat(), r'\bhello\b')
|
||||
engine.wordvar.set(False)
|
||||
|
||||
engine.setpat('\s')
|
||||
Equal(engine.getcookedpat(), r'\\s')
|
||||
engine.revar.set(True)
|
||||
Equal(engine.getcookedpat(), '\s')
|
||||
|
||||
def test_getprog(self):
|
||||
engine = self.engine
|
||||
Equal = self.assertEqual
|
||||
|
||||
engine.setpat('Hello')
|
||||
temppat = engine.getprog()
|
||||
Equal(temppat.pattern, re.compile('Hello', re.IGNORECASE).pattern)
|
||||
engine.casevar.set(1)
|
||||
temppat = engine.getprog()
|
||||
Equal(temppat.pattern, re.compile('Hello').pattern, 0)
|
||||
|
||||
engine.setpat('')
|
||||
Equal(engine.getprog(), None)
|
||||
engine.setpat('+')
|
||||
engine.revar.set(1)
|
||||
Equal(engine.getprog(), None)
|
||||
self.assertEqual(Mbox.showerror.message,
|
||||
'Error: nothing to repeat at position 0\nPattern: +')
|
||||
|
||||
def test_report_error(self):
|
||||
showerror = Mbox.showerror
|
||||
Equal = self.assertEqual
|
||||
pat = '[a-z'
|
||||
msg = 'unexpected end of regular expression'
|
||||
|
||||
Equal(self.engine.report_error(pat, msg), None)
|
||||
Equal(showerror.title, 'Regular expression error')
|
||||
expected_message = ("Error: " + msg + "\nPattern: [a-z")
|
||||
Equal(showerror.message, expected_message)
|
||||
|
||||
Equal(self.engine.report_error(pat, msg, 5), None)
|
||||
Equal(showerror.title, 'Regular expression error')
|
||||
expected_message += "\nOffset: 5"
|
||||
Equal(showerror.message, expected_message)
|
||||
|
||||
|
||||
class SearchTest(unittest.TestCase):
|
||||
# Test that search_text makes right call to right method.
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
## requires('gui')
|
||||
## cls.root = Tk()
|
||||
## cls.text = Text(master=cls.root)
|
||||
cls.text = mockText()
|
||||
test_text = (
|
||||
'First line\n'
|
||||
'Line with target\n'
|
||||
'Last line\n')
|
||||
cls.text.insert('1.0', test_text)
|
||||
cls.pat = re.compile('target')
|
||||
|
||||
cls.engine = se.SearchEngine(None)
|
||||
cls.engine.search_forward = lambda *args: ('f', args)
|
||||
cls.engine.search_backward = lambda *args: ('b', args)
|
||||
|
||||
## @classmethod
|
||||
## def tearDownClass(cls):
|
||||
## cls.root.destroy()
|
||||
## del cls.root
|
||||
|
||||
def test_search(self):
|
||||
Equal = self.assertEqual
|
||||
engine = self.engine
|
||||
search = engine.search_text
|
||||
text = self.text
|
||||
pat = self.pat
|
||||
|
||||
engine.patvar.set(None)
|
||||
#engine.revar.set(pat)
|
||||
Equal(search(text), None)
|
||||
|
||||
def mark(s):
|
||||
# no selection, cursor after 'Hello'
|
||||
if s == 'insert': return '1.5'
|
||||
raise TclError
|
||||
text.index = mark
|
||||
Equal(search(text, pat), ('f', (text, pat, 1, 5, True, False)))
|
||||
engine.wrapvar.set(False)
|
||||
Equal(search(text, pat), ('f', (text, pat, 1, 5, False, False)))
|
||||
engine.wrapvar.set(True)
|
||||
engine.backvar.set(True)
|
||||
Equal(search(text, pat), ('b', (text, pat, 1, 5, True, False)))
|
||||
engine.backvar.set(False)
|
||||
|
||||
def sel(s):
|
||||
if s == 'sel.first': return '2.10'
|
||||
if s == 'sel.last': return '2.16'
|
||||
raise TclError
|
||||
text.index = sel
|
||||
Equal(search(text, pat), ('f', (text, pat, 2, 16, True, False)))
|
||||
Equal(search(text, pat, True), ('f', (text, pat, 2, 10, True, True)))
|
||||
engine.backvar.set(True)
|
||||
Equal(search(text, pat), ('b', (text, pat, 2, 10, True, False)))
|
||||
Equal(search(text, pat, True), ('b', (text, pat, 2, 16, True, True)))
|
||||
|
||||
|
||||
class ForwardBackwardTest(unittest.TestCase):
|
||||
# Test that search_forward method finds the target.
|
||||
## @classmethod
|
||||
## def tearDownClass(cls):
|
||||
## cls.root.destroy()
|
||||
## del cls.root
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.engine = se.SearchEngine(None)
|
||||
## requires('gui')
|
||||
## cls.root = Tk()
|
||||
## cls.text = Text(master=cls.root)
|
||||
cls.text = mockText()
|
||||
# search_backward calls index('end-1c')
|
||||
cls.text.index = lambda index: '4.0'
|
||||
test_text = (
|
||||
'First line\n'
|
||||
'Line with target\n'
|
||||
'Last line\n')
|
||||
cls.text.insert('1.0', test_text)
|
||||
cls.pat = re.compile('target')
|
||||
cls.res = (2, (10, 16)) # line, slice indexes of 'target'
|
||||
cls.failpat = re.compile('xyz') # not in text
|
||||
cls.emptypat = re.compile('\w*') # empty match possible
|
||||
|
||||
def make_search(self, func):
|
||||
def search(pat, line, col, wrap, ok=0):
|
||||
res = func(self.text, pat, line, col, wrap, ok)
|
||||
# res is (line, matchobject) or None
|
||||
return (res[0], res[1].span()) if res else res
|
||||
return search
|
||||
|
||||
def test_search_forward(self):
|
||||
# search for non-empty match
|
||||
Equal = self.assertEqual
|
||||
forward = self.make_search(self.engine.search_forward)
|
||||
pat = self.pat
|
||||
Equal(forward(pat, 1, 0, True), self.res)
|
||||
Equal(forward(pat, 3, 0, True), self.res) # wrap
|
||||
Equal(forward(pat, 3, 0, False), None) # no wrap
|
||||
Equal(forward(pat, 2, 10, False), self.res)
|
||||
|
||||
Equal(forward(self.failpat, 1, 0, True), None)
|
||||
Equal(forward(self.emptypat, 2, 9, True, ok=True), (2, (9, 9)))
|
||||
#Equal(forward(self.emptypat, 2, 9, True), self.res)
|
||||
# While the initial empty match is correctly ignored, skipping
|
||||
# the rest of the line and returning (3, (0,4)) seems buggy - tjr.
|
||||
Equal(forward(self.emptypat, 2, 10, True), self.res)
|
||||
|
||||
def test_search_backward(self):
|
||||
# search for non-empty match
|
||||
Equal = self.assertEqual
|
||||
backward = self.make_search(self.engine.search_backward)
|
||||
pat = self.pat
|
||||
Equal(backward(pat, 3, 5, True), self.res)
|
||||
Equal(backward(pat, 2, 0, True), self.res) # wrap
|
||||
Equal(backward(pat, 2, 0, False), None) # no wrap
|
||||
Equal(backward(pat, 2, 16, False), self.res)
|
||||
|
||||
Equal(backward(self.failpat, 3, 9, True), None)
|
||||
Equal(backward(self.emptypat, 2, 10, True, ok=True), (2, (9,9)))
|
||||
# Accepted because 9 < 10, not because ok=True.
|
||||
# It is not clear that ok=True is useful going back - tjr
|
||||
Equal(backward(self.emptypat, 2, 9, True), (2, (5, 9)))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2, exit=2)
|
||||
227
Darwin/lib/python3.5/idlelib/idle_test/test_text.py
Normal file
227
Darwin/lib/python3.5/idlelib/idle_test/test_text.py
Normal file
|
|
@ -0,0 +1,227 @@
|
|||
# Test mock_tk.Text class against tkinter.Text class by running same tests with both.
|
||||
import unittest
|
||||
from test.support import requires
|
||||
|
||||
from _tkinter import TclError
|
||||
|
||||
class TextTest(object):
|
||||
|
||||
hw = 'hello\nworld' # usual initial insert after initialization
|
||||
hwn = hw+'\n' # \n present at initialization, before insert
|
||||
|
||||
Text = None
|
||||
def setUp(self):
|
||||
self.text = self.Text()
|
||||
|
||||
def test_init(self):
|
||||
self.assertEqual(self.text.get('1.0'), '\n')
|
||||
self.assertEqual(self.text.get('end'), '')
|
||||
|
||||
def test_index_empty(self):
|
||||
index = self.text.index
|
||||
|
||||
for dex in (-1.0, 0.3, '1.-1', '1.0', '1.0 lineend', '1.end', '1.33',
|
||||
'insert'):
|
||||
self.assertEqual(index(dex), '1.0')
|
||||
|
||||
for dex in 'end', 2.0, '2.1', '33.44':
|
||||
self.assertEqual(index(dex), '2.0')
|
||||
|
||||
def test_index_data(self):
|
||||
index = self.text.index
|
||||
self.text.insert('1.0', self.hw)
|
||||
|
||||
for dex in -1.0, 0.3, '1.-1', '1.0':
|
||||
self.assertEqual(index(dex), '1.0')
|
||||
|
||||
for dex in '1.0 lineend', '1.end', '1.33':
|
||||
self.assertEqual(index(dex), '1.5')
|
||||
|
||||
for dex in 'end', '33.44':
|
||||
self.assertEqual(index(dex), '3.0')
|
||||
|
||||
def test_get(self):
|
||||
get = self.text.get
|
||||
Equal = self.assertEqual
|
||||
self.text.insert('1.0', self.hw)
|
||||
|
||||
Equal(get('end'), '')
|
||||
Equal(get('end', 'end'), '')
|
||||
Equal(get('1.0'), 'h')
|
||||
Equal(get('1.0', '1.1'), 'h')
|
||||
Equal(get('1.0', '1.3'), 'hel')
|
||||
Equal(get('1.1', '1.3'), 'el')
|
||||
Equal(get('1.0', '1.0 lineend'), 'hello')
|
||||
Equal(get('1.0', '1.10'), 'hello')
|
||||
Equal(get('1.0 lineend'), '\n')
|
||||
Equal(get('1.1', '2.3'), 'ello\nwor')
|
||||
Equal(get('1.0', '2.5'), self.hw)
|
||||
Equal(get('1.0', 'end'), self.hwn)
|
||||
Equal(get('0.0', '5.0'), self.hwn)
|
||||
|
||||
def test_insert(self):
|
||||
insert = self.text.insert
|
||||
get = self.text.get
|
||||
Equal = self.assertEqual
|
||||
|
||||
insert('1.0', self.hw)
|
||||
Equal(get('1.0', 'end'), self.hwn)
|
||||
|
||||
insert('1.0', '') # nothing
|
||||
Equal(get('1.0', 'end'), self.hwn)
|
||||
|
||||
insert('1.0', '*')
|
||||
Equal(get('1.0', 'end'), '*hello\nworld\n')
|
||||
|
||||
insert('1.0 lineend', '*')
|
||||
Equal(get('1.0', 'end'), '*hello*\nworld\n')
|
||||
|
||||
insert('2.3', '*')
|
||||
Equal(get('1.0', 'end'), '*hello*\nwor*ld\n')
|
||||
|
||||
insert('end', 'x')
|
||||
Equal(get('1.0', 'end'), '*hello*\nwor*ldx\n')
|
||||
|
||||
insert('1.4', 'x\n')
|
||||
Equal(get('1.0', 'end'), '*helx\nlo*\nwor*ldx\n')
|
||||
|
||||
def test_no_delete(self):
|
||||
# if index1 == 'insert' or 'end' or >= end, there is no deletion
|
||||
delete = self.text.delete
|
||||
get = self.text.get
|
||||
Equal = self.assertEqual
|
||||
self.text.insert('1.0', self.hw)
|
||||
|
||||
delete('insert')
|
||||
Equal(get('1.0', 'end'), self.hwn)
|
||||
|
||||
delete('end')
|
||||
Equal(get('1.0', 'end'), self.hwn)
|
||||
|
||||
delete('insert', 'end')
|
||||
Equal(get('1.0', 'end'), self.hwn)
|
||||
|
||||
delete('insert', '5.5')
|
||||
Equal(get('1.0', 'end'), self.hwn)
|
||||
|
||||
delete('1.4', '1.0')
|
||||
Equal(get('1.0', 'end'), self.hwn)
|
||||
|
||||
delete('1.4', '1.4')
|
||||
Equal(get('1.0', 'end'), self.hwn)
|
||||
|
||||
def test_delete_char(self):
|
||||
delete = self.text.delete
|
||||
get = self.text.get
|
||||
Equal = self.assertEqual
|
||||
self.text.insert('1.0', self.hw)
|
||||
|
||||
delete('1.0')
|
||||
Equal(get('1.0', '1.end'), 'ello')
|
||||
|
||||
delete('1.0', '1.1')
|
||||
Equal(get('1.0', '1.end'), 'llo')
|
||||
|
||||
# delete \n and combine 2 lines into 1
|
||||
delete('1.end')
|
||||
Equal(get('1.0', '1.end'), 'lloworld')
|
||||
|
||||
self.text.insert('1.3', '\n')
|
||||
delete('1.10')
|
||||
Equal(get('1.0', '1.end'), 'lloworld')
|
||||
|
||||
self.text.insert('1.3', '\n')
|
||||
delete('1.3', '2.0')
|
||||
Equal(get('1.0', '1.end'), 'lloworld')
|
||||
|
||||
def test_delete_slice(self):
|
||||
delete = self.text.delete
|
||||
get = self.text.get
|
||||
Equal = self.assertEqual
|
||||
self.text.insert('1.0', self.hw)
|
||||
|
||||
delete('1.0', '1.0 lineend')
|
||||
Equal(get('1.0', 'end'), '\nworld\n')
|
||||
|
||||
delete('1.0', 'end')
|
||||
Equal(get('1.0', 'end'), '\n')
|
||||
|
||||
self.text.insert('1.0', self.hw)
|
||||
delete('1.0', '2.0')
|
||||
Equal(get('1.0', 'end'), 'world\n')
|
||||
|
||||
delete('1.0', 'end')
|
||||
Equal(get('1.0', 'end'), '\n')
|
||||
|
||||
self.text.insert('1.0', self.hw)
|
||||
delete('1.2', '2.3')
|
||||
Equal(get('1.0', 'end'), 'held\n')
|
||||
|
||||
def test_multiple_lines(self): # insert and delete
|
||||
self.text.insert('1.0', 'hello')
|
||||
|
||||
self.text.insert('1.3', '1\n2\n3\n4\n5')
|
||||
self.assertEqual(self.text.get('1.0', 'end'), 'hel1\n2\n3\n4\n5lo\n')
|
||||
|
||||
self.text.delete('1.3', '5.1')
|
||||
self.assertEqual(self.text.get('1.0', 'end'), 'hello\n')
|
||||
|
||||
def test_compare(self):
|
||||
compare = self.text.compare
|
||||
Equal = self.assertEqual
|
||||
# need data so indexes not squished to 1,0
|
||||
self.text.insert('1.0', 'First\nSecond\nThird\n')
|
||||
|
||||
self.assertRaises(TclError, compare, '2.2', 'op', '2.2')
|
||||
|
||||
for op, less1, less0, equal, greater0, greater1 in (
|
||||
('<', True, True, False, False, False),
|
||||
('<=', True, True, True, False, False),
|
||||
('>', False, False, False, True, True),
|
||||
('>=', False, False, True, True, True),
|
||||
('==', False, False, True, False, False),
|
||||
('!=', True, True, False, True, True),
|
||||
):
|
||||
Equal(compare('1.1', op, '2.2'), less1, op)
|
||||
Equal(compare('2.1', op, '2.2'), less0, op)
|
||||
Equal(compare('2.2', op, '2.2'), equal, op)
|
||||
Equal(compare('2.3', op, '2.2'), greater0, op)
|
||||
Equal(compare('3.3', op, '2.2'), greater1, op)
|
||||
|
||||
|
||||
class MockTextTest(TextTest, unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
from idlelib.idle_test.mock_tk import Text
|
||||
cls.Text = Text
|
||||
|
||||
def test_decode(self):
|
||||
# test endflags (-1, 0) not tested by test_index (which uses +1)
|
||||
decode = self.text._decode
|
||||
Equal = self.assertEqual
|
||||
self.text.insert('1.0', self.hw)
|
||||
|
||||
Equal(decode('end', -1), (2, 5))
|
||||
Equal(decode('3.1', -1), (2, 5))
|
||||
Equal(decode('end', 0), (2, 6))
|
||||
Equal(decode('3.1', 0), (2, 6))
|
||||
|
||||
|
||||
class TkTextTest(TextTest, unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
requires('gui')
|
||||
from tkinter import Tk, Text
|
||||
cls.Text = Text
|
||||
cls.root = Tk()
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.root.destroy()
|
||||
del cls.root
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2, exit=False)
|
||||
97
Darwin/lib/python3.5/idlelib/idle_test/test_textview.py
Normal file
97
Darwin/lib/python3.5/idlelib/idle_test/test_textview.py
Normal file
|
|
@ -0,0 +1,97 @@
|
|||
'''Test the functions and main class method of textView.py.
|
||||
|
||||
Since all methods and functions create (or destroy) a TextViewer, which
|
||||
is a widget containing multiple widgets, all tests must be gui tests.
|
||||
Using mock Text would not change this. Other mocks are used to retrieve
|
||||
information about calls.
|
||||
|
||||
The coverage is essentially 100%.
|
||||
'''
|
||||
from test.support import requires
|
||||
requires('gui')
|
||||
|
||||
import unittest
|
||||
import os
|
||||
from tkinter import Tk
|
||||
from idlelib import textView as tv
|
||||
from idlelib.idle_test.mock_idle import Func
|
||||
from idlelib.idle_test.mock_tk import Mbox
|
||||
|
||||
def setUpModule():
|
||||
global root
|
||||
root = Tk()
|
||||
|
||||
def tearDownModule():
|
||||
global root
|
||||
root.destroy() # pyflakes falsely sees root as undefined
|
||||
del root
|
||||
|
||||
|
||||
class TV(tv.TextViewer): # used by TextViewTest
|
||||
transient = Func()
|
||||
grab_set = Func()
|
||||
wait_window = Func()
|
||||
|
||||
class TextViewTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
TV.transient.__init__()
|
||||
TV.grab_set.__init__()
|
||||
TV.wait_window.__init__()
|
||||
|
||||
def test_init_modal(self):
|
||||
view = TV(root, 'Title', 'test text')
|
||||
self.assertTrue(TV.transient.called)
|
||||
self.assertTrue(TV.grab_set.called)
|
||||
self.assertTrue(TV.wait_window.called)
|
||||
view.Ok()
|
||||
|
||||
def test_init_nonmodal(self):
|
||||
view = TV(root, 'Title', 'test text', modal=False)
|
||||
self.assertFalse(TV.transient.called)
|
||||
self.assertFalse(TV.grab_set.called)
|
||||
self.assertFalse(TV.wait_window.called)
|
||||
view.Ok()
|
||||
|
||||
def test_ok(self):
|
||||
view = TV(root, 'Title', 'test text', modal=False)
|
||||
view.destroy = Func()
|
||||
view.Ok()
|
||||
self.assertTrue(view.destroy.called)
|
||||
del view.destroy # unmask real function
|
||||
view.destroy
|
||||
|
||||
|
||||
class textviewTest(unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.orig_mbox = tv.tkMessageBox
|
||||
tv.tkMessageBox = Mbox
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
tv.tkMessageBox = cls.orig_mbox
|
||||
del cls.orig_mbox
|
||||
|
||||
def test_view_text(self):
|
||||
# If modal True, tkinter will error with 'can't invoke "event" command'
|
||||
view = tv.view_text(root, 'Title', 'test text', modal=False)
|
||||
self.assertIsInstance(view, tv.TextViewer)
|
||||
|
||||
def test_view_file(self):
|
||||
test_dir = os.path.dirname(__file__)
|
||||
testfile = os.path.join(test_dir, 'test_textview.py')
|
||||
view = tv.view_file(root, 'Title', testfile, modal=False)
|
||||
self.assertIsInstance(view, tv.TextViewer)
|
||||
self.assertIn('Test', view.textView.get('1.0', '1.end'))
|
||||
view.Ok()
|
||||
|
||||
# Mock messagebox will be used and view_file will not return anything
|
||||
testfile = os.path.join(test_dir, '../notthere.py')
|
||||
view = tv.view_file(root, 'Title', testfile, modal=False)
|
||||
self.assertIsNone(view)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2)
|
||||
73
Darwin/lib/python3.5/idlelib/idle_test/test_warning.py
Normal file
73
Darwin/lib/python3.5/idlelib/idle_test/test_warning.py
Normal file
|
|
@ -0,0 +1,73 @@
|
|||
'''Test warnings replacement in PyShell.py and run.py.
|
||||
|
||||
This file could be expanded to include traceback overrides
|
||||
(in same two modules). If so, change name.
|
||||
Revise if output destination changes (http://bugs.python.org/issue18318).
|
||||
Make sure warnings module is left unaltered (http://bugs.python.org/issue18081).
|
||||
'''
|
||||
|
||||
import unittest
|
||||
from test.support import captured_stderr
|
||||
|
||||
import warnings
|
||||
# Try to capture default showwarning before Idle modules are imported.
|
||||
showwarning = warnings.showwarning
|
||||
# But if we run this file within idle, we are in the middle of the run.main loop
|
||||
# and default showwarnings has already been replaced.
|
||||
running_in_idle = 'idle' in showwarning.__name__
|
||||
|
||||
from idlelib import run
|
||||
from idlelib import PyShell as shell
|
||||
|
||||
# The following was generated from PyShell.idle_formatwarning
|
||||
# and checked as matching expectation.
|
||||
idlemsg = '''
|
||||
Warning (from warnings module):
|
||||
File "test_warning.py", line 99
|
||||
Line of code
|
||||
UserWarning: Test
|
||||
'''
|
||||
shellmsg = idlemsg + ">>> "
|
||||
|
||||
class RunWarnTest(unittest.TestCase):
|
||||
|
||||
@unittest.skipIf(running_in_idle, "Does not work when run within Idle.")
|
||||
def test_showwarnings(self):
|
||||
self.assertIs(warnings.showwarning, showwarning)
|
||||
run.capture_warnings(True)
|
||||
self.assertIs(warnings.showwarning, run.idle_showwarning_subproc)
|
||||
run.capture_warnings(False)
|
||||
self.assertIs(warnings.showwarning, showwarning)
|
||||
|
||||
def test_run_show(self):
|
||||
with captured_stderr() as f:
|
||||
run.idle_showwarning_subproc(
|
||||
'Test', UserWarning, 'test_warning.py', 99, f, 'Line of code')
|
||||
# The following uses .splitlines to erase line-ending differences
|
||||
self.assertEqual(idlemsg.splitlines(), f.getvalue().splitlines())
|
||||
|
||||
class ShellWarnTest(unittest.TestCase):
|
||||
|
||||
@unittest.skipIf(running_in_idle, "Does not work when run within Idle.")
|
||||
def test_showwarnings(self):
|
||||
self.assertIs(warnings.showwarning, showwarning)
|
||||
shell.capture_warnings(True)
|
||||
self.assertIs(warnings.showwarning, shell.idle_showwarning)
|
||||
shell.capture_warnings(False)
|
||||
self.assertIs(warnings.showwarning, showwarning)
|
||||
|
||||
def test_idle_formatter(self):
|
||||
# Will fail if format changed without regenerating idlemsg
|
||||
s = shell.idle_formatwarning(
|
||||
'Test', UserWarning, 'test_warning.py', 99, 'Line of code')
|
||||
self.assertEqual(idlemsg, s)
|
||||
|
||||
def test_shell_show(self):
|
||||
with captured_stderr() as f:
|
||||
shell.idle_showwarning(
|
||||
'Test', UserWarning, 'test_warning.py', 99, f, 'Line of code')
|
||||
self.assertEqual(shellmsg.splitlines(), f.getvalue().splitlines())
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2, exit=False)
|
||||
122
Darwin/lib/python3.5/idlelib/idle_test/test_widgetredir.py
Normal file
122
Darwin/lib/python3.5/idlelib/idle_test/test_widgetredir.py
Normal file
|
|
@ -0,0 +1,122 @@
|
|||
"""Unittest for idlelib.WidgetRedirector
|
||||
|
||||
100% coverage
|
||||
"""
|
||||
from test.support import requires
|
||||
import unittest
|
||||
from idlelib.idle_test.mock_idle import Func
|
||||
from tkinter import Tk, Text, TclError
|
||||
from idlelib.WidgetRedirector import WidgetRedirector
|
||||
|
||||
|
||||
class InitCloseTest(unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
requires('gui')
|
||||
cls.tk = Tk()
|
||||
cls.text = Text(cls.tk)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.text.destroy()
|
||||
cls.tk.destroy()
|
||||
del cls.text, cls.tk
|
||||
|
||||
def test_init(self):
|
||||
redir = WidgetRedirector(self.text)
|
||||
self.assertEqual(redir.widget, self.text)
|
||||
self.assertEqual(redir.tk, self.text.tk)
|
||||
self.assertRaises(TclError, WidgetRedirector, self.text)
|
||||
redir.close() # restore self.tk, self.text
|
||||
|
||||
def test_close(self):
|
||||
redir = WidgetRedirector(self.text)
|
||||
redir.register('insert', Func)
|
||||
redir.close()
|
||||
self.assertEqual(redir._operations, {})
|
||||
self.assertFalse(hasattr(self.text, 'widget'))
|
||||
|
||||
|
||||
class WidgetRedirectorTest(unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
requires('gui')
|
||||
cls.tk = Tk()
|
||||
cls.text = Text(cls.tk)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.text.destroy()
|
||||
cls.tk.destroy()
|
||||
del cls.text, cls.tk
|
||||
|
||||
def setUp(self):
|
||||
self.redir = WidgetRedirector(self.text)
|
||||
self.func = Func()
|
||||
self.orig_insert = self.redir.register('insert', self.func)
|
||||
self.text.insert('insert', 'asdf') # leaves self.text empty
|
||||
|
||||
def tearDown(self):
|
||||
self.text.delete('1.0', 'end')
|
||||
self.redir.close()
|
||||
|
||||
def test_repr(self): # partly for 100% coverage
|
||||
self.assertIn('Redirector', repr(self.redir))
|
||||
self.assertIn('Original', repr(self.orig_insert))
|
||||
|
||||
def test_register(self):
|
||||
self.assertEqual(self.text.get('1.0', 'end'), '\n')
|
||||
self.assertEqual(self.func.args, ('insert', 'asdf'))
|
||||
self.assertIn('insert', self.redir._operations)
|
||||
self.assertIn('insert', self.text.__dict__)
|
||||
self.assertEqual(self.text.insert, self.func)
|
||||
|
||||
def test_original_command(self):
|
||||
self.assertEqual(self.orig_insert.operation, 'insert')
|
||||
self.assertEqual(self.orig_insert.tk_call, self.text.tk.call)
|
||||
self.orig_insert('insert', 'asdf')
|
||||
self.assertEqual(self.text.get('1.0', 'end'), 'asdf\n')
|
||||
|
||||
def test_unregister(self):
|
||||
self.assertIsNone(self.redir.unregister('invalid operation name'))
|
||||
self.assertEqual(self.redir.unregister('insert'), self.func)
|
||||
self.assertNotIn('insert', self.redir._operations)
|
||||
self.assertNotIn('insert', self.text.__dict__)
|
||||
|
||||
def test_unregister_no_attribute(self):
|
||||
del self.text.insert
|
||||
self.assertEqual(self.redir.unregister('insert'), self.func)
|
||||
|
||||
def test_dispatch_intercept(self):
|
||||
self.func.__init__(True)
|
||||
self.assertTrue(self.redir.dispatch('insert', False))
|
||||
self.assertFalse(self.func.args[0])
|
||||
|
||||
def test_dispatch_bypass(self):
|
||||
self.orig_insert('insert', 'asdf')
|
||||
# tk.call returns '' where Python would return None
|
||||
self.assertEqual(self.redir.dispatch('delete', '1.0', 'end'), '')
|
||||
self.assertEqual(self.text.get('1.0', 'end'), '\n')
|
||||
|
||||
def test_dispatch_error(self):
|
||||
self.func.__init__(TclError())
|
||||
self.assertEqual(self.redir.dispatch('insert', False), '')
|
||||
self.assertEqual(self.redir.dispatch('invalid'), '')
|
||||
|
||||
def test_command_dispatch(self):
|
||||
# Test that .__init__ causes redirection of tk calls
|
||||
# through redir.dispatch
|
||||
self.tk.call(self.text._w, 'insert', 'hello')
|
||||
self.assertEqual(self.func.args, ('hello',))
|
||||
self.assertEqual(self.text.get('1.0', 'end'), '\n')
|
||||
# Ensure that called through redir .dispatch and not through
|
||||
# self.text.insert by having mock raise TclError.
|
||||
self.func.__init__(TclError())
|
||||
self.assertEqual(self.tk.call(self.text._w, 'insert', 'boo'), '')
|
||||
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main(verbosity=2)
|
||||
Loading…
Add table
Add a link
Reference in a new issue