home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 14 / hacker14.iso / programacao / pythonwin / python.exe / TEST_PYCLBR.PY < prev    next >
Encoding:
Python Source  |  2003-05-02  |  6.0 KB  |  163 lines
  1. '''
  2.    Test cases for pyclbr.py
  3.    Nick Mathewson
  4. '''
  5. from test.test_support import run_unittest
  6. import unittest, sys
  7. from types import ClassType, FunctionType, MethodType
  8. import pyclbr
  9. from unittest import TestCase
  10. from sets import Set
  11.  
  12. # This next line triggers an error on old versions of pyclbr.
  13.  
  14. from commands import getstatus
  15.  
  16. # Here we test the python class browser code.
  17. #
  18. # The main function in this suite, 'testModule', compares the output
  19. # of pyclbr with the introspected members of a module.  Because pyclbr
  20. # is imperfect (as designed), testModule is called with a set of
  21. # members to ignore.
  22.  
  23. class PyclbrTest(TestCase):
  24.  
  25.     def assertListEq(self, l1, l2, ignore):
  26.         ''' succeed iff {l1} - {ignore} == {l2} - {ignore} '''
  27.         missing = (Set(l1) ^ Set(l2)) - Set(ignore)
  28.         if missing:
  29.             print >>sys.stderr, "l1=%r\nl2=%r\nignore=%r" % (l1, l2, ignore)
  30.             self.fail("%r missing" % missing.pop())
  31.  
  32.     def assertHasattr(self, obj, attr, ignore):
  33.         ''' succeed iff hasattr(obj,attr) or attr in ignore. '''
  34.         if attr in ignore: return
  35.         if not hasattr(obj, attr): print "???", attr
  36.         self.failUnless(hasattr(obj, attr),
  37.                         'expected hasattr(%r, %r)' % (obj, attr))
  38.  
  39.  
  40.     def assertHaskey(self, obj, key, ignore):
  41.         ''' succeed iff obj.has_key(key) or key in ignore. '''
  42.         if key in ignore: return
  43.         if not obj.has_key(key):
  44.             print >>sys.stderr, "***",key
  45.         self.failUnless(obj.has_key(key))
  46.  
  47.     def assertEquals(self, a, b, ignore=None):
  48.         ''' succeed iff a == b or a in ignore or b in ignore '''
  49.         if (ignore == None) or (a in ignore) or (b in ignore): return
  50.  
  51.         unittest.TestCase.assertEquals(self, a, b)
  52.  
  53.     def checkModule(self, moduleName, module=None, ignore=()):
  54.         ''' succeed iff pyclbr.readmodule_ex(modulename) corresponds
  55.             to the actual module object, module.  Any identifiers in
  56.             ignore are ignored.   If no module is provided, the appropriate
  57.             module is loaded with __import__.'''
  58.  
  59.         if module == None:
  60.             # Import it.
  61.             # ('<silly>' is to work around an API silliness in __import__)
  62.             module = __import__(moduleName, globals(), {}, ['<silly>'])
  63.  
  64.         dict = pyclbr.readmodule_ex(moduleName)
  65.  
  66.         def ismethod(obj, name):
  67.             if not  isinstance(obj, MethodType):
  68.                 return False
  69.             if obj.im_self is not None:
  70.                 return False
  71.             objname = obj.__name__
  72.             if objname.startswith("__") and not objname.endswith("__"):
  73.                 objname = "_%s%s" % (obj.im_class.__name__, objname)
  74.             return objname == name
  75.  
  76.         # Make sure the toplevel functions and classes are the same.
  77.         for name, value in dict.items():
  78.             if name in ignore:
  79.                 continue
  80.             self.assertHasattr(module, name, ignore)
  81.             py_item = getattr(module, name)
  82.             if isinstance(value, pyclbr.Function):
  83.                 self.assertEquals(type(py_item), FunctionType)
  84.             else:
  85.                 self.assertEquals(type(py_item), ClassType)
  86.                 real_bases = [base.__name__ for base in py_item.__bases__]
  87.                 pyclbr_bases = [ getattr(base, 'name', base)
  88.                                  for base in value.super ]
  89.  
  90.                 try:
  91.                     self.assertListEq(real_bases, pyclbr_bases, ignore)
  92.                 except:
  93.                     print >>sys.stderr, "class=%s" % py_item
  94.                     raise
  95.  
  96.                 actualMethods = []
  97.                 for m in py_item.__dict__.keys():
  98.                     if ismethod(getattr(py_item, m), m):
  99.                         actualMethods.append(m)
  100.                 foundMethods = []
  101.                 for m in value.methods.keys():
  102.                     if m[:2] == '__' and m[-2:] != '__':
  103.                         foundMethods.append('_'+name+m)
  104.                     else:
  105.                         foundMethods.append(m)
  106.  
  107.                 try:
  108.                     self.assertListEq(foundMethods, actualMethods, ignore)
  109.                     self.assertEquals(py_item.__module__, value.module)
  110.  
  111.                     self.assertEquals(py_item.__name__, value.name, ignore)
  112.                     # can't check file or lineno
  113.                 except:
  114.                     print >>sys.stderr, "class=%s" % py_item
  115.                     raise
  116.  
  117.         # Now check for missing stuff.
  118.         def defined_in(item, module):
  119.             if isinstance(item, ClassType):
  120.                 return item.__module__ == module.__name__
  121.             if isinstance(item, FunctionType):
  122.                 return item.func_globals is module.__dict__
  123.             return False
  124.         for name in dir(module):
  125.             item = getattr(module, name)
  126.             if isinstance(item,  (ClassType, FunctionType)):
  127.                 if defined_in(item, module):
  128.                     self.assertHaskey(dict, name, ignore)
  129.  
  130.     def test_easy(self):
  131.         self.checkModule('pyclbr')
  132.         self.checkModule('doctest')
  133.         self.checkModule('rfc822')
  134.         self.checkModule('difflib')
  135.  
  136.     def test_others(self):
  137.         cm = self.checkModule
  138.  
  139.         # These were once about the 10 longest modules
  140.         cm('random', ignore=('Random',))  # from _random import Random as CoreGenerator
  141.         cm('cgi', ignore=('log',))      # set with = in module
  142.         cm('mhlib')
  143.         cm('urllib', ignore=('getproxies_registry',
  144.                              'open_https')) # not on all platforms
  145.         cm('pickle', ignore=('g',))     # from types import *
  146.         cm('aifc', ignore=('openfp',))  # set with = in module
  147.         cm('Cookie')
  148.         cm('sre_parse', ignore=('dump',)) # from sre_constants import *
  149.         cm('pdb')
  150.         cm('pydoc')
  151.  
  152.         # Tests for modules inside packages
  153.         cm('email.Parser')
  154.         cm('test.test_pyclbr')
  155.  
  156.  
  157. def test_main():
  158.     run_unittest(PyclbrTest)
  159.  
  160.  
  161. if __name__ == "__main__":
  162.     test_main()
  163.