home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / test / test_support.pyo (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  19.7 KB  |  704 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. if __name__ != 'test.test_support':
  5.     raise ImportError('test_support must be imported from the test package')
  6. __name__ != 'test.test_support'
  7. import contextlib
  8. import errno
  9. import socket
  10. import sys
  11. import os
  12. import shutil
  13. import warnings
  14. import unittest
  15. __all__ = [
  16.     'Error',
  17.     'TestFailed',
  18.     'TestSkipped',
  19.     'ResourceDenied',
  20.     'import_module',
  21.     'verbose',
  22.     'use_resources',
  23.     'max_memuse',
  24.     'record_original_stdout',
  25.     'get_original_stdout',
  26.     'unload',
  27.     'unlink',
  28.     'rmtree',
  29.     'forget',
  30.     'is_resource_enabled',
  31.     'requires',
  32.     'find_unused_port',
  33.     'bind_port',
  34.     'fcmp',
  35.     'have_unicode',
  36.     'is_jython',
  37.     'TESTFN',
  38.     'HOST',
  39.     'FUZZ',
  40.     'findfile',
  41.     'verify',
  42.     'vereq',
  43.     'sortdict',
  44.     'check_syntax_error',
  45.     'open_urlresource',
  46.     'check_warnings',
  47.     'CleanImport',
  48.     'EnvironmentVarGuard',
  49.     'captured_output',
  50.     'captured_stdout',
  51.     'TransientResource',
  52.     'transient_internet',
  53.     'run_with_locale',
  54.     'set_memlimit',
  55.     'bigmemtest',
  56.     'bigaddrspacetest',
  57.     'BasicTestRunner',
  58.     'run_unittest',
  59.     'run_doctest',
  60.     'threading_setup',
  61.     'threading_cleanup',
  62.     'reap_children']
  63.  
  64. class Error(Exception):
  65.     pass
  66.  
  67.  
  68. class TestFailed(Error):
  69.     pass
  70.  
  71.  
  72. class TestSkipped(Error):
  73.     pass
  74.  
  75.  
  76. class ResourceDenied(TestSkipped):
  77.     pass
  78.  
  79.  
  80. def import_module(name, deprecated = False):
  81.     warnings.catch_warnings().__enter__()
  82.     
  83.     try:
  84.         
  85.         try:
  86.             module = __import__(name, level = 0)
  87.         except ImportError:
  88.             None if deprecated else warnings.catch_warnings()
  89.             None if deprecated else warnings.catch_warnings()
  90.             raise TestSkipped('No module named ' + name)
  91.         except:
  92.             None if deprecated else warnings.catch_warnings()
  93.  
  94.         return module
  95.     finally:
  96.         pass
  97.  
  98.  
  99. verbose = 1
  100. use_resources = None
  101. max_memuse = 0
  102. real_max_memuse = 0
  103. _original_stdout = None
  104.  
  105. def record_original_stdout(stdout):
  106.     global _original_stdout
  107.     _original_stdout = stdout
  108.  
  109.  
  110. def get_original_stdout():
  111.     if not _original_stdout:
  112.         pass
  113.     return sys.stdout
  114.  
  115.  
  116. def unload(name):
  117.     
  118.     try:
  119.         del sys.modules[name]
  120.     except KeyError:
  121.         pass
  122.  
  123.  
  124.  
  125. def unlink(filename):
  126.     
  127.     try:
  128.         os.unlink(filename)
  129.     except OSError:
  130.         pass
  131.  
  132.  
  133.  
  134. def rmtree(path):
  135.     
  136.     try:
  137.         shutil.rmtree(path)
  138.     except OSError:
  139.         e = None
  140.         if e.errno not in (errno.ENOENT, errno.ESRCH):
  141.             raise 
  142.         e.errno not in (errno.ENOENT, errno.ESRCH)
  143.  
  144.  
  145.  
  146. def forget(modname):
  147.     unload(modname)
  148.     for dirname in sys.path:
  149.         unlink(os.path.join(dirname, modname + os.extsep + 'pyc'))
  150.         unlink(os.path.join(dirname, modname + os.extsep + 'pyo'))
  151.     
  152.  
  153.  
  154. def is_resource_enabled(resource):
  155.     if use_resources is not None:
  156.         pass
  157.     return resource in use_resources
  158.  
  159.  
  160. def requires(resource, msg = None):
  161.     if sys._getframe().f_back.f_globals.get('__name__') == '__main__':
  162.         return None
  163.     if not is_resource_enabled(resource):
  164.         if msg is None:
  165.             msg = "Use of the `%s' resource not enabled" % resource
  166.         
  167.         raise ResourceDenied(msg)
  168.     is_resource_enabled(resource)
  169.  
  170. HOST = 'localhost'
  171.  
  172. def find_unused_port(family = socket.AF_INET, socktype = socket.SOCK_STREAM):
  173.     tempsock = socket.socket(family, socktype)
  174.     port = bind_port(tempsock)
  175.     tempsock.close()
  176.     del tempsock
  177.     return port
  178.  
  179.  
  180. def bind_port(sock, host = HOST):
  181.     if sock.family == socket.AF_INET and sock.type == socket.SOCK_STREAM:
  182.         if hasattr(socket, 'SO_REUSEADDR'):
  183.             if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) == 1:
  184.                 raise TestFailed('tests should never set the SO_REUSEADDR socket option on TCP/IP sockets!')
  185.             sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) == 1
  186.         
  187.         if hasattr(socket, 'SO_REUSEPORT'):
  188.             if sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT) == 1:
  189.                 raise TestFailed('tests should never set the SO_REUSEPORT socket option on TCP/IP sockets!')
  190.             sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT) == 1
  191.         
  192.         if hasattr(socket, 'SO_EXCLUSIVEADDRUSE'):
  193.             sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
  194.         
  195.     
  196.     sock.bind((host, 0))
  197.     port = sock.getsockname()[1]
  198.     return port
  199.  
  200. FUZZ = 1e-06
  201.  
  202. def fcmp(x, y):
  203.     if isinstance(x, float) or isinstance(y, float):
  204.         
  205.         try:
  206.             fuzz = (abs(x) + abs(y)) * FUZZ
  207.             if abs(x - y) <= fuzz:
  208.                 return 0
  209.  
  210.     elif type(x) == type(y) and isinstance(x, (tuple, list)):
  211.         for i in range(min(len(x), len(y))):
  212.             outcome = fcmp(x[i], y[i])
  213.             if outcome != 0:
  214.                 return outcome
  215.         
  216.         return (len(x) > len(y)) - (len(x) < len(y))
  217.     outcome != 0
  218.     return (x > y) - (x < y)
  219.  
  220.  
  221. try:
  222.     unicode
  223.     have_unicode = True
  224. except NameError:
  225.     have_unicode = False
  226.  
  227. is_jython = sys.platform.startswith('java')
  228. if os.name == 'java':
  229.     TESTFN = '$test'
  230. elif os.name == 'riscos':
  231.     TESTFN = 'testfile'
  232. else:
  233.     TESTFN = '@test'
  234.     if have_unicode:
  235.         if isinstance('', unicode):
  236.             TESTFN_UNICODE = '@test-\xe0\xf2'
  237.         else:
  238.             TESTFN_UNICODE = unicode('@test-\xe0\xf2', 'latin-1')
  239.         TESTFN_ENCODING = sys.getfilesystemencoding()
  240.         if not hasattr(sys, 'getwindowsversion') or sys.getwindowsversion()[3] < 2:
  241.             TESTFN_UNICODE_UNENCODEABLE = None
  242.         else:
  243.             TESTFN_UNICODE_UNENCODEABLE = eval('u"@test-\\u5171\\u6709\\u3055\\u308c\\u308b"')
  244.             
  245.             try:
  246.                 TESTFN_UNICODE_UNENCODEABLE.encode('Latin1')
  247.             except UnicodeEncodeError:
  248.                 pass
  249.  
  250.             print 'WARNING: The filename %r CAN be encoded by the filesystem.  Unicode filename tests may not be effective' % TESTFN_UNICODE_UNENCODEABLE
  251.     
  252. fp = None
  253.  
  254. try:
  255.     fp = open(TESTFN, 'w+')
  256. except IOError:
  257.     TMP_TESTFN = os.path.join('/tmp', TESTFN)
  258.     
  259.     try:
  260.         fp = open(TMP_TESTFN, 'w+')
  261.         TESTFN = TMP_TESTFN
  262.         del TMP_TESTFN
  263.     except IOError:
  264.         print 'WARNING: tests will fail, unable to write to: %s or %s' % (TESTFN, TMP_TESTFN)
  265.     except:
  266.         None<EXCEPTION MATCH>IOError
  267.     
  268.  
  269.     None<EXCEPTION MATCH>IOError
  270.  
  271. if fp is not None:
  272.     fp.close()
  273.     unlink(TESTFN)
  274.  
  275. del fp
  276.  
  277. def findfile(file, here = __file__):
  278.     if os.path.isabs(file):
  279.         return file
  280.     path = sys.path
  281.     path = [
  282.         os.path.dirname(here)] + path
  283.     for dn in path:
  284.         fn = os.path.join(dn, file)
  285.         if os.path.exists(fn):
  286.             return fn
  287.     
  288.     return file
  289.  
  290.  
  291. def verify(condition, reason = 'test failed'):
  292.     if not condition:
  293.         raise TestFailed(reason)
  294.     condition
  295.  
  296.  
  297. def vereq(a, b):
  298.     if not a == b:
  299.         raise TestFailed('%r == %r' % (a, b))
  300.     a == b
  301.  
  302.  
  303. def sortdict(dict):
  304.     items = dict.items()
  305.     items.sort()
  306.     reprpairs = [ '%r: %r' % pair for pair in items ]
  307.     withcommas = ', '.join(reprpairs)
  308.     return '{%s}' % withcommas
  309.  
  310.  
  311. def make_bad_fd():
  312.     file = open(TESTFN, 'wb')
  313.     
  314.     try:
  315.         return file.fileno()
  316.     finally:
  317.         file.close()
  318.         unlink(TESTFN)
  319.  
  320.  
  321.  
  322. def check_syntax_error(testcase, statement):
  323.     
  324.     try:
  325.         compile(statement, '<test string>', 'exec')
  326.     except SyntaxError:
  327.         pass
  328.  
  329.     testcase.fail('Missing SyntaxError: "%s"' % statement)
  330.  
  331.  
  332. def open_urlresource(url):
  333.     import urllib
  334.     import urlparse
  335.     requires('urlfetch')
  336.     filename = urlparse.urlparse(url)[2].split('/')[-1]
  337.     for path in [
  338.         os.path.curdir,
  339.         os.path.pardir]:
  340.         fn = os.path.join(path, filename)
  341.         if os.path.exists(fn):
  342.             return open(fn)
  343.     
  344.     print >>get_original_stdout(), '\tfetching %s ...' % url
  345.     (fn, _) = urllib.urlretrieve(url, filename)
  346.     return open(fn)
  347.  
  348.  
  349. class WarningsRecorder(object):
  350.     
  351.     def __init__(self, warnings_list):
  352.         self.warnings = warnings_list
  353.  
  354.     
  355.     def __getattr__(self, attr):
  356.         if self.warnings:
  357.             return getattr(self.warnings[-1], attr)
  358.         if attr in warnings.WarningMessage._WARNING_DETAILS:
  359.             return None
  360.         raise AttributeError('%r has no attribute %r' % (self, attr))
  361.  
  362.     
  363.     def reset(self):
  364.         del self.warnings[:]
  365.  
  366.  
  367.  
  368. def check_warnings():
  369.     
  370.     try:
  371.         w = _[1]
  372.         yield WarningsRecorder(w)
  373.         warnings.catch_warnings(record = True).__exit__
  374.     finally:
  375.         pass
  376.  
  377.  
  378. check_warnings = contextlib.contextmanager(check_warnings)
  379.  
  380. class CleanImport(object):
  381.     
  382.     def __init__(self, *module_names):
  383.         self.original_modules = sys.modules.copy()
  384.         for module_name in module_names:
  385.             if module_name in sys.modules:
  386.                 module = sys.modules[module_name]
  387.                 if module.__name__ != module_name:
  388.                     del sys.modules[module.__name__]
  389.                 
  390.                 del sys.modules[module_name]
  391.                 continue
  392.         
  393.  
  394.     
  395.     def __enter__(self):
  396.         return self
  397.  
  398.     
  399.     def __exit__(self, *ignore_exc):
  400.         sys.modules.update(self.original_modules)
  401.  
  402.  
  403.  
  404. class EnvironmentVarGuard(object):
  405.     
  406.     def __init__(self):
  407.         self._changed = { }
  408.  
  409.     
  410.     def set(self, envvar, value):
  411.         if envvar not in self._changed:
  412.             self._changed[envvar] = os.environ.get(envvar)
  413.         
  414.         os.environ[envvar] = value
  415.  
  416.     
  417.     def unset(self, envvar):
  418.         if envvar not in self._changed:
  419.             self._changed[envvar] = os.environ.get(envvar)
  420.         
  421.         if envvar in os.environ:
  422.             del os.environ[envvar]
  423.         
  424.  
  425.     
  426.     def __enter__(self):
  427.         return self
  428.  
  429.     
  430.     def __exit__(self, *ignore_exc):
  431.         for k, v in self._changed.items():
  432.             if v is None:
  433.                 if k in os.environ:
  434.                     del os.environ[k]
  435.                 
  436.             k in os.environ
  437.             os.environ[k] = v
  438.         
  439.  
  440.  
  441.  
  442. class TransientResource(object):
  443.     
  444.     def __init__(self, exc, **kwargs):
  445.         self.exc = exc
  446.         self.attrs = kwargs
  447.  
  448.     
  449.     def __enter__(self):
  450.         return self
  451.  
  452.     
  453.     def __exit__(self, type_ = None, value = None, traceback = None):
  454.         if type_ is not None and issubclass(self.exc, type_):
  455.             for attr, attr_value in self.attrs.iteritems():
  456.                 if not hasattr(value, attr):
  457.                     break
  458.                 
  459.                 if getattr(value, attr) != attr_value:
  460.                     break
  461.                     continue
  462.             else:
  463.                 raise ResourceDenied('an optional resource is not available')
  464.  
  465.  
  466.  
  467. def transient_internet():
  468.     time_out = TransientResource(IOError, errno = errno.ETIMEDOUT)
  469.     socket_peer_reset = TransientResource(socket.error, errno = errno.ECONNRESET)
  470.     ioerror_peer_reset = TransientResource(IOError, errno = errno.ECONNRESET)
  471.     return contextlib.nested(time_out, socket_peer_reset, ioerror_peer_reset)
  472.  
  473.  
  474. def captured_output(stream_name):
  475.     import StringIO
  476.     orig_stdout = getattr(sys, stream_name)
  477.     setattr(sys, stream_name, StringIO.StringIO())
  478.     
  479.     try:
  480.         yield getattr(sys, stream_name)
  481.     finally:
  482.         setattr(sys, stream_name, orig_stdout)
  483.  
  484.  
  485. captured_output = contextlib.contextmanager(captured_output)
  486.  
  487. def captured_stdout():
  488.     return captured_output('stdout')
  489.  
  490.  
  491. def run_with_locale(catstr, *locales):
  492.     
  493.     def decorator(func):
  494.         
  495.         def inner(*args, **kwds):
  496.             
  497.             try:
  498.                 import locale
  499.                 category = getattr(locale, catstr)
  500.                 orig_locale = locale.setlocale(category)
  501.             except AttributeError:
  502.                 raise 
  503.             except:
  504.                 locale = None
  505.                 orig_locale = None
  506.  
  507.             for loc in locales:
  508.                 
  509.                 try:
  510.                     locale.setlocale(category, loc)
  511.                 continue
  512.                 continue
  513.  
  514.             
  515.             
  516.             try:
  517.                 return func(*args, **kwds)
  518.             finally:
  519.                 if locale and orig_locale:
  520.                     locale.setlocale(category, orig_locale)
  521.                 
  522.  
  523.  
  524.         inner.func_name = func.func_name
  525.         inner.__doc__ = func.__doc__
  526.         return inner
  527.  
  528.     return decorator
  529.  
  530. _1M = 1048576
  531. _1G = 1024 * _1M
  532. _2G = 2 * _1G
  533. _4G = 4 * _1G
  534. MAX_Py_ssize_t = sys.maxsize
  535.  
  536. def set_memlimit(limit):
  537.     global real_max_memuse, max_memuse
  538.     import re
  539.     sizes = {
  540.         'k': 1024,
  541.         'm': _1M,
  542.         'g': _1G,
  543.         't': 1024 * _1G }
  544.     m = re.match('(\\d+(\\.\\d+)?) (K|M|G|T)b?$', limit, re.IGNORECASE | re.VERBOSE)
  545.     if m is None:
  546.         raise ValueError('Invalid memory limit %r' % (limit,))
  547.     m is None
  548.     memlimit = int(float(m.group(1)) * sizes[m.group(3).lower()])
  549.     real_max_memuse = memlimit
  550.     if memlimit > MAX_Py_ssize_t:
  551.         memlimit = MAX_Py_ssize_t
  552.     
  553.     if memlimit < _2G - 1:
  554.         raise ValueError('Memory limit %r too low to be useful' % (limit,))
  555.     memlimit < _2G - 1
  556.     max_memuse = memlimit
  557.  
  558.  
  559. def bigmemtest(minsize, memuse, overhead = 5 * _1M):
  560.     
  561.     def decorator(f):
  562.         
  563.         def wrapper(self):
  564.             return f(self, maxsize)
  565.  
  566.         wrapper.minsize = minsize
  567.         wrapper.memuse = memuse
  568.         wrapper.overhead = overhead
  569.         return wrapper
  570.  
  571.     return decorator
  572.  
  573.  
  574. def precisionbigmemtest(size, memuse, overhead = 5 * _1M):
  575.     
  576.     def decorator(f):
  577.         
  578.         def wrapper(self):
  579.             return f(self, maxsize)
  580.  
  581.         wrapper.size = size
  582.         wrapper.memuse = memuse
  583.         wrapper.overhead = overhead
  584.         return wrapper
  585.  
  586.     return decorator
  587.  
  588.  
  589. def bigaddrspacetest(f):
  590.     
  591.     def wrapper(self):
  592.         if max_memuse < MAX_Py_ssize_t:
  593.             if verbose:
  594.                 sys.stderr.write('Skipping %s because of memory constraint\n' % (f.__name__,))
  595.             
  596.         else:
  597.             return f(self)
  598.         return max_memuse < MAX_Py_ssize_t
  599.  
  600.     return wrapper
  601.  
  602.  
  603. class BasicTestRunner:
  604.     
  605.     def run(self, test):
  606.         result = unittest.TestResult()
  607.         test(result)
  608.         return result
  609.  
  610.  
  611.  
  612. def _run_suite(suite):
  613.     if verbose:
  614.         runner = unittest.TextTestRunner(sys.stdout, verbosity = 2)
  615.     else:
  616.         runner = BasicTestRunner()
  617.     result = runner.run(suite)
  618.     if not result.wasSuccessful():
  619.         if len(result.errors) == 1 and not (result.failures):
  620.             err = result.errors[0][1]
  621.         elif len(result.failures) == 1 and not (result.errors):
  622.             err = result.failures[0][1]
  623.         else:
  624.             err = 'errors occurred; run in verbose mode for details'
  625.         raise TestFailed(err)
  626.     result.wasSuccessful()
  627.  
  628.  
  629. def run_unittest(*classes):
  630.     valid_types = (unittest.TestSuite, unittest.TestCase)
  631.     suite = unittest.TestSuite()
  632.     for cls in classes:
  633.         if isinstance(cls, str):
  634.             if cls in sys.modules:
  635.                 suite.addTest(unittest.findTestCases(sys.modules[cls]))
  636.             else:
  637.                 raise ValueError('str arguments must be keys in sys.modules')
  638.         cls in sys.modules
  639.         if isinstance(cls, valid_types):
  640.             suite.addTest(cls)
  641.             continue
  642.         suite.addTest(unittest.makeSuite(cls))
  643.     
  644.     _run_suite(suite)
  645.  
  646.  
  647. def run_doctest(module, verbosity = None):
  648.     import doctest
  649.     if verbosity is None:
  650.         verbosity = verbose
  651.     else:
  652.         verbosity = None
  653.     save_stdout = sys.stdout
  654.     sys.stdout = get_original_stdout()
  655.     
  656.     try:
  657.         (f, t) = doctest.testmod(module, verbose = verbosity)
  658.         if f:
  659.             raise TestFailed('%d of %d doctests failed' % (f, t))
  660.         f
  661.     finally:
  662.         sys.stdout = save_stdout
  663.  
  664.     if verbose:
  665.         print 'doctest (%s) ... %d tests with zero failures' % (module.__name__, t)
  666.     
  667.     return (f, t)
  668.  
  669.  
  670. def threading_setup():
  671.     import threading
  672.     return (len(threading._active), len(threading._limbo))
  673.  
  674.  
  675. def threading_cleanup(num_active, num_limbo):
  676.     import threading
  677.     import time
  678.     _MAX_COUNT = 10
  679.     count = 0
  680.     while len(threading._active) != num_active and count < _MAX_COUNT:
  681.         count += 1
  682.         time.sleep(0.1)
  683.     count = 0
  684.     while len(threading._limbo) != num_limbo and count < _MAX_COUNT:
  685.         count += 1
  686.         time.sleep(0.1)
  687.  
  688.  
  689. def reap_children():
  690.     if hasattr(os, 'waitpid'):
  691.         any_process = -1
  692.         while True:
  693.             
  694.             try:
  695.                 (pid, status) = os.waitpid(any_process, os.WNOHANG)
  696.                 if pid == 0:
  697.                     break
  698.             continue
  699.             break
  700.             continue
  701.  
  702.     
  703.  
  704.