| 1 |
"""Classes that replace tkinter gui objects used by an object being tested. |
| 2 |
|
| 3 |
A gui object is anything with a master or parent parameter, which is |
| 4 |
typically required in spite of what the doc strings say. |
| 5 |
""" |
| 6 |
import re |
| 7 |
from _tkinter import TclError |
| 8 |
|
| 9 |
|
| 10 |
class Event: |
| 11 |
'''Minimal mock with attributes for testing event handlers. |
| 12 |
|
| 13 |
This is not a gui object, but is used as an argument for callbacks |
| 14 |
that access attributes of the event passed. If a callback ignores |
| 15 |
the event, other than the fact that is happened, pass 'event'. |
| 16 |
|
| 17 |
Keyboard, mouse, window, and other sources generate Event instances. |
| 18 |
Event instances have the following attributes: serial (number of |
| 19 |
event), time (of event), type (of event as number), widget (in which |
| 20 |
event occurred), and x,y (position of mouse). There are other |
| 21 |
attributes for specific events, such as keycode for key events. |
| 22 |
tkinter.Event.__doc__ has more but is still not complete. |
| 23 |
''' |
| 24 |
def __init__(self, **kwds): |
| 25 |
"Create event with attributes needed for test" |
| 26 |
self.__dict__.update(kwds) |
| 27 |
|
| 28 |
|
| 29 |
class Var: |
| 30 |
"Use for String/Int/BooleanVar: incomplete" |
| 31 |
def __init__(self, master=None, value=None, name=None): |
| 32 |
self.master = master |
| 33 |
self.value = value |
| 34 |
self.name = name |
| 35 |
def set(self, value): |
| 36 |
self.value = value |
| 37 |
def get(self): |
| 38 |
return self.value |
| 39 |
|
| 40 |
|
| 41 |
class Mbox_func: |
| 42 |
"""Generic mock for messagebox functions, which all have the same signature. |
| 43 |
|
| 44 |
Instead of displaying a message box, the mock's call method saves the |
| 45 |
arguments as instance attributes, which test functions can then examine. |
| 46 |
The test can set the result returned to ask function |
| 47 |
""" |
| 48 |
def __init__(self, result=None): |
| 49 |
self.result = result # Return None for all show funcs |
| 50 |
def __call__(self, title, message, *args, **kwds): |
| 51 |
# Save all args for possible examination by tester |
| 52 |
self.title = title |
| 53 |
self.message = message |
| 54 |
self.args = args |
| 55 |
self.kwds = kwds |
| 56 |
return self.result # Set by tester for ask functions |
| 57 |
|
| 58 |
|
| 59 |
class Mbox: |
| 60 |
"""Mock for tkinter.messagebox with an Mbox_func for each function. |
| 61 |
|
| 62 |
Example usage in test_module.py for testing functions in module.py: |
| 63 |
--- |
| 64 |
from idlelib.idle_test.mock_tk import Mbox |
| 65 |
import module |
| 66 |
|
| 67 |
orig_mbox = module.messagebox |
| 68 |
showerror = Mbox.showerror # example, for attribute access in test methods |
| 69 |
|
| 70 |
class Test(unittest.TestCase): |
| 71 |
|
| 72 |
@classmethod |
| 73 |
def setUpClass(cls): |
| 74 |
module.messagebox = Mbox |
| 75 |
|
| 76 |
@classmethod |
| 77 |
def tearDownClass(cls): |
| 78 |
module.messagebox = orig_mbox |
| 79 |
--- |
| 80 |
For 'ask' functions, set func.result return value before calling the method |
| 81 |
that uses the message function. When messagebox functions are the |
| 82 |
only GUI calls in a method, this replacement makes the method GUI-free, |
| 83 |
""" |
| 84 |
askokcancel = Mbox_func() # True or False |
| 85 |
askquestion = Mbox_func() # 'yes' or 'no' |
| 86 |
askretrycancel = Mbox_func() # True or False |
| 87 |
askyesno = Mbox_func() # True or False |
| 88 |
askyesnocancel = Mbox_func() # True, False, or None |
| 89 |
showerror = Mbox_func() # None |
| 90 |
showinfo = Mbox_func() # None |
| 91 |
showwarning = Mbox_func() # None |
| 92 |
|
| 93 |
|
| 94 |
class Text: |
| 95 |
"""A semi-functional non-gui replacement for tkinter.Text text editors. |
| 96 |
|
| 97 |
The mock's data model is that a text is a list of \n-terminated lines. |
| 98 |
The mock adds an empty string at the beginning of the list so that the |
| 99 |
index of actual lines start at 1, as with Tk. The methods never see this. |
| 100 |
Tk initializes files with a terminal \n that cannot be deleted. It is |
| 101 |
invisible in the sense that one cannot move the cursor beyond it. |
| 102 |
|
| 103 |
This class is only tested (and valid) with strings of ascii chars. |
| 104 |
For testing, we are not concerned with Tk Text's treatment of, |
| 105 |
for instance, 0-width characters or character + accent. |
| 106 |
""" |
| 107 |
def __init__(self, master=None, cnf={}, **kw): |
| 108 |
'''Initialize mock, non-gui, text-only Text widget. |
| 109 |
|
| 110 |
At present, all args are ignored. Almost all affect visual behavior. |
| 111 |
There are just a few Text-only options that affect text behavior. |
| 112 |
''' |
| 113 |
self.data = ['', '\n'] |
| 114 |
|
| 115 |
def index(self, index): |
| 116 |
"Return string version of index decoded according to current text." |
| 117 |
return "%s.%s" % self._decode(index, endflag=1) |
| 118 |
|
| 119 |
def _decode(self, index, endflag=0): |
| 120 |
"""Return a (line, char) tuple of int indexes into self.data. |
| 121 |
|
| 122 |
This implements .index without converting the result back to a string. |
| 123 |
The result is constrained by the number of lines and linelengths of |
| 124 |
self.data. For many indexes, the result is initially (1, 0). |
| 125 |
|
| 126 |
The input index may have any of several possible forms: |
| 127 |
* line.char float: converted to 'line.char' string; |
| 128 |
* 'line.char' string, where line and char are decimal integers; |
| 129 |
* 'line.char lineend', where lineend='lineend' (and char is ignored); |
| 130 |
* 'line.end', where end='end' (same as above); |
| 131 |
* 'insert', the positions before terminal \n; |
| 132 |
* 'end', whose meaning depends on the endflag passed to ._endex. |
| 133 |
* 'sel.first' or 'sel.last', where sel is a tag -- not implemented. |
| 134 |
""" |
| 135 |
if isinstance(index, (float, bytes)): |
| 136 |
index = str(index) |
| 137 |
try: |
| 138 |
index=index.lower() |
| 139 |
except AttributeError: |
| 140 |
raise TclError('bad text index "%s"' % index) from None |
| 141 |
|
| 142 |
lastline = len(self.data) - 1 # same as number of text lines |
| 143 |
if index == 'insert': |
| 144 |
return lastline, len(self.data[lastline]) - 1 |
| 145 |
elif index == 'end': |
| 146 |
return self._endex(endflag) |
| 147 |
|
| 148 |
line, char = index.split('.') |
| 149 |
line = int(line) |
| 150 |
|
| 151 |
# Out of bounds line becomes first or last ('end') index |
| 152 |
if line < 1: |
| 153 |
return 1, 0 |
| 154 |
elif line > lastline: |
| 155 |
return self._endex(endflag) |
| 156 |
|
| 157 |
linelength = len(self.data[line]) -1 # position before/at \n |
| 158 |
if char.endswith(' lineend') or char == 'end': |
| 159 |
return line, linelength |
| 160 |
# Tk requires that ignored chars before ' lineend' be valid int |
| 161 |
if m := re.fullmatch(r'end-(\d*)c', char, re.A): # Used by hyperparser. |
| 162 |
return line, linelength - int(m.group(1)) |
| 163 |
|
| 164 |
# Out of bounds char becomes first or last index of line |
| 165 |
char = int(char) |
| 166 |
if char < 0: |
| 167 |
char = 0 |
| 168 |
elif char > linelength: |
| 169 |
char = linelength |
| 170 |
return line, char |
| 171 |
|
| 172 |
def _endex(self, endflag): |
| 173 |
'''Return position for 'end' or line overflow corresponding to endflag. |
| 174 |
|
| 175 |
-1: position before terminal \n; for .insert(), .delete |
| 176 |
0: position after terminal \n; for .get, .delete index 1 |
| 177 |
1: same viewed as beginning of non-existent next line (for .index) |
| 178 |
''' |
| 179 |
n = len(self.data) |
| 180 |
if endflag == 1: |
| 181 |
return n, 0 |
| 182 |
else: |
| 183 |
n -= 1 |
| 184 |
return n, len(self.data[n]) + endflag |
| 185 |
|
| 186 |
def insert(self, index, chars): |
| 187 |
"Insert chars before the character at index." |
| 188 |
|
| 189 |
if not chars: # ''.splitlines() is [], not [''] |
| 190 |
return |
| 191 |
chars = chars.splitlines(True) |
| 192 |
if chars[-1][-1] == '\n': |
| 193 |
chars.append('') |
| 194 |
line, char = self._decode(index, -1) |
| 195 |
before = self.data[line][:char] |
| 196 |
after = self.data[line][char:] |
| 197 |
self.data[line] = before + chars[0] |
| 198 |
self.data[line+1:line+1] = chars[1:] |
| 199 |
self.data[line+len(chars)-1] += after |
| 200 |
|
| 201 |
def get(self, index1, index2=None): |
| 202 |
"Return slice from index1 to index2 (default is 'index1+1')." |
| 203 |
|
| 204 |
startline, startchar = self._decode(index1) |
| 205 |
if index2 is None: |
| 206 |
endline, endchar = startline, startchar+1 |
| 207 |
else: |
| 208 |
endline, endchar = self._decode(index2) |
| 209 |
|
| 210 |
if startline == endline: |
| 211 |
return self.data[startline][startchar:endchar] |
| 212 |
else: |
| 213 |
lines = [self.data[startline][startchar:]] |
| 214 |
for i in range(startline+1, endline): |
| 215 |
lines.append(self.data[i]) |
| 216 |
lines.append(self.data[endline][:endchar]) |
| 217 |
return ''.join(lines) |
| 218 |
|
| 219 |
def delete(self, index1, index2=None): |
| 220 |
'''Delete slice from index1 to index2 (default is 'index1+1'). |
| 221 |
|
| 222 |
Adjust default index2 ('index+1) for line ends. |
| 223 |
Do not delete the terminal \n at the very end of self.data ([-1][-1]). |
| 224 |
''' |
| 225 |
startline, startchar = self._decode(index1, -1) |
| 226 |
if index2 is None: |
| 227 |
if startchar < len(self.data[startline])-1: |
| 228 |
# not deleting \n |
| 229 |
endline, endchar = startline, startchar+1 |
| 230 |
elif startline < len(self.data) - 1: |
| 231 |
# deleting non-terminal \n, convert 'index1+1 to start of next line |
| 232 |
endline, endchar = startline+1, 0 |
| 233 |
else: |
| 234 |
# do not delete terminal \n if index1 == 'insert' |
| 235 |
return |
| 236 |
else: |
| 237 |
endline, endchar = self._decode(index2, -1) |
| 238 |
# restricting end position to insert position excludes terminal \n |
| 239 |
|
| 240 |
if startline == endline and startchar < endchar: |
| 241 |
self.data[startline] = self.data[startline][:startchar] + \ |
| 242 |
self.data[startline][endchar:] |
| 243 |
elif startline < endline: |
| 244 |
self.data[startline] = self.data[startline][:startchar] + \ |
| 245 |
self.data[endline][endchar:] |
| 246 |
startline += 1 |
| 247 |
for i in range(startline, endline+1): |
| 248 |
del self.data[startline] |
| 249 |
|
| 250 |
def compare(self, index1, op, index2): |
| 251 |
line1, char1 = self._decode(index1) |
| 252 |
line2, char2 = self._decode(index2) |
| 253 |
if op == '<': |
| 254 |
return line1 < line2 or line1 == line2 and char1 < char2 |
| 255 |
elif op == '<=': |
| 256 |
return line1 < line2 or line1 == line2 and char1 <= char2 |
| 257 |
elif op == '>': |
| 258 |
return line1 > line2 or line1 == line2 and char1 > char2 |
| 259 |
elif op == '>=': |
| 260 |
return line1 > line2 or line1 == line2 and char1 >= char2 |
| 261 |
elif op == '==': |
| 262 |
return line1 == line2 and char1 == char2 |
| 263 |
elif op == '!=': |
| 264 |
return line1 != line2 or char1 != char2 |
| 265 |
else: |
| 266 |
raise TclError('''bad comparison operator "%s": ''' |
| 267 |
'''must be <, <=, ==, >=, >, or !=''' % op) |
| 268 |
|
| 269 |
# The following Text methods normally do something and return None. |
| 270 |
# Whether doing nothing is sufficient for a test will depend on the test. |
| 271 |
|
| 272 |
def mark_set(self, name, index): |
| 273 |
"Set mark *name* before the character at index." |
| 274 |
pass |
| 275 |
|
| 276 |
def mark_unset(self, *markNames): |
| 277 |
"Delete all marks in markNames." |
| 278 |
|
| 279 |
def tag_remove(self, tagName, index1, index2=None): |
| 280 |
"Remove tag tagName from all characters between index1 and index2." |
| 281 |
pass |
| 282 |
|
| 283 |
# The following Text methods affect the graphics screen and return None. |
| 284 |
# Doing nothing should always be sufficient for tests. |
| 285 |
|
| 286 |
def scan_dragto(self, x, y): |
| 287 |
"Adjust the view of the text according to scan_mark" |
| 288 |
|
| 289 |
def scan_mark(self, x, y): |
| 290 |
"Remember the current X, Y coordinates." |
| 291 |
|
| 292 |
def see(self, index): |
| 293 |
"Scroll screen to make the character at INDEX is visible." |
| 294 |
pass |
| 295 |
|
| 296 |
# The following is a Misc method inherited by Text. |
| 297 |
# It should properly go in a Misc mock, but is included here for now. |
| 298 |
|
| 299 |
def bind(sequence=None, func=None, add=None): |
| 300 |
"Bind to this widget at event sequence a call to function func." |
| 301 |
pass |
| 302 |
|
| 303 |
|
| 304 |
class Entry: |
| 305 |
"Mock for tkinter.Entry." |
| 306 |
def focus_set(self): |
| 307 |
pass |