home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 January / maximum-cd-2011-01.iso / DiscContents / calibre-0.7.26.msi / file_2912 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-10-31  |  11.1 KB  |  331 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import os
  6. import win32api
  7. import tempfile
  8. import unittest
  9. import gc
  10. import pythoncom
  11. import winerror
  12. import cStringIO as StringIO
  13. from pythoncom import _GetInterfaceCount, _GetGatewayCount
  14. import win32com
  15. import logging
  16.  
  17. def CheckClean():
  18.     sys.exc_clear()
  19.     c = _GetInterfaceCount()
  20.     if c:
  21.         print 'Warning - %d com interface objects still alive' % c
  22.     
  23.     c = _GetGatewayCount()
  24.     if c:
  25.         print 'Warning - %d com gateway objects still alive' % c
  26.     
  27.  
  28.  
  29. def RegisterPythonServer(filename, verbose = 0):
  30.     cmd = '%s "%s" > nul 2>&1' % (win32api.GetModuleFileName(0), filename)
  31.     if verbose:
  32.         print 'Registering engine', filename
  33.     
  34.     rc = os.system(cmd)
  35.     if rc:
  36.         print 'Registration command was:'
  37.         print cmd
  38.         raise RuntimeError, "Registration of engine '%s' failed" % filename
  39.     rc
  40.  
  41.  
  42. def ExecuteShellCommand(cmd, testcase, expected_output = None, tracebacks_ok = 0):
  43.     output_name = tempfile.mktemp('win32com_test')
  44.     cmd = cmd + ' > "%s" 2>&1' % output_name
  45.     rc = os.system(cmd)
  46.     output = open(output_name, 'r').read().strip()
  47.     
  48.     class Failed(Exception):
  49.         pass
  50.  
  51.     
  52.     try:
  53.         if rc:
  54.             raise Failed, 'exit code was ' + str(rc)
  55.         rc
  56.         if expected_output is not None and output != expected_output:
  57.             raise Failed, 'Expected output %r (got %r)' % (expected_output, output)
  58.         output != expected_output
  59.         if not tracebacks_ok and output.find('Traceback (most recent call last)') >= 0:
  60.             raise Failed, 'traceback in program output'
  61.         output.find('Traceback (most recent call last)') >= 0
  62.         return output
  63.     except Failed:
  64.         why = None
  65.         print "Failed to exec command '%r'" % cmd
  66.         print 'Failed as', why
  67.         print '** start of program output **'
  68.         print output
  69.         print '** end of program output **'
  70.         testcase.fail("Executing '%s' failed as %s" % (cmd, why))
  71.  
  72.  
  73.  
  74. def assertRaisesCOM_HRESULT(testcase, hresult, func, *args, **kw):
  75.     
  76.     try:
  77.         func(*args, **kw)
  78.     except pythoncom.com_error:
  79.         details = None
  80.         if details[0] == hresult:
  81.             return None
  82.     except:
  83.         details[0] == hresult
  84.  
  85.     testcase.fail('Excepected COM exception with HRESULT 0x%x' % hresult)
  86.  
  87.  
  88. class CaptureWriter:
  89.     
  90.     def __init__(self):
  91.         self.old_err = None
  92.         self.old_out = None
  93.         self.clear()
  94.  
  95.     
  96.     def capture(self):
  97.         self.clear()
  98.         self.old_out = sys.stdout
  99.         self.old_err = sys.stderr
  100.         sys.stdout = sys.stderr = self
  101.  
  102.     
  103.     def release(self):
  104.         if self.old_out:
  105.             sys.stdout = self.old_out
  106.             self.old_out = None
  107.         
  108.         if self.old_err:
  109.             sys.stderr = self.old_err
  110.             self.old_err = None
  111.         
  112.  
  113.     
  114.     def clear(self):
  115.         self.captured = []
  116.  
  117.     
  118.     def write(self, msg):
  119.         self.captured.append(msg)
  120.  
  121.     
  122.     def get_captured(self):
  123.         return ''.join(self.captured)
  124.  
  125.     
  126.     def get_num_lines_captured(self):
  127.         return len(''.join(self.captured).split('\n'))
  128.  
  129.  
  130.  
  131. class LeakTestCase(unittest.TestCase):
  132.     
  133.     def __init__(self, real_test):
  134.         unittest.TestCase.__init__(self)
  135.         self.real_test = real_test
  136.         self.num_test_cases = 1
  137.         self.num_leak_iters = 2
  138.         if hasattr(sys, 'gettotalrefcount'):
  139.             self.num_test_cases = self.num_test_cases + self.num_leak_iters
  140.         
  141.  
  142.     
  143.     def countTestCases(self):
  144.         return self.num_test_cases
  145.  
  146.     
  147.     def runTest(self):
  148.         pass
  149.  
  150.     
  151.     def __call__(self, result = None):
  152.         gc.collect()
  153.         ni = _GetInterfaceCount()
  154.         ng = _GetGatewayCount()
  155.         self.real_test(result)
  156.         if result.shouldStop or not result.wasSuccessful():
  157.             return None
  158.         self._do_leak_tests(result)
  159.         gc.collect()
  160.         lost_i = _GetInterfaceCount() - ni
  161.         lost_g = _GetGatewayCount() - ng
  162.         if lost_i or lost_g:
  163.             msg = '%d interface objects and %d gateway objects leaked' % (lost_i, lost_g)
  164.             result.addFailure(self.real_test, (AssertionError, msg, None))
  165.         
  166.  
  167.     
  168.     def _do_leak_tests(self, result = None):
  169.         
  170.         try:
  171.             gtrc = sys.gettotalrefcount
  172.         except AttributeError:
  173.             return None
  174.             
  175.             def gtrc():
  176.                 return 0
  177.  
  178.  
  179.         trc = gtrc()
  180.         for i in range(self.num_leak_iters):
  181.             self.real_test(result)
  182.             if result.shouldStop:
  183.                 break
  184.                 continue
  185.         
  186.         del i
  187.         lost = (gtrc() - trc) // self.num_leak_iters
  188.         if lost < 0:
  189.             msg = 'LeakTest: %s appeared to gain %d references!!' % (self.real_test, -lost)
  190.             result.addFailure(self.real_test, (AssertionError, msg, None))
  191.         
  192.         if lost > 0:
  193.             msg = 'LeakTest: %s lost %d references' % (self.real_test, lost)
  194.             result.addFailure(self.real_test, (AssertionError, msg, None))
  195.         
  196.  
  197.  
  198.  
  199. class TestLoader(unittest.TestLoader):
  200.     
  201.     def loadTestsFromTestCase(self, testCaseClass):
  202.         leak_tests = []
  203.         for name in self.getTestCaseNames(testCaseClass):
  204.             real_test = testCaseClass(name)
  205.             leak_test = self._getTestWrapper(real_test)
  206.             leak_tests.append(leak_test)
  207.         
  208.         return self.suiteClass(leak_tests)
  209.  
  210.     
  211.     def _getTestWrapper(self, test):
  212.         no_leak_tests = getattr(test, 'no_leak_tests', False)
  213.         if no_leak_tests:
  214.             print "Test says it doesn't want leak tests!"
  215.             return test
  216.         return LeakTestCase(test)
  217.  
  218.     
  219.     def loadTestsFromModule(self, mod):
  220.         if hasattr(mod, 'suite'):
  221.             return mod.suite()
  222.         return unittest.TestLoader.loadTestsFromModule(self, mod)
  223.  
  224.     
  225.     def loadTestsFromName(self, name, module = None):
  226.         test = unittest.TestLoader.loadTestsFromName(self, name, module)
  227.         if isinstance(test, unittest.TestSuite):
  228.             pass
  229.         elif isinstance(test, unittest.TestCase):
  230.             test = self._getTestWrapper(test)
  231.         else:
  232.             print 'XXX - what is', test
  233.         return test
  234.  
  235.  
  236.  
  237. class LogHandler(logging.Handler):
  238.     
  239.     def __init__(self):
  240.         self.emitted = []
  241.         logging.Handler.__init__(self)
  242.  
  243.     
  244.     def emit(self, record):
  245.         self.emitted.append(record)
  246.  
  247.  
  248.  
  249. def setup_test_logger():
  250.     old_log = getattr(win32com, 'logger', None)
  251.     win32com.logger = logging.Logger('test')
  252.     handler = LogHandler()
  253.     win32com.logger.addHandler(handler)
  254.     return (handler.emitted, old_log)
  255.  
  256.  
  257. def restore_test_logger(prev_logger):
  258.     if prev_logger is None:
  259.         del win32com.logger
  260.     else:
  261.         win32com.logger = prev_logger
  262.  
  263. TestCase = unittest.TestCase
  264.  
  265. def CapturingFunctionTestCase(*args, **kw):
  266.     real_test = _CapturingFunctionTestCase(*args, **kw)
  267.     return LeakTestCase(real_test)
  268.  
  269.  
  270. class _CapturingFunctionTestCase(unittest.FunctionTestCase):
  271.     
  272.     def __call__(self, result = None):
  273.         if result is None:
  274.             result = self.defaultTestResult()
  275.         
  276.         writer = CaptureWriter()
  277.         writer.capture()
  278.         
  279.         try:
  280.             unittest.FunctionTestCase.__call__(self, result)
  281.             if getattr(self, 'do_leak_tests', 0) and hasattr(sys, 'gettotalrefcount'):
  282.                 self.run_leak_tests(result)
  283.         finally:
  284.             writer.release()
  285.  
  286.         output = writer.get_captured()
  287.         self.checkOutput(output, result)
  288.         if result.showAll:
  289.             print output
  290.         
  291.  
  292.     
  293.     def checkOutput(self, output, result):
  294.         if output.find('Traceback') >= 0:
  295.             msg = 'Test output contained a traceback\n---\n%s\n---' % output
  296.             result.errors.append((self, msg))
  297.         
  298.  
  299.  
  300.  
  301. class ShellTestCase(unittest.TestCase):
  302.     
  303.     def __init__(self, cmd, expected_output):
  304.         self._ShellTestCase__cmd = cmd
  305.         self._ShellTestCase__eo = expected_output
  306.         unittest.TestCase.__init__(self)
  307.  
  308.     
  309.     def runTest(self):
  310.         ExecuteShellCommand(self._ShellTestCase__cmd, self, self._ShellTestCase__eo)
  311.  
  312.     
  313.     def __str__(self):
  314.         max = 30
  315.         if len(self._ShellTestCase__cmd) > max:
  316.             cmd_repr = self._ShellTestCase__cmd[:max] + '...'
  317.         else:
  318.             cmd_repr = self._ShellTestCase__cmd
  319.         return 'exec: ' + cmd_repr
  320.  
  321.  
  322.  
  323. def testmain(*args, **kw):
  324.     new_kw = kw.copy()
  325.     if not new_kw.has_key('testLoader'):
  326.         new_kw['testLoader'] = TestLoader()
  327.     
  328.     unittest.main(*args, **new_kw)
  329.     CheckClean()
  330.  
  331.