[wxWidgets.git] / wxPython / wx / py / tests / test_introspect.py

#!/usr/bin/env python

__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
__cvsid__ = "$Id$"
__revision__ = "$Revision$"[11:-2]

import unittest

# Import from this module's parent directory.
import os
import sys
sys.path.insert(0, os.pardir)
import introspect
del sys.path[0]
del sys
del os


"""
These unittest methods are preferred:
-------------------------------------
self.assert_(expr, msg=None)
self.assertEqual(first, second, msg=None)
self.assertRaises(excClass, callableObj, *args, **kwargs)
self.fail(msg=None)
self.failIf(expr, msg=None)
"""


class ModuleTestCase(unittest.TestCase):

    def test_module(self):
        module = introspect
        self.assert_(module.__author__)
        self.assert_(module.__cvsid__)
        self.assert_(module.__revision__)
        self.assert_(module.getAllAttributeNames)
        self.assert_(module.getAttributeNames)
        self.assert_(module.getAutoCompleteList)
        self.assert_(module.getBaseObject)
        self.assert_(module.getCallTip)
        self.assert_(module.getConstructor)
        self.assert_(module.getRoot)
        self.assert_(module.rtrimTerminus)


class RtrimTerminusTestCase(unittest.TestCase):

    def test_rtrimTerminus(self):
        values = (
            ('', '', ''),
            ('', None, ''),
            ('', '.', ''),
            ('', '(', ''),
            
            ('.', '', '.'),
            ('.', None, '.'),
            ('.', '.', '.'),
            ('.', '(', '.'),
            
            ('(', '', '('),
            ('(', None, '('),
            ('(', '.', '('),
            ('(', '(', '('),
            
            ('spam', '', 'spam'),
            ('spam', None, 'spam'),
            ('spam', '.', 'spam'),
            ('spam', '(', 'spam'),
            
            ('spam.', '', 'spam.'),
            ('spam.', None, 'spam.'),
            ('spam.', '.', 'spam.'),
            ('spam.', '(', 'spam.'),
            
            ('spam(', '', 'spam('),
            ('spam(', None, 'spam('),
            ('spam(', '.', 'spam('),
            ('spam(', '(', 'spam('),
            
            ('spam.eggs', '.', 'spam.'),
            ('spam.eggs.', '.', 'spam.eggs.'),
            ('spam.eggs(', '(', 'spam.eggs('),
            ('spam.eggs.', '(', 'spam.eggs.'),
            ('spam.eggs(', '.', 'spam.'),
            
            ('x = spam.', '.', 'x = spam.'),
            ('x = spam.eggs', '.', 'x = spam.'),
            ('x = spam.eggs.', '.', 'x = spam.eggs.'),
            ('x = spam.eggs(', '(', 'x = spam.eggs('),
        )
        for input, terminator, output in values:
            result = introspect.rtrimTerminus(input, terminator)
            self.assertEqual(result, output,
                             ':in: %r :t: %r :out: %r :result: %r' %
                             (input, terminator, output, result))


class GetRootTestCase(unittest.TestCase):

    def _checkRoot(self, input, terminator, output):
        root = introspect.getRoot(command=input, terminator=terminator)
        self.assertEqual(root, output,
                         ':in: %r :t: %r :out: %r :root: %r' %
                         (input, terminator, output, root))

    def test_getRoot(self):
        values = (
            ('', '', ''),
            ('', None, ''),
            ('', '.', ''),
            ('', '(', ''),
            
            ('.', '', '.'),
            ('.', None, '.'),
            ('.', '.', ''),
            ('.', '(', '.'),
            
            ('(', '', ''),
            ('(', None, ''),
            ('(', '.', ''),
            ('(', '(', ''),
            
            ('spam', '', 'spam'),
            ('spam', None, 'spam'),
            ('spam', '.', ''),
            ('spam', '(', 'spam'),
            
            ('spam.', '', 'spam.'),
            ('spam.', None, 'spam.'),
            ('spam.', '.', 'spam'),
            ('spam.', '(', 'spam.'),
            
            ('spam(', '', ''),
            ('spam(', None, ''),
            ('spam(', '.', ''),
            ('spam(', '(', 'spam'),
            
            ('spam.eggs', '.', 'spam'),
            ('spam.eggs.', '.', 'spam.eggs'),
            ('spam.eggs(', '(', 'spam.eggs'),
            ('spam.eggs.', '(', 'spam.eggs.'),
            ('spam.eggs(', '.', 'spam'),
            
            ('x = spam.', '.', 'spam'),
            ('x = spam.eggs', '.', 'spam'),
            ('x = spam.eggs.', '.', 'spam.eggs'),
            ('x = spam.eggs(', '(', 'spam.eggs'),

            ('for n in range(3):\n    d.', '.', 'd'),
            ('for n in range(3):\n...    d.', '.', 'd'),
        )
        for input, terminator, output in values:
            self._checkRoot(input, terminator, output)

    def test_getRoot_Advanced(self):
        values = (
            ('spam_', '', 'spam_'),
            ('spam_', None, 'spam_'),
            ('spam_', '.', ''),
            ('spam_', '(', 'spam_'),
            
            ('_spam', '', '_spam'),
            ('_spam', None, '_spam'),
            ('_spam', '.', ''),
            ('_spam', '(', '_spam'),
            
            ('spam_eggs', '', 'spam_eggs'),
            ('spam_eggs', None, 'spam_eggs'),
            ('spam_eggs', '.', ''),
            ('spam_eggs', '(', 'spam_eggs'),
            
            ('spam123', '', 'spam123'),
            ('spam123', None, 'spam123'),
            ('spam123', '.', ''),
            ('spam123', '(', 'spam123'),

            ('spam_123', '', 'spam_123'),
            ('spam_123', None, 'spam_123'),
            ('spam_123', '.', ''),
            ('spam_123', '(', 'spam_123'),
        )
        for input, terminator, output in values:
            self._checkRoot(input, terminator, output)

## The original intent was to detect when we were inside a string.
## That has proven to be very difficult, for little benefit.
## The fact that autocomplete or calltips might be triggered inside
## a string is not a big deal. Sometimes it is even helpful.

##    def test_getRoot_InsideStrings(self):
##        values = (
##            ('x = ".', '.', ''),
##            ("x = '.", '.', ''),
##            ('x = """.', '.', ''),
##            ("x = '''.", '.', ''),
##
##            ('x = "(', '(', ''),
##            ("x = '(", '(', ''),
##            ('x = """(', '(', ''),
##            ("x = '''(", '(', ''),
##
##            ('x = "spam', '.', ''),
##            ('x = "spam.', '.', ''),
##            ("x = 'spam.", '.', ''),
##            ('x = """spam.', '.', ''),
##            ("x = '''spam.", '.', ''),
##            
##            ('x = "spam', '(', ''),
##            ('x = "spam(', '(', ''),
##            ("x = 'spam(", '(', ''),
##            ('x = """spam(', '(', ''),
##            ("x = '''spam(", '(', ''),
##            
##            ('x = "spam.eggs.', '.', ''),
##            ("x = 'spam.eggs.", '.', ''),
##            ('x = """spam.eggs.', '.', ''),
##            ("x = '''spam.eggs.", '.', ''),
##            
##            ('x = "spam.eggs(', '(', ''),
##            ("x = 'spam.eggs(", '(', ''),
##            ('x = """spam.eggs(', '(', ''),
##            ("x = '''spam.eggs(", '(', ''),
##        )
##        for input, terminator, output in values:
##            self._checkRoot(input, terminator, output)

    def test_getRoot_EmptyTypes(self):
        values = (
            ("''.", '.', "''"),
            ('"".', '.', '""'),
            ('"""""".', '.', '""""""'),
            ("''''''.", '.', "''''''"),

            ('[].', '.', '[]'),
            ('().', '.', '()'),
            ('{}.', '.', '{}'),
            
            ('[](', '(', '[]'),
            ('()(', '(', '()'),
            ('{}(', '(', '{}'),
            
            ("x = ''.", '.', "''"),
            ('x = "".', '.', '""'),
            ('x = """""".', '.', '""""""'),
            ("x = ''''''.", '.', "''''''"),

            ('x = [].', '.', '[]'),
            ('x = ().', '.', '()'),
            ('x = {}.', '.', '{}'),
            
            ('x = [](', '(', '[]'),
            ('x = ()(', '(', '()'),
            ('x = {}(', '(', '{}'),

            ('print [].', '.', '[]'),
            ('print ().', '.', '()'),
            ('print {}.', '.', '{}'),
            
            ('print [](', '(', '[]'),
            ('print ()(', '(', '()'),
            ('print {}(', '(', '{}'),

            ("''.attr.", '.', "''.attr"),
            ('"".attr.', '.', '"".attr'),
            ('"""""".attr.', '.', '"""""".attr'),
            ("''''''.attr.", '.', "''''''.attr"),

            ('[].attr.', '.', '[].attr'),
            ('().attr.', '.', '().attr'),
            ('{}.attr.', '.', '{}.attr'),
            
            ('[].attr(', '(', '[].attr'),
            ('().attr(', '(', '().attr'),
            ('{}.attr(', '(', '{}.attr'),

            ('spam().', '.', ''),
            ('spam_().', '.', ''),
            ('spam5().', '.', ''),
            ('spam[]().', '.', ''),
            ('spam()[].', '.', ''),
            ('spam[]{}.', '.', ''),

            ("spam(''.", '.', "''"),
            ('spam("".', '.', '""'),
            ('spam("""""".', '.', '""""""'),
            ("spam(''''''.", '.', "''''''"),

            ('spam([].', '.', '[]'),
            ('spam(().', '.', '()'),
            ('spam({}.', '.', '{}'),
            ('spam[[].', '.', '[]'),
            ('spam[().', '.', '()'),
            ('spam[{}.', '.', '{}'),
            ('x = {[].', '.', '[]'),
            ('x = {().', '.', '()'),
            ('x = {{}.', '.', '{}'),

            ('spam,[].', '.', '[]'),
            ('spam+[].', '.', '[]'),
            ('spam-[].', '.', '[]'),
            ('spam*[].', '.', '[]'),
            ('spam/[].', '.', '[]'),
            ('spam=[].', '.', '[]'),
            ('spam%[].', '.', '[]'),
            ('spam<[].', '.', '[]'),
            ('spam>[].', '.', '[]'),
            ('spam&[].', '.', '[]'),
            ('spam|[].', '.', '[]'),
            ('spam^[].', '.', '[]'),
            ('spam~[].', '.', '[]'),
            ('spam:[].', '.', '[]'),

            ('spam,().', '.', '()'),
            ('spam+().', '.', '()'),
            ('spam-().', '.', '()'),
            ('spam*().', '.', '()'),
            ('spam/().', '.', '()'),
            ('spam=().', '.', '()'),
            ('spam%().', '.', '()'),
            ('spam<().', '.', '()'),
            ('spam>().', '.', '()'),
            ('spam&().', '.', '()'),
            ('spam|().', '.', '()'),
            ('spam^().', '.', '()'),
            ('spam~().', '.', '()'),
            ('spam:().', '.', '()'),

            ('spam,{}.', '.', '{}'),
            ('spam+{}.', '.', '{}'),
            ('spam-{}.', '.', '{}'),
            ('spam*{}.', '.', '{}'),
            ('spam/{}.', '.', '{}'),
            ('spam={}.', '.', '{}'),
            ('spam%{}.', '.', '{}'),
            ('spam<{}.', '.', '{}'),
            ('spam>{}.', '.', '{}'),
            ('spam&{}.', '.', '{}'),
            ('spam|{}.', '.', '{}'),
            ('spam^{}.', '.', '{}'),
            ('spam~{}.', '.', '{}'),
            ('spam:{}.', '.', '{}'),
        )
        for input, terminator, output in values:
            self._checkRoot(input, terminator, output)


# Support for GetBaseObjectTestCase and GetAttributeNamesTestCase.

class Foo:
    def __init__(self):
        pass

    def __del__(self):
        pass

    def _private(self):
        pass

class Bar:
    pass

class Spam:
    def __call__(self):
        pass

    def foo(self):
        pass

    def bar(spam):
        # It shouldn't matter what we call "self".
        pass

    def eggs(self):
        pass

def ham(eggs):
    pass

class GetBaseObjectTestCase(unittest.TestCase):

    def test_getBaseObject(self):
        spam = Spam()
        eggs = Spam.eggs
        listappend = [].append
        spamda = lambda: None
        values = (
            ('spam', 'spam', 0),
            (123, 123, 0),
            (12.3, 12.3, 0),
            ([], [], 0),
            ((), (), 0),
            ({}, {}, 0),
            # Builtin function.
            (len, len, 0),
            # Builtin method.
            (listappend, listappend, 0),
            # User function.
            (ham, ham, 0),
            # Byte-compiled code.
            (ham.func_code, ham.func_code, 0),
            # Lambda.
            (spamda, spamda, 0),
            # Class with init.
            (Foo, Foo.__init__.im_func, 1),
            # Class with no init.
            (Bar, Bar, 0),
            # Bound method.
            (spam.foo, spam.foo.im_func, 1),
            # Bound method with self named something else (spam).
            (spam.bar, spam.bar.im_func, 1),
            # Unbound method. (Do not drop the self argument.)
            (eggs, eggs.im_func, 0),
            # Callable instance.
            (spam, spam.__call__.im_func, 1),
        )
        for object, baseObject, dropSelf in values:
            result = introspect.getBaseObject(object)
            self.assertEqual(result, (baseObject, dropSelf))


class GetAttributeTestCase(unittest.TestCase):
    """Base class for other test case classes."""

    def setUp(self):
        self.values = (
            '__abs__',
            '__add__',
            '__and__',
            '__base__',
            '__bases__',
            '__basicsize__',
            '__builtins__',
            '__call__',
            '__class__',
            '__cmp__',
            '__coerce__',
            '__contains__',
            '__del__',
            '__delattr__',
            '__delitem__',
            '__delslice__',
            '__dict__',
            '__dictoffset__',
            '__div__',
            '__divmod__',
            '__doc__',
            '__eq__',
            '__file__',
            '__flags__',
            '__float__',
            '__floordiv__',
            '__ge__',
            '__get__',
            '__getattr__',
            '__getattribute__',
            '__getitem__',
            '__getslice__',
            '__gt__',
            '__hash__',
            '__hex__',
            '__iadd__',
            '__imul__',
            '__init__',
            '__int__',
            '__invert__',
            '__itemsize__',
            '__iter__',
            '__le__',
            '__len__',
            '__long__',
            '__lshift__',
            '__lt__',
            '__mod__',
            '__module__',
            '__mro__',
            '__mul__',
            '__name__',
            '__ne__',
            '__neg__',
            '__new__',
            '__nonzero__',
            '__oct__',
            '__or__',
            '__path__',
            '__pos__',
            '__pow__',
            '__radd__',
            '__rand__',
            '__rdiv__',
            '__rdivmod__',
            '__reduce__',
            '__repr__',
            '__rfloordiv__',
            '__rlshift__',
            '__rmod__',
            '__rmul__',
            '__ror__',
            '__rpow__',
            '__rrshift__',
            '__rshift__',
            '__rsub__',
            '__rtruediv__',
            '__rxor__',
            '__self__',
            '__setattr__',
            '__setitem__',
            '__setslice__',
            '__str__',
            '__sub__',
            '__subclasses__',
            '__truediv__',
            '__warningregistry__',
            '__weakrefoffset__',
            '__xor__',
            'append',
            'capitalize',
            'center',
            'clear',
            'close',
            'closed',
            'co_argcount',
            'co_cellvars',
            'co_code',
            'co_consts',
            'co_filename',
            'co_firstlineno',
            'co_flags',
            'co_freevars',
            'co_lnotab',
            'co_name',
            'co_names',
            'co_nlocals',
            'co_stacksize',
            'co_varnames',
            'conjugate',
            'copy',
            'count',
            'decode',
            'encode',
            'endswith',
            'expandtabs',
            'extend',
            'fileno',
            'find',
            'flush',
            'func_closure',
            'func_code',
            'func_defaults',
            'func_dict',
            'func_doc',
            'func_globals',
            'func_name',
            'get',
            'has_key',
            'im_class',
            'im_func',
            'im_self',
            'imag',
            'index',
            'insert',
            'isalnum',
            'isalpha',
            'isatty',
            'isdigit',
            'islower',
            'isspace',
            'istitle',
            'isupper',
            'items',
            'iteritems',
            'iterkeys',
            'itervalues',
            'join',
            'keys',
            'ljust',
            'lower',
            'lstrip',
            'mode',
            'mro',
            'name',
            'pop',
            'popitem',
            'real',
            'read',
            'readinto',
            'readline',
            'readlines',
            'remove',
            'replace',
            'reverse',
            'rfind',
            'rindex',
            'rjust',
            'rstrip',
            'seek',
            'setdefault',
            'softspace',
            'sort',
            'split',
            'splitlines',
            'start',
            'startswith',
            'step',
            'stop',
            'strip',
            'swapcase',
            'tell',
            'title',
            'tolist',
            'translate',
            'truncate',
            'update',
            'upper',
            'values',
            'write',
            'writelines',
            'xreadlines',
        )

# Since getAllAttributeNames() calls str(object),
# we need to test for a broken __str__ method.
class BrokenStr:
    def __str__(self):
        raise Exception
    
brokenStr = BrokenStr()

class GetAttributeNamesTestCase(GetAttributeTestCase):

    def setUp(self):
        GetAttributeTestCase.setUp(self)
        from wx import py
        spam = Spam()
        self.f = open('test_introspect.py')
        self.items = (
            None,
            int(123),
            long(123),
            float(123),
            complex(123),
            "",
            unicode(""),
            [],
            (),
            xrange(0),
            {},
            # Builtin function.
            len,
            # Builtin method.
            [].append,
            # User function.
            ham,
            # Byte-compiled code.
            ham.func_code,
            # Lambda.
            lambda: None,
            # Class with no init.
            Bar,
            # Instance with no init.
            Bar(),
            # Class with init and del.
            Foo,
            # Instance with init and del.
            Foo(),
            # Bound method.
            spam.foo,
            # Unbound method.
            Spam.eggs,
            # Callable instance.
            spam,
            # Module.
            introspect,
            # Package.
            py,
            # Buffer.
            buffer(''),
            # File.
            self.f,
            # Slice.
            slice(0),
            # Ellipsis.
            Ellipsis,
            # BrokenStr class.
            BrokenStr,
            # BrokenStr instance.
            brokenStr,
        )

    def tearDown(self):
        self.items = None
        self.f.close()

    def test_getAttributeNames(self):
        for item in self.items:
            self._checkAttributeNames(item)
        if __builtins__.has_key('object'):
            self._checkAttributeNames(object)

    def test_getAttributeNames_NoSingle(self):
        for item in self.items:
            result = introspect.getAttributeNames(item, includeSingle=0)
            attributes = [attribute for attribute in result \
                          if attribute[0] != '_' or attribute[:2] == '__']
            self.assertEqual(result, attributes, 
                             ':item: %r' % (item,))

    def test_getAttributeNames_NoDouble(self):
        for item in self.items:
            result = introspect.getAttributeNames(item, includeDouble=0)
            attributes = [attribute for attribute in result \
                          if attribute[:2] != '__']
            self.assertEqual(result, attributes, 
                             ':item: %r' % (item,))

    def test_getAttributeNames_NoSingleOrDouble(self):
        for item in self.items:
            result = introspect.getAttributeNames(item, includeSingle=0, 
                                                  includeDouble=0)
            attributes = [attribute for attribute in result \
                          if attribute[0] != '_']
            self.assertEqual(result, attributes, 
                             ':item: %r' % (item,))

    def _checkAttributeNames(self, item):
        result = introspect.getAttributeNames(item)
        attributes = [attribute for attribute in self.values \
                      if hasattr(item, attribute)]
        for attribute in attributes:
            self.assert_(attribute in result, 
                         ':item: %r :attribute: %r' % (item, attribute))


class GetAutoCompleteListTestCase(GetAttributeTestCase):

    def setUp(self):
        GetAttributeTestCase.setUp(self)
        self.items = (
            'None.',
            '123 .',
            '"".',
            '[].',
            '().',
            '{}.',
            # Builtin function.
            'len.',
            # Builtin method.
            '[].append.',
        )

    def test_getAutoCompleteList(self):
        for item in self.items:
            result = introspect.getAutoCompleteList(item)
            object = eval(item[:-1])
            attributes = [attribute for attribute in self.values \
                          if hasattr(object, attribute)]
            for attribute in attributes:
                self.assert_(attribute in result, 
                             ':item: %r :attribute: %r' % (item, attribute))

    def test_getAutoCompleteList_NoSingle(self):
        for item in self.items:
            result = introspect.getAutoCompleteList(item, includeSingle=0)
            attributes = [attribute for attribute in result \
                          if attribute[0] != '_' or attribute[:2] == '__']
            self.assertEqual(result, attributes, 
                             ':item: %r' % (item,))

    def test_getAutoCompleteList_NoDouble(self):
        for item in self.items:
            result = introspect.getAutoCompleteList(item, includeDouble=0)
            attributes = [attribute for attribute in result \
                          if attribute[:2] != '__']
            self.assertEqual(result, attributes, 
                             ':item: %r' % (item,))

    def test_getAutoCompleteList_NoSingleOrDouble(self):
        for item in self.items:
            result = introspect.getAutoCompleteList(item, includeSingle=0, 
                                                    includeDouble=0)
            attributes = [attribute for attribute in result \
                          if attribute[0] != '_']
            self.assertEqual(result, attributes, 
                             ':item: %r' % (item,))


# Support for GetConstructorTestCase.

class A1:
    def __init__(self, a):
        self.a = a

class B1(A1):
    def __init__(self, b):
        self.b = b

class C1(A1):
    pass

class D1(C1, B1):
    pass

if __builtins__.has_key('object'):
    class A2(object):
        def __init__(self, a):
            self.a = a

    class B2(A2):
        def __init__(self, b):
            self.b = b

    class C2(A2):
        pass

    class D2(C2, B2):
        pass
    
class N:
    pass

class O:
    def __init__(self, a, b=2, *args, **kwargs):
        pass

class P(O):
    pass

class Q(P):
    def __init__(self, c, d=4):
        pass

class GetConstructorTestCase(unittest.TestCase):

    def test_getConstructor(self):
        args = ('self', 'a', 'b', 'args', 'kwargs')
        varnames = introspect.getConstructor(O).func_code.co_varnames
        self.assertEqual(varnames, args)
        varnames = introspect.getConstructor(P).func_code.co_varnames
        self.assertEqual(varnames, args)
        args = ('self', 'c', 'd')
        varnames = introspect.getConstructor(Q).func_code.co_varnames
        self.assertEqual(varnames, args)

    def test_getConstructor_None(self):
        values = (N, 1, 'spam', {}, [], (), dir)
        for value in values:
            self.assertEqual(introspect.getConstructor(N), None)

    def test_getConstructor_MultipleInheritance(self):
        # Test old style inheritance rules.
        args = ('self', 'a')
        varnames = introspect.getConstructor(D1).func_code.co_varnames
        self.assertEqual(varnames, args)
        if __builtins__.has_key('object'):
            # Test new style inheritance rules as well.
            args = ('self', 'b')
            varnames = introspect.getConstructor(D2).func_code.co_varnames
            self.assertEqual(varnames, args)


if __name__ == '__main__':
    unittest.main()
Commit	Line	Data
1fded56b RD	1	#!/usr/bin/env python
	2
	3	__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
	4	__cvsid__ = "$Id$"
	5	__revision__ = "$Revision$"[11:-2]
	6
	7	import unittest
	8
	9	# Import from this module's parent directory.
	10	import os
	11	import sys
	12	sys.path.insert(0, os.pardir)
	13	import introspect
	14	del sys.path[0]
	15	del sys
	16	del os
	17
	18
	19	"""
	20	These unittest methods are preferred:
	21	-------------------------------------
	22	self.assert_(expr, msg=None)
	23	self.assertEqual(first, second, msg=None)
	24	self.assertRaises(excClass, callableObj, args, *kwargs)
	25	self.fail(msg=None)
	26	self.failIf(expr, msg=None)
	27	"""
	28
	29
	30	class ModuleTestCase(unittest.TestCase):
	31
	32	def test_module(self):
	33	module = introspect
	34	self.assert_(module.__author__)
	35	self.assert_(module.__cvsid__)
	36	self.assert_(module.__revision__)
	37	self.assert_(module.getAllAttributeNames)
	38	self.assert_(module.getAttributeNames)
	39	self.assert_(module.getAutoCompleteList)
	40	self.assert_(module.getBaseObject)
	41	self.assert_(module.getCallTip)
	42	self.assert_(module.getConstructor)
	43	self.assert_(module.getRoot)
	44	self.assert_(module.rtrimTerminus)
	45
	46
	47	class RtrimTerminusTestCase(unittest.TestCase):
	48
	49	def test_rtrimTerminus(self):
	50	values = (
	51	('', '', ''),
	52	('', None, ''),
	53	('', '.', ''),
	54	('', '(', ''),
	55
	56	('.', '', '.'),
	57	('.', None, '.'),
	58	('.', '.', '.'),
	59	('.', '(', '.'),
	60
	61	('(', '', '('),
	62	('(', None, '('),
	63	('(', '.', '('),
	64	('(', '(', '('),
65
66	('spam', '', 'spam'),
67	('spam', None, 'spam'),
68	('spam', '.', 'spam'),
69	('spam', '(', 'spam'),
70
71	('spam.', '', 'spam.'),
72	('spam.', None, 'spam.'),
73	('spam.', '.', 'spam.'),
74	('spam.', '(', 'spam.'),
75
76	('spam(', '', 'spam('),
77	('spam(', None, 'spam('),
78	('spam(', '.', 'spam('),
79	('spam(', '(', 'spam('),
80
81	('spam.eggs', '.', 'spam.'),
82	('spam.eggs.', '.', 'spam.eggs.'),
83	('spam.eggs(', '(', 'spam.eggs('),
84	('spam.eggs.', '(', 'spam.eggs.'),
85	('spam.eggs(', '.', 'spam.'),
86
87	('x = spam.', '.', 'x = spam.'),
88	('x = spam.eggs', '.', 'x = spam.'),
89	('x = spam.eggs.', '.', 'x = spam.eggs.'),
90	('x = spam.eggs(', '(', 'x = spam.eggs('),
91	)
92	for input, terminator, output in values:
93	result = introspect.rtrimTerminus(input, terminator)
94	self.assertEqual(result, output,
95	':in: %r :t: %r :out: %r :result: %r' %
96	(input, terminator, output, result))
97
98
99	class GetRootTestCase(unittest.TestCase):
100
101	def _checkRoot(self, input, terminator, output):
102	root = introspect.getRoot(command=input, terminator=terminator)
103	self.assertEqual(root, output,
104	':in: %r :t: %r :out: %r :root: %r' %
105	(input, terminator, output, root))
106
107	def test_getRoot(self):
108	values = (
109	('', '', ''),
110	('', None, ''),
111	('', '.', ''),
112	('', '(', ''),
113
114	('.', '', '.'),
115	('.', None, '.'),
116	('.', '.', ''),
117	('.', '(', '.'),
118
119	('(', '', ''),
120	('(', None, ''),
121	('(', '.', ''),
122	('(', '(', ''),
123
124	('spam', '', 'spam'),
125	('spam', None, 'spam'),
126	('spam', '.', ''),
127	('spam', '(', 'spam'),
128
129	('spam.', '', 'spam.'),
130	('spam.', None, 'spam.'),
131	('spam.', '.', 'spam'),
132	('spam.', '(', 'spam.'),
133
134	('spam(', '', ''),
135	('spam(', None, ''),
136	('spam(', '.', ''),
137	('spam(', '(', 'spam'),
138
139	('spam.eggs', '.', 'spam'),
140	('spam.eggs.', '.', 'spam.eggs'),
141	('spam.eggs(', '(', 'spam.eggs'),
142	('spam.eggs.', '(', 'spam.eggs.'),
143	('spam.eggs(', '.', 'spam'),
144
145	('x = spam.', '.', 'spam'),
146	('x = spam.eggs', '.', 'spam'),
147	('x = spam.eggs.', '.', 'spam.eggs'),
148	('x = spam.eggs(', '(', 'spam.eggs'),
149
150	('for n in range(3):\n d.', '.', 'd'),
151	('for n in range(3):\n... d.', '.', 'd'),
152	)
153	for input, terminator, output in values:
154	self._checkRoot(input, terminator, output)
155
156	def test_getRoot_Advanced(self):
157	values = (
158	('spam_', '', 'spam_'),
159	('spam_', None, 'spam_'),
160	('spam_', '.', ''),
161	('spam_', '(', 'spam_'),
162
163	('_spam', '', '_spam'),
164	('_spam', None, '_spam'),
165	('_spam', '.', ''),
166	('_spam', '(', '_spam'),
167
168	('spam_eggs', '', 'spam_eggs'),
169	('spam_eggs', None, 'spam_eggs'),
170	('spam_eggs', '.', ''),
171	('spam_eggs', '(', 'spam_eggs'),
172
173	('spam123', '', 'spam123'),
174	('spam123', None, 'spam123'),
175	('spam123', '.', ''),
176	('spam123', '(', 'spam123'),
177
178	('spam_123', '', 'spam_123'),
179	('spam_123', None, 'spam_123'),
180	('spam_123', '.', ''),
181	('spam_123', '(', 'spam_123'),
182	)
183	for input, terminator, output in values:
184	self._checkRoot(input, terminator, output)
185
186	## The original intent was to detect when we were inside a string.
187	## That has proven to be very difficult, for little benefit.
188	## The fact that autocomplete or calltips might be triggered inside
189	## a string is not a big deal. Sometimes it is even helpful.
190
191	## def test_getRoot_InsideStrings(self):
192	## values = (
193	## ('x = ".', '.', ''),
194	## ("x = '.", '.', ''),
195	## ('x = """.', '.', ''),
196	## ("x = '''.", '.', ''),
197	##
198	## ('x = "(', '(', ''),
199	## ("x = '(", '(', ''),
200	## ('x = """(', '(', ''),
201	## ("x = '''(", '(', ''),
202	##
203	## ('x = "spam', '.', ''),
204	## ('x = "spam.', '.', ''),
205	## ("x = 'spam.", '.', ''),
206	## ('x = """spam.', '.', ''),
207	## ("x = '''spam.", '.', ''),
208	##
209	## ('x = "spam', '(', ''),
210	## ('x = "spam(', '(', ''),
211	## ("x = 'spam(", '(', ''),
212	## ('x = """spam(', '(', ''),
213	## ("x = '''spam(", '(', ''),
214	##
215	## ('x = "spam.eggs.', '.', ''),
216	## ("x = 'spam.eggs.", '.', ''),
217	## ('x = """spam.eggs.', '.', ''),
218	## ("x = '''spam.eggs.", '.', ''),
219	##
220	## ('x = "spam.eggs(', '(', ''),
221	## ("x = 'spam.eggs(", '(', ''),
222	## ('x = """spam.eggs(', '(', ''),
223	## ("x = '''spam.eggs(", '(', ''),
224	## )
225	## for input, terminator, output in values:
226	## self._checkRoot(input, terminator, output)
227
228	def test_getRoot_EmptyTypes(self):
229	values = (
230	("''.", '.', "''"),
231	('"".', '.', '""'),
232	('"""""".', '.', '""""""'),
233	("''''''.", '.', "''''''"),
234
235	('[].', '.', '[]'),
236	('().', '.', '()'),
237	('{}.', '.', '{}'),
238
239	('[](', '(', '[]'),
240	('()(', '(', '()'),
241	('{}(', '(', '{}'),
242
243	("x = ''.", '.', "''"),
244	('x = "".', '.', '""'),
245	('x = """""".', '.', '""""""'),
246	("x = ''''''.", '.', "''''''"),
247
248	('x = [].', '.', '[]'),
249	('x = ().', '.', '()'),
250	('x = {}.', '.', '{}'),
251
252	('x = [](', '(', '[]'),
253	('x = ()(', '(', '()'),
254	('x = {}(', '(', '{}'),
255
256	('print [].', '.', '[]'),
257	('print ().', '.', '()'),
258	('print {}.', '.', '{}'),
259
260	('print [](', '(', '[]'),
261	('print ()(', '(', '()'),
262	('print {}(', '(', '{}'),
263
264	("''.attr.", '.', "''.attr"),
265	('"".attr.', '.', '"".attr'),
266	('"""""".attr.', '.', '"""""".attr'),
267	("''''''.attr.", '.', "''''''.attr"),
268
269	('[].attr.', '.', '[].attr'),
270	('().attr.', '.', '().attr'),
271	('{}.attr.', '.', '{}.attr'),
272
273	('[].attr(', '(', '[].attr'),
274	('().attr(', '(', '().attr'),
275	('{}.attr(', '(', '{}.attr'),
276
277	('spam().', '.', ''),
278	('spam_().', '.', ''),
279	('spam5().', '.', ''),
280	('spam[]().', '.', ''),
281	('spam()[].', '.', ''),
282	('spam[]{}.', '.', ''),
283
284	("spam(''.", '.', "''"),
285	('spam("".', '.', '""'),
286	('spam("""""".', '.', '""""""'),
287	("spam(''''''.", '.', "''''''"),
288
289	('spam([].', '.', '[]'),
290	('spam(().', '.', '()'),
291	('spam({}.', '.', '{}'),
292	('spam[[].', '.', '[]'),
293	('spam[().', '.', '()'),
294	('spam[{}.', '.', '{}'),
295	('x = {[].', '.', '[]'),
296	('x = {().', '.', '()'),
297	('x = {{}.', '.', '{}'),
298
299	('spam,[].', '.', '[]'),
300	('spam+[].', '.', '[]'),
301	('spam-[].', '.', '[]'),
302	('spam*[].', '.', '[]'),
303	('spam/[].', '.', '[]'),
304	('spam=[].', '.', '[]'),
305	('spam%[].', '.', '[]'),
306	('spam<[].', '.', '[]'),
307	('spam>[].', '.', '[]'),
308	('spam&[].', '.', '[]'),
309	('spam\|[].', '.', '[]'),
310	('spam^[].', '.', '[]'),
311	('spam~[].', '.', '[]'),
312	('spam:[].', '.', '[]'),
313
314	('spam,().', '.', '()'),
315	('spam+().', '.', '()'),
316	('spam-().', '.', '()'),
317	('spam*().', '.', '()'),
318	('spam/().', '.', '()'),
319	('spam=().', '.', '()'),
320	('spam%().', '.', '()'),
321	('spam<().', '.', '()'),
322	('spam>().', '.', '()'),
323	('spam&().', '.', '()'),
324	('spam\|().', '.', '()'),
325	('spam^().', '.', '()'),
326	('spam~().', '.', '()'),
327	('spam:().', '.', '()'),
328
329	('spam,{}.', '.', '{}'),
330	('spam+{}.', '.', '{}'),
331	('spam-{}.', '.', '{}'),
332	('spam*{}.', '.', '{}'),
333	('spam/{}.', '.', '{}'),
334	('spam={}.', '.', '{}'),
335	('spam%{}.', '.', '{}'),
336	('spam<{}.', '.', '{}'),
337	('spam>{}.', '.', '{}'),
338	('spam&{}.', '.', '{}'),
339	('spam\|{}.', '.', '{}'),
340	('spam^{}.', '.', '{}'),
341	('spam~{}.', '.', '{}'),
342	('spam:{}.', '.', '{}'),
343	)
344	for input, terminator, output in values:
345	self._checkRoot(input, terminator, output)
346
347
348	# Support for GetBaseObjectTestCase and GetAttributeNamesTestCase.
349
350	class Foo:
351	def __init__(self):
352	pass
353
354	def __del__(self):
355	pass
356
357	def _private(self):
358	pass
359
360	class Bar:
361	pass
362
363	class Spam:
364	def __call__(self):
365	pass
366
367	def foo(self):
368	pass
369
370	def bar(spam):
371	# It shouldn't matter what we call "self".
372	pass
373
374	def eggs(self):
375	pass
376
377	def ham(eggs):
378	pass
379
380	class GetBaseObjectTestCase(unittest.TestCase):
381
382	def test_getBaseObject(self):
383	spam = Spam()
384	eggs = Spam.eggs
385	listappend = [].append
386	spamda = lambda: None
387	values = (
388	('spam', 'spam', 0),
389	(123, 123, 0),
390	(12.3, 12.3, 0),
391	([], [], 0),
392	((), (), 0),
393	({}, {}, 0),
394	# Builtin function.
395	(len, len, 0),
396	# Builtin method.
397	(listappend, listappend, 0),
398	# User function.
399	(ham, ham, 0),
400	# Byte-compiled code.
401	(ham.func_code, ham.func_code, 0),
402	# Lambda.
403	(spamda, spamda, 0),
404	# Class with init.
405	(Foo, Foo.__init__.im_func, 1),
406	# Class with no init.
407	(Bar, Bar, 0),
408	# Bound method.
409	(spam.foo, spam.foo.im_func, 1),
410	# Bound method with self named something else (spam).
411	(spam.bar, spam.bar.im_func, 1),
412	# Unbound method. (Do not drop the self argument.)
413	(eggs, eggs.im_func, 0),
414	# Callable instance.
415	(spam, spam.__call__.im_func, 1),
416	)
417	for object, baseObject, dropSelf in values:
418	result = introspect.getBaseObject(object)
419	self.assertEqual(result, (baseObject, dropSelf))
420
421
422	class GetAttributeTestCase(unittest.TestCase):
423	"""Base class for other test case classes."""
424
425	def setUp(self):
426	self.values = (
427	'__abs__',
428	'__add__',
429	'__and__',
430	'__base__',
431	'__bases__',
432	'__basicsize__',
433	'__builtins__',
434	'__call__',
435	'__class__',
436	'__cmp__',
437	'__coerce__',
438	'__contains__',
439	'__del__',
440	'__delattr__',
441	'__delitem__',
442	'__delslice__',
443	'__dict__',
444	'__dictoffset__',
445	'__div__',
446	'__divmod__',
447	'__doc__',
448	'__eq__',
449	'__file__',
450	'__flags__',
451	'__float__',
452	'__floordiv__',
453	'__ge__',
454	'__get__',
455	'__getattr__',
456	'__getattribute__',
457	'__getitem__',
458	'__getslice__',
459	'__gt__',
460	'__hash__',
461	'__hex__',
462	'__iadd__',
463	'__imul__',
464	'__init__',
465	'__int__',
466	'__invert__',
467	'__itemsize__',
468	'__iter__',
469	'__le__',
470	'__len__',
471	'__long__',
472	'__lshift__',
473	'__lt__',
474	'__mod__',
475	'__module__',
476	'__mro__',
477	'__mul__',
478	'__name__',
479	'__ne__',
480	'__neg__',
481	'__new__',
482	'__nonzero__',
483	'__oct__',
484	'__or__',
485	'__path__',
486	'__pos__',
487	'__pow__',
488	'__radd__',
489	'__rand__',
490	'__rdiv__',
491	'__rdivmod__',
492	'__reduce__',
493	'__repr__',
494	'__rfloordiv__',
495	'__rlshift__',
496	'__rmod__',
497	'__rmul__',
498	'__ror__',
499	'__rpow__',
500	'__rrshift__',
501	'__rshift__',
502	'__rsub__',
503	'__rtruediv__',
504	'__rxor__',
505	'__self__',
506	'__setattr__',
507	'__setitem__',
508	'__setslice__',
509	'__str__',
510	'__sub__',
511	'__subclasses__',
512	'__truediv__',
513	'__warningregistry__',
514	'__weakrefoffset__',
515	'__xor__',
516	'append',
517	'capitalize',
518	'center',
519	'clear',
520	'close',
521	'closed',
522	'co_argcount',
523	'co_cellvars',
524	'co_code',
525	'co_consts',
526	'co_filename',
527	'co_firstlineno',
528	'co_flags',
529	'co_freevars',
530	'co_lnotab',
531	'co_name',
532	'co_names',
533	'co_nlocals',
534	'co_stacksize',
535	'co_varnames',
536	'conjugate',
537	'copy',
538	'count',
539	'decode',
540	'encode',
541	'endswith',
542	'expandtabs',
543	'extend',
544	'fileno',
545	'find',
546	'flush',
547	'func_closure',
548	'func_code',
549	'func_defaults',
550	'func_dict',
551	'func_doc',
552	'func_globals',
553	'func_name',
554	'get',
555	'has_key',
556	'im_class',
557	'im_func',
558	'im_self',
559	'imag',
560	'index',
561	'insert',
562	'isalnum',
563	'isalpha',
564	'isatty',
565	'isdigit',
566	'islower',
567	'isspace',
568	'istitle',
569	'isupper',
570	'items',
571	'iteritems',
572	'iterkeys',
573	'itervalues',
574	'join',
575	'keys',
576	'ljust',
577	'lower',
578	'lstrip',
579	'mode',
580	'mro',
581	'name',
582	'pop',
583	'popitem',
584	'real',
585	'read',
586	'readinto',
587	'readline',
588	'readlines',
589	'remove',
590	'replace',
591	'reverse',
592	'rfind',
593	'rindex',
594	'rjust',
595	'rstrip',
596	'seek',
597	'setdefault',
598	'softspace',
599	'sort',
600	'split',
601	'splitlines',
602	'start',
603	'startswith',
604	'step',
605	'stop',
606	'strip',
607	'swapcase',
608	'tell',
609	'title',
610	'tolist',
611	'translate',
612	'truncate',
613	'update',
614	'upper',
615	'values',
616	'write',
617	'writelines',
618	'xreadlines',
619	)
620
621	# Since getAllAttributeNames() calls str(object),
622	# we need to test for a broken __str__ method.
623	class BrokenStr:
624	def __str__(self):
625	raise Exception
626
627	brokenStr = BrokenStr()
628
629	class GetAttributeNamesTestCase(GetAttributeTestCase):
630
631	def setUp(self):
632	GetAttributeTestCase.setUp(self)
65136283	633	from wx import py
1fded56b RD	634	spam = Spam()
	635	self.f = open('test_introspect.py')
	636	self.items = (
	637	None,
	638	int(123),
	639	long(123),
	640	float(123),
	641	complex(123),
	642	"",
	643	unicode(""),
	644	[],
	645	(),
	646	xrange(0),
	647	{},
	648	# Builtin function.
	649	len,
	650	# Builtin method.
	651	[].append,
	652	# User function.
	653	ham,
	654	# Byte-compiled code.
	655	ham.func_code,
	656	# Lambda.
	657	lambda: None,
	658	# Class with no init.
	659	Bar,
	660	# Instance with no init.
	661	Bar(),
	662	# Class with init and del.
	663	Foo,
	664	# Instance with init and del.
	665	Foo(),
	666	# Bound method.
	667	spam.foo,
	668	# Unbound method.
	669	Spam.eggs,
	670	# Callable instance.
	671	spam,
	672	# Module.
	673	introspect,
	674	# Package.
65136283	675	py,
1fded56b RD	676	# Buffer.
	677	buffer(''),
	678	# File.
	679	self.f,
	680	# Slice.
	681	slice(0),
	682	# Ellipsis.
	683	Ellipsis,
	684	# BrokenStr class.
	685	BrokenStr,
	686	# BrokenStr instance.
	687	brokenStr,
	688	)
	689
	690	def tearDown(self):
	691	self.items = None
	692	self.f.close()
	693
	694	def test_getAttributeNames(self):
	695	for item in self.items:
	696	self._checkAttributeNames(item)
	697	if __builtins__.has_key('object'):
	698	self._checkAttributeNames(object)
	699
	700	def test_getAttributeNames_NoSingle(self):
	701	for item in self.items:
	702	result = introspect.getAttributeNames(item, includeSingle=0)
	703	attributes = [attribute for attribute in result \
	704	if attribute[0] != '_' or attribute[:2] == '__']
	705	self.assertEqual(result, attributes,
	706	':item: %r' % (item,))
	707
	708	def test_getAttributeNames_NoDouble(self):
	709	for item in self.items:
	710	result = introspect.getAttributeNames(item, includeDouble=0)
	711	attributes = [attribute for attribute in result \
	712	if attribute[:2] != '__']
	713	self.assertEqual(result, attributes,
	714	':item: %r' % (item,))
	715
	716	def test_getAttributeNames_NoSingleOrDouble(self):
	717	for item in self.items:
	718	result = introspect.getAttributeNames(item, includeSingle=0,
	719	includeDouble=0)
	720	attributes = [attribute for attribute in result \
	721	if attribute[0] != '_']
	722	self.assertEqual(result, attributes,
	723	':item: %r' % (item,))
	724
	725	def _checkAttributeNames(self, item):
	726	result = introspect.getAttributeNames(item)
	727	attributes = [attribute for attribute in self.values \
	728	if hasattr(item, attribute)]
	729	for attribute in attributes:
	730	self.assert_(attribute in result,
	731	':item: %r :attribute: %r' % (item, attribute))
	732
	733
	734	class GetAutoCompleteListTestCase(GetAttributeTestCase):
	735
	736	def setUp(self):
	737	GetAttributeTestCase.setUp(self)
	738	self.items = (
	739	'None.',
740	'123 .',
741	'"".',
742	'[].',
743	'().',
744	'{}.',
745	# Builtin function.
746	'len.',
747	# Builtin method.
748	'[].append.',
749	)
750
751	def test_getAutoCompleteList(self):
752	for item in self.items:
753	result = introspect.getAutoCompleteList(item)
754	object = eval(item[:-1])
755	attributes = [attribute for attribute in self.values \
756	if hasattr(object, attribute)]
757	for attribute in attributes:
758	self.assert_(attribute in result,
759	':item: %r :attribute: %r' % (item, attribute))
760
761	def test_getAutoCompleteList_NoSingle(self):
762	for item in self.items:
763	result = introspect.getAutoCompleteList(item, includeSingle=0)
764	attributes = [attribute for attribute in result \
765	if attribute[0] != '_' or attribute[:2] == '__']
766	self.assertEqual(result, attributes,
767	':item: %r' % (item,))
768
769	def test_getAutoCompleteList_NoDouble(self):
770	for item in self.items:
771	result = introspect.getAutoCompleteList(item, includeDouble=0)
772	attributes = [attribute for attribute in result \
773	if attribute[:2] != '__']
774	self.assertEqual(result, attributes,
775	':item: %r' % (item,))
776
777	def test_getAutoCompleteList_NoSingleOrDouble(self):
778	for item in self.items:
779	result = introspect.getAutoCompleteList(item, includeSingle=0,
780	includeDouble=0)
781	attributes = [attribute for attribute in result \
782	if attribute[0] != '_']
783	self.assertEqual(result, attributes,
784	':item: %r' % (item,))
785
786
787	# Support for GetConstructorTestCase.
788
789	class A1:
790	def __init__(self, a):
791	self.a = a
792
793	class B1(A1):
794	def __init__(self, b):
795	self.b = b
796
797	class C1(A1):
798	pass
799
800	class D1(C1, B1):
801	pass
802
803	if __builtins__.has_key('object'):
804	class A2(object):
805	def __init__(self, a):
806	self.a = a
807
808	class B2(A2):
809	def __init__(self, b):
810	self.b = b
811
812	class C2(A2):
813	pass
814
815	class D2(C2, B2):
816	pass
817
818	class N:
819	pass
820
821	class O:
822	def __init__(self, a, b=2, args, *kwargs):
823	pass
824
825	class P(O):
826	pass
827
828	class Q(P):
829	def __init__(self, c, d=4):
830	pass
831
832	class GetConstructorTestCase(unittest.TestCase):
833
834	def test_getConstructor(self):
835	args = ('self', 'a', 'b', 'args', 'kwargs')
836	varnames = introspect.getConstructor(O).func_code.co_varnames
837	self.assertEqual(varnames, args)
838	varnames = introspect.getConstructor(P).func_code.co_varnames
839	self.assertEqual(varnames, args)
840	args = ('self', 'c', 'd')
841	varnames = introspect.getConstructor(Q).func_code.co_varnames
842	self.assertEqual(varnames, args)
843
844	def test_getConstructor_None(self):
845	values = (N, 1, 'spam', {}, [], (), dir)
846	for value in values:
847	self.assertEqual(introspect.getConstructor(N), None)
848
849	def test_getConstructor_MultipleInheritance(self):
850	# Test old style inheritance rules.
851	args = ('self', 'a')
852	varnames = introspect.getConstructor(D1).func_code.co_varnames
853	self.assertEqual(varnames, args)
854	if __builtins__.has_key('object'):
855	# Test new style inheritance rules as well.
856	args = ('self', 'b')
857	varnames = introspect.getConstructor(D2).func_code.co_varnames
858	self.assertEqual(varnames, args)
859
860
861	if __name__ == '__main__':
862	unittest.main()