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