FM / idle

/usr/lib64/python2.7/idlelib/idle_test

Name	Size	Mode	Actions
htest.py	13779	0644	edit dl rm
htest.pyc	12600	0644	edit dl rm
htest.pyo	12600	0644	edit dl rm
mock_idle.py	1597	0644	edit dl rm
mock_idle.pyc	2879	0644	edit dl rm
mock_idle.pyo	2879	0644	edit dl rm
mock_tk.py	11574	0644	edit dl rm
mock_tk.pyc	12362	0644	edit dl rm
mock_tk.pyo	12362	0644	edit dl rm
README.txt	5492	0644	edit dl rm
test_autocomplete.py	4922	0644	edit dl rm
test_autocomplete.pyc	5860	0644	edit dl rm
test_autocomplete.pyo	5860	0644	edit dl rm
test_autoexpand.py	4122	0644	edit dl rm
test_autoexpand.pyc	4806	0644	edit dl rm
test_autoexpand.pyo	4806	0644	edit dl rm
test_calltips.py	7140	0644	edit dl rm
test_calltips.pyc	12131	0644	edit dl rm
test_calltips.pyo	12131	0644	edit dl rm
test_configdialog.py	782	0644	edit dl rm
test_configdialog.pyc	1655	0644	edit dl rm
test_configdialog.pyo	1655	0644	edit dl rm
test_config_name.py	2472	0644	edit dl rm
test_config_name.pyc	4012	0644	edit dl rm
test_config_name.pyo	4012	0644	edit dl rm
test_delegator.py	1294	0644	edit dl rm
test_delegator.pyc	1319	0644	edit dl rm
test_delegator.pyo	1319	0644	edit dl rm
test_editmenu.py	3167	0644	edit dl rm
test_editmenu.pyc	4439	0644	edit dl rm
test_editmenu.pyo	4439	0644	edit dl rm
test_formatparagraph.py	14344	0644	edit dl rm
test_formatparagraph.pyc	14318	0644	edit dl rm
test_formatparagraph.pyo	14318	0644	edit dl rm
test_grep.py	2762	0644	edit dl rm
test_grep.pyc	3760	0644	edit dl rm
test_grep.pyo	3760	0644	edit dl rm
test_helpabout.py	1611	0644	edit dl rm
test_helpabout.pyc	2363	0644	edit dl rm
test_helpabout.pyo	2363	0644	edit dl rm
test_hyperparser.py	5684	0644	edit dl rm
test_hyperparser.pyc	6734	0644	edit dl rm
test_hyperparser.pyo	6734	0644	edit dl rm
test_idlehistory.py	5495	0644	edit dl rm
test_idlehistory.pyc	8142	0644	edit dl rm
test_idlehistory.pyo	8142	0644	edit dl rm
test_io.py	9505	0644	edit dl rm
test_io.pyc	11533	0644	edit dl rm
test_io.pyo	11533	0644	edit dl rm
test_parenmatch.py	3822	0644	edit dl rm
test_parenmatch.pyc	5456	0644	edit dl rm
test_parenmatch.pyo	5456	0644	edit dl rm
test_pathbrowser.py	940	0644	edit dl rm
test_pathbrowser.pyc	1485	0644	edit dl rm
test_pathbrowser.pyo	1485	0644	edit dl rm
test_rstrip.py	1613	0644	edit dl rm
test_rstrip.pyc	1773	0644	edit dl rm
test_rstrip.pyo	1773	0644	edit dl rm
test_searchdialogbase.py	5863	0644	edit dl rm
test_searchdialogbase.pyc	6827	0644	edit dl rm
test_searchdialogbase.pyo	6827	0644	edit dl rm
test_searchengine.py	11487	0644	edit dl rm
test_searchengine.pyc	12649	0644	edit dl rm
test_searchengine.pyo	12649	0644	edit dl rm
test_text.py	6744	0644	edit dl rm
test_text.pyc	8148	0644	edit dl rm
test_text.pyo	8148	0644	edit dl rm
test_textview.py	2802	0644	edit dl rm
test_textview.pyc	4531	0644	edit dl rm
test_textview.pyo	4531	0644	edit dl rm
test_warning.py	2757	0644	edit dl rm
test_warning.pyc	3286	0644	edit dl rm
test_warning.pyo	3286	0644	edit dl rm
test_widgetredir.py	4177	0644	edit dl rm
test_widgetredir.pyc	6384	0644	edit dl rm
test_widgetredir.pyo	6384	0644	edit dl rm
__init__.py	650	0644	edit dl rm
__init__.pyc	915	0644	edit dl rm
__init__.pyo	915	0644	edit dl rm

Edit: /usr/lib64/python2.7/idlelib/idle_test/mock_tk.py (11574B)

"""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(object):
    '''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(object):
    "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(object):
    """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(object):
    """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(object):
    """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 contrained 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)

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

cmd: