home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 June / maximum-cd-2009-06.iso / DiscContents / digsby_setup.exe / lib / test / test_support.pyo (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2009-02-26  |  13.7 KB  |  505 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. if __name__ != 'test.test_support':
  5.     raise ImportError, 'test_support must be imported from the test package'
  6.  
  7. import sys
  8.  
  9. class Error(Exception):
  10.     pass
  11.  
  12.  
  13. class TestFailed(Error):
  14.     pass
  15.  
  16.  
  17. class TestSkipped(Error):
  18.     pass
  19.  
  20.  
  21. class ResourceDenied(TestSkipped):
  22.     pass
  23.  
  24. verbose = 1
  25. use_resources = None
  26. max_memuse = 0
  27. real_max_memuse = 0
  28. _original_stdout = None
  29.  
  30. def record_original_stdout(stdout):
  31.     global _original_stdout
  32.     _original_stdout = stdout
  33.  
  34.  
  35. def get_original_stdout():
  36.     if not _original_stdout:
  37.         pass
  38.     return sys.stdout
  39.  
  40.  
  41. def unload(name):
  42.     
  43.     try:
  44.         del sys.modules[name]
  45.     except KeyError:
  46.         pass
  47.  
  48.  
  49.  
  50. def unlink(filename):
  51.     import os
  52.     
  53.     try:
  54.         os.unlink(filename)
  55.     except OSError:
  56.         pass
  57.  
  58.  
  59.  
  60. def forget(modname):
  61.     unload(modname)
  62.     import os
  63.     for dirname in sys.path:
  64.         unlink(os.path.join(dirname, modname + os.extsep + 'pyc'))
  65.         unlink(os.path.join(dirname, modname + os.extsep + 'pyo'))
  66.     
  67.  
  68.  
  69. def is_resource_enabled(resource):
  70.     if use_resources is not None:
  71.         pass
  72.     return resource in use_resources
  73.  
  74.  
  75. def requires(resource, msg = None):
  76.     if sys._getframe().f_back.f_globals.get('__name__') == '__main__':
  77.         return None
  78.     
  79.     if not is_resource_enabled(resource):
  80.         if msg is None:
  81.             msg = "Use of the `%s' resource not enabled" % resource
  82.         
  83.         raise ResourceDenied(msg)
  84.     
  85.  
  86.  
  87. def bind_port(sock, host = '', preferred_port = 54321):
  88.     import socket
  89.     import errno
  90.     for port in [
  91.         preferred_port,
  92.         9907,
  93.         10243,
  94.         32999,
  95.         0]:
  96.         
  97.         try:
  98.             sock.bind((host, port))
  99.             if port == 0:
  100.                 port = sock.getsockname()[1]
  101.             
  102.             return port
  103.         continue
  104.         except socket.error:
  105.             (err, msg) = None
  106.             if err != errno.EADDRINUSE:
  107.                 raise 
  108.             
  109.             print >>sys.__stderr__, '  WARNING: failed to listen on port %d, trying another' % port
  110.             continue
  111.         
  112.  
  113.     
  114.     raise TestFailed, 'unable to find port to listen on'
  115.  
  116. FUZZ = 1e-06
  117.  
  118. def fcmp(x, y):
  119.     if type(x) == type(0) or type(y) == type(0):
  120.         
  121.         try:
  122.             (x, y) = coerce(x, y)
  123.             fuzz = (abs(x) + abs(y)) * FUZZ
  124.             if abs(x - y) <= fuzz:
  125.                 return 0
  126.  
  127.     elif type(x) == type(y) and type(x) in (type(()), type([])):
  128.         for i in range(min(len(x), len(y))):
  129.             outcome = fcmp(x[i], y[i])
  130.             if outcome != 0:
  131.                 return outcome
  132.                 continue
  133.         
  134.         return cmp(len(x), len(y))
  135.     
  136.     return cmp(x, y)
  137.  
  138.  
  139. try:
  140.     unicode
  141.     have_unicode = 1
  142. except NameError:
  143.     have_unicode = 0
  144.  
  145. is_jython = sys.platform.startswith('java')
  146. import os
  147. if os.name == 'java':
  148.     TESTFN = '$test'
  149. elif os.name == 'riscos':
  150.     TESTFN = 'testfile'
  151. else:
  152.     TESTFN = '@test'
  153.     if have_unicode:
  154.         if isinstance('', unicode):
  155.             TESTFN_UNICODE = '@test-\xe0\xf2'
  156.         else:
  157.             TESTFN_UNICODE = unicode('@test-\xe0\xf2', 'latin-1')
  158.         TESTFN_ENCODING = sys.getfilesystemencoding()
  159.         if not hasattr(sys, 'getwindowsversion') or sys.getwindowsversion()[3] < 2:
  160.             TESTFN_UNICODE_UNENCODEABLE = None
  161.         else:
  162.             TESTFN_UNICODE_UNENCODEABLE = eval('u"@test-\\u5171\\u6709\\u3055\\u308c\\u308b"')
  163.             
  164.             try:
  165.                 TESTFN_UNICODE_UNENCODEABLE.encode('Latin1')
  166.             except UnicodeEncodeError:
  167.                 pass
  168.  
  169.             print 'WARNING: The filename %r CAN be encoded by the filesystem.  Unicode filename tests may not be effective' % TESTFN_UNICODE_UNENCODEABLE
  170.     
  171. fp = None
  172.  
  173. try:
  174.     fp = open(TESTFN, 'w+')
  175. except IOError:
  176.     TMP_TESTFN = os.path.join('/tmp', TESTFN)
  177.     
  178.     try:
  179.         fp = open(TMP_TESTFN, 'w+')
  180.         TESTFN = TMP_TESTFN
  181.         del TMP_TESTFN
  182.     except IOError:
  183.         print 'WARNING: tests will fail, unable to write to: %s or %s' % (TESTFN, TMP_TESTFN)
  184.     except:
  185.         None<EXCEPTION MATCH>IOError
  186.     
  187.  
  188.     None<EXCEPTION MATCH>IOError
  189.  
  190. if fp is not None:
  191.     fp.close()
  192.     unlink(TESTFN)
  193.  
  194. del os
  195. del fp
  196.  
  197. def findfile(file, here = __file__):
  198.     import os
  199.     if os.path.isabs(file):
  200.         return file
  201.     
  202.     path = sys.path
  203.     path = [
  204.         os.path.dirname(here)] + path
  205.     for dn in path:
  206.         fn = os.path.join(dn, file)
  207.         if os.path.exists(fn):
  208.             return fn
  209.             continue
  210.     
  211.     return file
  212.  
  213.  
  214. def verify(condition, reason = 'test failed'):
  215.     if not condition:
  216.         raise TestFailed(reason)
  217.     
  218.  
  219.  
  220. def vereq(a, b):
  221.     if not a == b:
  222.         raise TestFailed, '%r == %r' % (a, b)
  223.     
  224.  
  225.  
  226. def sortdict(dict):
  227.     items = dict.items()
  228.     items.sort()
  229.     reprpairs = [ '%r: %r' % pair for pair in items ]
  230.     withcommas = ', '.join(reprpairs)
  231.     return '{%s}' % withcommas
  232.  
  233.  
  234. def check_syntax(statement):
  235.     
  236.     try:
  237.         compile(statement, '<string>', 'exec')
  238.     except SyntaxError:
  239.         pass
  240.  
  241.     print 'Missing SyntaxError: "%s"' % statement
  242.  
  243.  
  244. def open_urlresource(url):
  245.     import urllib
  246.     import urlparse
  247.     import os.path as os
  248.     filename = urlparse.urlparse(url)[2].split('/')[-1]
  249.     for path in [
  250.         os.path.curdir,
  251.         os.path.pardir]:
  252.         fn = os.path.join(path, filename)
  253.         if os.path.exists(fn):
  254.             return open(fn)
  255.             continue
  256.     
  257.     requires('urlfetch')
  258.     print >>get_original_stdout(), '\tfetching %s ...' % url
  259.     (fn, _) = urllib.urlretrieve(url, filename)
  260.     return open(fn)
  261.  
  262.  
  263. def run_with_locale(catstr, *locales):
  264.     
  265.     def decorator(func):
  266.         
  267.         def inner(*args, **kwds):
  268.             
  269.             try:
  270.                 import locale
  271.                 category = getattr(locale, catstr)
  272.                 orig_locale = locale.setlocale(category)
  273.             except AttributeError:
  274.                 raise 
  275.             except:
  276.                 locale = None
  277.                 orig_locale = None
  278.  
  279.             for loc in locales:
  280.                 
  281.                 try:
  282.                     locale.setlocale(category, loc)
  283.                 continue
  284.                 continue
  285.  
  286.             
  287.             
  288.             try:
  289.                 return func(*args, **kwds)
  290.             finally:
  291.                 if locale and orig_locale:
  292.                     locale.setlocale(category, orig_locale)
  293.                 
  294.  
  295.  
  296.         inner.func_name = func.func_name
  297.         inner.__doc__ = func.__doc__
  298.         return inner
  299.  
  300.     return decorator
  301.  
  302. _1M = 1048576
  303. _1G = 1024 * _1M
  304. _2G = 2 * _1G
  305. _4G = 4 * _1G
  306.  
  307. class _Dummy:
  308.     
  309.     def __getslice__(self, i, j):
  310.         return j
  311.  
  312.  
  313. MAX_Py_ssize_t = _Dummy()[:]
  314.  
  315. def set_memlimit(limit):
  316.     global real_max_memuse, max_memuse
  317.     import re
  318.     sizes = {
  319.         'k': 1024,
  320.         'm': _1M,
  321.         'g': _1G,
  322.         't': 1024 * _1G }
  323.     m = re.match('(\\d+(\\.\\d+)?) (K|M|G|T)b?$', limit, re.IGNORECASE | re.VERBOSE)
  324.     if m is None:
  325.         raise ValueError('Invalid memory limit %r' % (limit,))
  326.     
  327.     memlimit = int(float(m.group(1)) * sizes[m.group(3).lower()])
  328.     real_max_memuse = memlimit
  329.     if memlimit > MAX_Py_ssize_t:
  330.         memlimit = MAX_Py_ssize_t
  331.     
  332.     if memlimit < _2G - 1:
  333.         raise ValueError('Memory limit %r too low to be useful' % (limit,))
  334.     
  335.     max_memuse = memlimit
  336.  
  337.  
  338. def bigmemtest(minsize, memuse, overhead = 5 * _1M):
  339.     
  340.     def decorator(f):
  341.         
  342.         def wrapper(self):
  343.             if not max_memuse:
  344.                 maxsize = 5147
  345.                 self.failIf(maxsize * memuse + overhead > 20 * _1M)
  346.             else:
  347.                 maxsize = int((max_memuse - overhead) / memuse)
  348.                 if maxsize < minsize:
  349.                     if verbose:
  350.                         sys.stderr.write('Skipping %s because of memory constraint\n' % (f.__name__,))
  351.                     
  352.                     return None
  353.                 
  354.                 maxsize = max(maxsize - 50 * _1M, minsize)
  355.             return f(self, maxsize)
  356.  
  357.         wrapper.minsize = minsize
  358.         wrapper.memuse = memuse
  359.         wrapper.overhead = overhead
  360.         return wrapper
  361.  
  362.     return decorator
  363.  
  364.  
  365. def precisionbigmemtest(size, memuse, overhead = 5 * _1M):
  366.     
  367.     def decorator(f):
  368.         
  369.         def wrapper(self):
  370.             if not real_max_memuse:
  371.                 maxsize = 5147
  372.             else:
  373.                 maxsize = size
  374.                 if real_max_memuse and real_max_memuse < maxsize * memuse:
  375.                     if verbose:
  376.                         sys.stderr.write('Skipping %s because of memory constraint\n' % (f.__name__,))
  377.                     
  378.                     return None
  379.                 
  380.             return f(self, maxsize)
  381.  
  382.         wrapper.size = size
  383.         wrapper.memuse = memuse
  384.         wrapper.overhead = overhead
  385.         return wrapper
  386.  
  387.     return decorator
  388.  
  389.  
  390. def bigaddrspacetest(f):
  391.     
  392.     def wrapper(self):
  393.         if max_memuse < MAX_Py_ssize_t:
  394.             if verbose:
  395.                 sys.stderr.write('Skipping %s because of memory constraint\n' % (f.__name__,))
  396.             
  397.         else:
  398.             return f(self)
  399.  
  400.     return wrapper
  401.  
  402. import unittest
  403.  
  404. class BasicTestRunner:
  405.     
  406.     def run(self, test):
  407.         result = unittest.TestResult()
  408.         test(result)
  409.         return result
  410.  
  411.  
  412.  
  413. def run_suite(suite, testclass = None):
  414.     if verbose:
  415.         runner = unittest.TextTestRunner(sys.stdout, verbosity = 2)
  416.     else:
  417.         runner = BasicTestRunner()
  418.     result = runner.run(suite)
  419.     if not result.wasSuccessful():
  420.         if len(result.errors) == 1 and not (result.failures):
  421.             err = result.errors[0][1]
  422.         elif len(result.failures) == 1 and not (result.errors):
  423.             err = result.failures[0][1]
  424.         elif testclass is None:
  425.             msg = 'errors occurred; run in verbose mode for details'
  426.         else:
  427.             msg = 'errors occurred in %s.%s' % (testclass.__module__, testclass.__name__)
  428.         raise TestFailed(msg)
  429.         raise TestFailed(err)
  430.     
  431.  
  432.  
  433. def run_unittest(*classes):
  434.     suite = unittest.TestSuite()
  435.     for cls in classes:
  436.         if isinstance(cls, (unittest.TestSuite, unittest.TestCase)):
  437.             suite.addTest(cls)
  438.             continue
  439.         suite.addTest(unittest.makeSuite(cls))
  440.     
  441.     if len(classes) == 1:
  442.         testclass = classes[0]
  443.     else:
  444.         testclass = None
  445.     run_suite(suite, testclass)
  446.  
  447.  
  448. def run_doctest(module, verbosity = None):
  449.     import doctest
  450.     if verbosity is None:
  451.         verbosity = verbose
  452.     else:
  453.         verbosity = None
  454.     save_stdout = sys.stdout
  455.     sys.stdout = get_original_stdout()
  456.     
  457.     try:
  458.         (f, t) = doctest.testmod(module, verbose = verbosity)
  459.         if f:
  460.             raise TestFailed('%d of %d doctests failed' % (f, t))
  461.     finally:
  462.         sys.stdout = save_stdout
  463.  
  464.     if verbose:
  465.         print 'doctest (%s) ... %d tests with zero failures' % (module.__name__, t)
  466.     
  467.     return (f, t)
  468.  
  469.  
  470. def threading_setup():
  471.     import threading
  472.     return (len(threading._active), len(threading._limbo))
  473.  
  474.  
  475. def threading_cleanup(num_active, num_limbo):
  476.     import threading
  477.     import time
  478.     _MAX_COUNT = 10
  479.     count = 0
  480.     while len(threading._active) != num_active and count < _MAX_COUNT:
  481.         count += 1
  482.         time.sleep(0.1)
  483.     count = 0
  484.     while len(threading._limbo) != num_limbo and count < _MAX_COUNT:
  485.         count += 1
  486.         time.sleep(0.1)
  487.  
  488.  
  489. def reap_children():
  490.     import os
  491.     if hasattr(os, 'waitpid'):
  492.         any_process = -1
  493.         while True:
  494.             
  495.             try:
  496.                 (pid, status) = os.waitpid(any_process, os.WNOHANG)
  497.                 if pid == 0:
  498.                     break
  499.             continue
  500.             break
  501.             continue
  502.  
  503.     
  504.  
  505.