PageRenderTime 39ms CodeModel.GetById 8ms RepoModel.GetById 0ms app.codeStats 0ms

/lib-python/conftest.py

https://bitbucket.org/pypy/pypy/
Python | 681 lines | 661 code | 1 blank | 19 comment | 2 complexity | 6525b65bbd61c5efd2af280808fc6119 MD5 | raw file
Possible License(s): AGPL-3.0, BSD-3-Clause, Apache-2.0 
    

  1. """
    2. 

    3. 

  3. test configuration(s) for running CPython's regression
    4. 

  4. test suite on top of PyPy
    5. 

  5. 

  6. """
    7. 

  7. import py
    8. 

  8. import sys
    9. 

  9. import pypy
    10. 

  10. import re
    11. 

  11. from pypy.interpreter.gateway import ApplevelClass
    12. 

  12. from pypy.interpreter.error import OperationError
    13. 

  13. from pypy.interpreter.module import Module as PyPyModule
    14. 

  14. from pypy.interpreter.main import run_string, run_file
    15. 

  15. 

  16. # the following adds command line options as a side effect!
    17. 

  17. from pypy.conftest import option as pypy_option
    18. 

  18. 

  19. from pypy.tool.pytest import appsupport
    20. 

  20. from pypy.tool.pytest.confpath import pypydir, rpythondir, testdir, testresultdir
    21. 

  21. from rpython.config.parse import parse_info
    22. 

  22. 

  23. pytest_plugins = "resultlog",
    24. 

  24. rsyncdirs = ['.', '../pypy/']
    25. 

  25. 

  26. #
    27. 

  27. # Interfacing/Integrating with py.test's collection process
    28. 

  28. #
    29. 

  29. 

  30. def pytest_addoption(parser):
    31. 

  31.     group = parser.getgroup("complicance testing options")
    32. 

  32.     group.addoption('-T', '--timeout', action="store", type="string",
    33. 

  33.                     default="1000", dest="timeout",
    34. 

  34.                     help="fail a test module after the given timeout. "
    35. 

  35.                          "specify in seconds or 'NUMmp' aka Mega-Pystones")
    36. 

  36.     group.addoption('--pypy', action="store", type="string", dest="pypy",
    37. 

  37.                     help="use given pypy executable to run lib-python tests. "
    38. 

  38.                          "This will run the tests directly (i.e. not through py.py)")
    39. 

  39.     group.addoption('--filter', action="store", type="string", default=None,
    40. 

  40.                     dest="unittest_filter", help="Similar to -k, XXX")
    41. 

  41. 

  42. def gettimeout(timeout):
    43. 

  43.     from rpython.translator.test import rpystone
    44. 

  44.     if timeout.endswith('mp'):
    45. 

  45.         megapystone = float(timeout[:-2])
    46. 

  46.         t, stone = pystone.Proc0(10000)
    47. 

  47.         pystonetime = t/stone
    48. 

  48.         seconds = megapystone * 1000000 * pystonetime
    49. 

  49.         return seconds
    50. 

  50.     return float(timeout)
    51. 

  51. 

  52. # ________________________________________________________________________
    53. 

  53. #
    54. 

  54. # classification of all tests files (this is ongoing work)
    55. 

  55. #
    56. 

  56. 

  57. class RegrTest:
    58. 

  58.     """ Regression Test Declaration."""
    59. 

  59.     def __init__(self, basename, core=False, compiler=None, usemodules='',
    60. 

  60.                  skip=None):
    61. 

  61.         self.basename = basename
    62. 

  62.         self._usemodules = usemodules.split() + ['signal', 'time', 'itertools', '_socket']
    63. 

  63.         self._compiler = compiler
    64. 

  64.         self.core = core
    65. 

  65.         self.skip = skip
    66. 

  66.         assert self.getfspath().check(), "%r not found!" % (basename,)
    67. 

  67. 

  68.     def usemodules(self):
    69. 

  69.         return self._usemodules  # + pypy_option.usemodules
    70. 

  70.     usemodules = property(usemodules)
    71. 

  71. 

  72.     def compiler(self):
    73. 

  73.         return self._compiler  # or pypy_option.compiler
    74. 

  74.     compiler = property(compiler)
    75. 

  75. 

  76.     def ismodified(self):
    77. 

  77.         #XXX: ask hg
    78. 

  78.         return None
    79. 

  79. 

  80.     def getfspath(self):
    81. 

  81.         return testdir.join(self.basename)
    82. 

  82. 

  83.     def run_file(self, space):
    84. 

  84.         fspath = self.getfspath()
    85. 

  85.         assert fspath.check()
    86. 

  86.         modname = fspath.purebasename
    87. 

  87.         space.appexec([], '''():
    88. 

  88.             from test import %(modname)s
    89. 

  89.             m = %(modname)s
    90. 

  90.             if hasattr(m, 'test_main'):
    91. 

  91.                 m.test_main()
    92. 

  92.         ''' % locals())
    93. 

    94. 

  94. testmap = [
    95. 

  95.     RegrTest('test___all__.py', core=True),
    96. 

  96.     RegrTest('test___future__.py', core=True),
    97. 

  97.     RegrTest('test__locale.py', usemodules='_locale'),
    98. 

  98.     RegrTest('test__osx_support.py'),
    99. 

  99.     RegrTest('test_abc.py'),
    100. 

  100.     RegrTest('test_abstract_numbers.py'),
    101. 

  101.     RegrTest('test_aepack.py'),
    102. 

  102.     RegrTest('test_aifc.py'),
    103. 

  103.     RegrTest('test_al.py'),
    104. 

  104.     RegrTest('test_anydbm.py', usemodules='struct'),
    105. 

  105.     RegrTest('test_applesingle.py'),
    106. 

  106.     RegrTest('test_argparse.py', usemodules='binascii'),
    107. 

  107.     RegrTest('test_array.py', core=True, usemodules='struct array binascii'),
    108. 

  108.     RegrTest('test_ascii_formatd.py'),
    109. 

  109.     RegrTest('test_ast.py', core=True, usemodules='struct'),
    110. 

  110.     RegrTest('test_asynchat.py', usemodules='select fcntl'),
    111. 

  111.     RegrTest('test_asyncore.py', usemodules='select fcntl'),
    112. 

  112.     RegrTest('test_atexit.py', core=True),
    113. 

  113.     RegrTest('test_audioop.py'),
    114. 

  114.     RegrTest('test_augassign.py', core=True),
    115. 

  115.     RegrTest('test_base64.py', usemodules='struct'),
    116. 

  116.     RegrTest('test_bastion.py'),
    117. 

  117.     RegrTest('test_bigaddrspace.py'),
    118. 

  118.     RegrTest('test_bigmem.py'),
    119. 

  119.     RegrTest('test_binascii.py', usemodules='binascii'),
    120. 

  120.     RegrTest('test_binhex.py'),
    121. 

  121.     RegrTest('test_binop.py', core=True),
    122. 

  122.     RegrTest('test_bisect.py', core=True, usemodules='_bisect'),
    123. 

  123.     RegrTest('test_bool.py', core=True),
    124. 

  124.     RegrTest('test_bsddb.py'),
    125. 

  125.     RegrTest('test_bsddb185.py'),
    126. 

  126.     RegrTest('test_bsddb3.py'),
    127. 

  127.     RegrTest('test_buffer.py'),
    128. 

  128.     RegrTest('test_bufio.py', core=True),
    129. 

  129.     RegrTest('test_builtin.py', core=True, usemodules='binascii'),
    130. 

  130.     RegrTest('test_bytes.py', usemodules='struct binascii'),
    131. 

  131.     RegrTest('test_bz2.py', usemodules='bz2'),
    132. 

  132.     RegrTest('test_calendar.py'),
    133. 

  133.     RegrTest('test_call.py', core=True),
    134. 

  134.     RegrTest('test_capi.py', usemodules='cpyext'),
    135. 

  135.     RegrTest('test_cd.py'),
    136. 

  136.     RegrTest('test_cfgparser.py'),
    137. 

  137.     RegrTest('test_cgi.py'),
    138. 

  138.     RegrTest('test_charmapcodec.py', core=True),
    139. 

  139.     RegrTest('test_cl.py'),
    140. 

  140.     RegrTest('test_class.py', core=True),
    141. 

  141.     RegrTest('test_cmath.py', core=True),
    142. 

  142.     RegrTest('test_cmd.py'),
    143. 

  143.     RegrTest('test_cmd_line.py'),
    144. 

  144.     RegrTest('test_cmd_line_script.py'),
    145. 

  145.     RegrTest('test_code.py', core=True),
    146. 

  146.     RegrTest('test_codeccallbacks.py', core=True),
    147. 

  147.     RegrTest('test_codecencodings_cn.py', usemodules='_multibytecodec'),
    148. 

  148.     RegrTest('test_codecencodings_hk.py', usemodules='_multibytecodec'),
    149. 

  149.     RegrTest('test_codecencodings_iso2022.py', usemodules='_multibytecodec'),
    150. 

  150.     RegrTest('test_codecencodings_jp.py', usemodules='_multibytecodec'),
    151. 

  151.     RegrTest('test_codecencodings_kr.py', usemodules='_multibytecodec'),
    152. 

  152.     RegrTest('test_codecencodings_tw.py', usemodules='_multibytecodec'),
    153. 

  153.     RegrTest('test_codecmaps_cn.py', usemodules='_multibytecodec'),
    154. 

  154.     RegrTest('test_codecmaps_hk.py', usemodules='_multibytecodec'),
    155. 

  155.     RegrTest('test_codecmaps_jp.py', usemodules='_multibytecodec'),
    156. 

  156.     RegrTest('test_codecmaps_kr.py', usemodules='_multibytecodec'),
    157. 

  157.     RegrTest('test_codecmaps_tw.py', usemodules='_multibytecodec'),
    158. 

  158.     RegrTest('test_codecs.py', core=True, usemodules='_multibytecodec'),
    159. 

  159.     RegrTest('test_codeop.py', core=True),
    160. 

  160.     RegrTest('test_coding.py', core=True),
    161. 

  161.     RegrTest('test_coercion.py', core=True, usemodules='struct'),
    162. 

  162.     RegrTest('test_collections.py', usemodules='binascii struct'),
    163. 

  163.     RegrTest('test_colorsys.py'),
    164. 

  164.     RegrTest('test_commands.py'),
    165. 

  165.     RegrTest('test_compare.py', core=True),
    166. 

  166.     RegrTest('test_compile.py', core=True),
    167. 

  167.     RegrTest('test_compileall.py'),
    168. 

  168.     RegrTest('test_compiler.py', core=False, skip="slowly deprecating compiler"),
    169. 

  169.     RegrTest('test_complex.py', core=True),
    170. 

  170.     RegrTest('test_complex_args.py'),
    171. 

  171.     RegrTest('test_contains.py', core=True),
    172. 

  172.     RegrTest('test_contextlib.py', usemodules="thread"),
    173. 

  173.     RegrTest('test_cookie.py'),
    174. 

  174.     RegrTest('test_cookielib.py'),
    175. 

  175.     RegrTest('test_copy.py', core=True),
    176. 

  176.     RegrTest('test_copy_reg.py', core=True),
    177. 

  177.     RegrTest('test_cpickle.py', core=True),
    178. 

  178.     RegrTest('test_cprofile.py'),
    179. 

  179.     RegrTest('test_crypt.py', usemodules='crypt'),
    180. 

  180.     RegrTest('test_csv.py', usemodules='_csv'),
    181. 

  181.     RegrTest('test_ctypes.py', usemodules="_rawffi thread cpyext"),
    182. 

  182.     RegrTest('test_curses.py'),
    183. 

  183.     RegrTest('test_datetime.py', usemodules='binascii struct'),
    184. 

  184.     RegrTest('test_dbm.py'),
    185. 

  185.     RegrTest('test_decimal.py'),
    186. 

  186.     RegrTest('test_decorators.py', core=True),
    187. 

  187.     RegrTest('test_defaultdict.py', usemodules='_collections'),
    188. 

  188.     RegrTest('test_deque.py', core=True, usemodules='_collections'),
    189. 

  189.     RegrTest('test_descr.py', core=True, usemodules='_weakref'),
    190. 

  190.     RegrTest('test_descrtut.py', core=True),
    191. 

  191.     RegrTest('test_dict.py', core=True),
    192. 

  192.     RegrTest('test_dictcomps.py', core=True),
    193. 

  193.     RegrTest('test_dictviews.py', core=True),
    194. 

  194.     RegrTest('test_difflib.py'),
    195. 

  195.     RegrTest('test_dircache.py', core=True),
    196. 

  196.     RegrTest('test_dis.py'),
    197. 

  197.     RegrTest('test_distutils.py', skip=True),
    198. 

  198.     RegrTest('test_dl.py'),
    199. 

  199.     RegrTest('test_doctest.py', usemodules="thread"),
    200. 

  200.     RegrTest('test_doctest2.py'),
    201. 

  201.     RegrTest('test_docxmlrpc.py'),
    202. 

  202.     RegrTest('test_dumbdbm.py'),
    203. 

  203.     RegrTest('test_dummy_thread.py', core=True),
    204. 

  204.     RegrTest('test_dummy_threading.py', core=True),
    205. 

  205.     RegrTest('test_email.py'),
    206. 

  206.     RegrTest('test_email_codecs.py'),
    207. 

  207.     RegrTest('test_email_renamed.py'),
    208. 

  208.     RegrTest('test_ensurepip.py'),
    209. 

  209.     RegrTest('test_enumerate.py', core=True),
    210. 

  210.     RegrTest('test_eof.py', core=True),
    211. 

  211.     RegrTest('test_epoll.py'),
    212. 

  212.     RegrTest('test_errno.py', usemodules="errno"),
    213. 

  213.     RegrTest('test_exception_variations.py'),
    214. 

  214.     RegrTest('test_exceptions.py', core=True),
    215. 

  215.     RegrTest('test_extcall.py', core=True),
    216. 

  216.     RegrTest('test_fcntl.py', usemodules='fcntl'),
    217. 

  217.     RegrTest('test_file.py', usemodules="posix", core=True),
    218. 

  218.     RegrTest('test_file2k.py', usemodules="posix", core=True),
    219. 

  219.     RegrTest('test_file_eintr.py'),
    220. 

  220.     RegrTest('test_filecmp.py', core=True),
    221. 

  221.     RegrTest('test_fileinput.py', core=True),
    222. 

  222.     RegrTest('test_fileio.py'),
    223. 

  223.     RegrTest('test_float.py', core=True),
    224. 

  224.     RegrTest('test_fnmatch.py', core=True),
    225. 

  225.     RegrTest('test_fork1.py', usemodules="thread"),
    226. 

  226.     RegrTest('test_format.py', core=True),
    227. 

  227.     RegrTest('test_fpformat.py', core=True),
    228. 

  228.     RegrTest('test_fractions.py'),
    229. 

  229.     RegrTest('test_frozen.py', skip="unsupported extension module"),
    230. 

  230.     RegrTest('test_ftplib.py'),
    231. 

  231.     RegrTest('test_funcattrs.py', core=True),
    232. 

  232.     RegrTest('test_functools.py'),
    233. 

  233.     RegrTest('test_future.py', core=True),
    234. 

  234.     RegrTest('test_future1.py', core=True),
    235. 

  235.     RegrTest('test_future2.py', core=True),
    236. 

  236.     RegrTest('test_future3.py', core=True),
    237. 

  237.     RegrTest('test_future4.py', core=True),
    238. 

  238.     RegrTest('test_future5.py', core=True),
    239. 

  239.     RegrTest('test_future_builtins.py'),
    240. 

  240.     RegrTest('test_gc.py', usemodules='_weakref', skip="implementation detail"),
    241. 

  241.     RegrTest('test_gdb.py', skip="not applicable"),
    242. 

  242.     RegrTest('test_gdbm.py'),
    243. 

  243.     RegrTest('test_generators.py', core=True, usemodules='thread _weakref'),
    244. 

  244.     RegrTest('test_genericpath.py'),
    245. 

  245.     RegrTest('test_genexps.py', core=True, usemodules='_weakref'),
    246. 

  246.     RegrTest('test_getargs.py'),
    247. 

  247.     RegrTest('test_getargs2.py', usemodules='binascii', skip=True),
    248. 

  248.     RegrTest('test_getopt.py', core=True),
    249. 

  249.     RegrTest('test_gettext.py'),
    250. 

  250.     RegrTest('test_gl.py'),
    251. 

  251.     RegrTest('test_glob.py', core=True),
    252. 

  252.     RegrTest('test_global.py', core=True),
    253. 

  253.     RegrTest('test_grammar.py', core=True),
    254. 

  254.     RegrTest('test_grp.py'),
    255. 

  255.     RegrTest('test_gzip.py', usemodules='zlib'),
    256. 

  256.     RegrTest('test_hash.py', core=True),
    257. 

  257.     RegrTest('test_hashlib.py', core=True),
    258. 

  258.     RegrTest('test_heapq.py', core=True),
    259. 

  259.     RegrTest('test_hmac.py'),
    260. 

  260.     RegrTest('test_hotshot.py', skip="unsupported extension module"),
    261. 

  261.     RegrTest('test_htmllib.py'),
    262. 

  262.     RegrTest('test_htmlparser.py'),
    263. 

  263.     RegrTest('test_httplib.py'),
    264. 

  264.     RegrTest('test_httpservers.py'),
    265. 

  265.     RegrTest('test_idle.py'),
    266. 

  266.     RegrTest('test_imageop.py'),
    267. 

  267.     RegrTest('test_imaplib.py'),
    268. 

  268.     RegrTest('test_imgfile.py'),
    269. 

  269.     RegrTest('test_imghdr.py'),
    270. 

  270.     RegrTest('test_imp.py', core=True, usemodules='thread'),
    271. 

  271.     RegrTest('test_import.py', core=True),
    272. 

  272.     RegrTest('test_importhooks.py', core=True),
    273. 

  273.     RegrTest('test_importlib.py'),
    274. 

  274.     RegrTest('test_index.py'),
    275. 

  275.     RegrTest('test_inspect.py'),
    276. 

  276.     RegrTest('test_int.py', core=True),
    277. 

  277.     RegrTest('test_int_literal.py', core=True),
    278. 

  278.     RegrTest('test_io.py', usemodules='array binascii'),
    279. 

  279.     RegrTest('test_ioctl.py'),
    280. 

  280.     RegrTest('test_isinstance.py', core=True),
    281. 

  281.     RegrTest('test_iter.py', core=True),
    282. 

  282.     RegrTest('test_iterlen.py', core=True, usemodules="_collections itertools"),
    283. 

  283.     RegrTest('test_itertools.py', core=True, usemodules="itertools struct"),
    284. 

  284.     RegrTest('test_json.py'),
    285. 

  285.     RegrTest('test_kqueue.py'),
    286. 

  286.     RegrTest('test_largefile.py'),
    287. 

  287.     RegrTest('test_lib2to3.py'),
    288. 

  288.     RegrTest('test_linecache.py'),
    289. 

  289.     RegrTest('test_linuxaudiodev.py', skip="unsupported extension module"),
    290. 

  290.     RegrTest('test_list.py', core=True),
    291. 

  291.     RegrTest('test_locale.py', usemodules="_locale"),
    292. 

  292.     RegrTest('test_logging.py', usemodules='thread'),
    293. 

  293.     RegrTest('test_long.py', core=True),
    294. 

  294.     RegrTest('test_long_future.py', core=True),
    295. 

  295.     RegrTest('test_longexp.py', core=True),
    296. 

  296.     RegrTest('test_macos.py'),
    297. 

  297.     RegrTest('test_macostools.py'),
    298. 

  298.     RegrTest('test_macpath.py'),
    299. 

  299.     RegrTest('test_macurl2path.py'),
    300. 

  300.     RegrTest('test_mailbox.py'),
    301. 

  301.     RegrTest('test_marshal.py', core=True),
    302. 

  302.     RegrTest('test_math.py', core=True, usemodules='math'),
    303. 

  303.     RegrTest('test_memoryio.py'),
    304. 

  304.     RegrTest('test_memoryview.py'),
    305. 

  305.     RegrTest('test_md5.py'),
    306. 

  306.     RegrTest('test_mhlib.py', usemodules='binascii struct'),
    307. 

  307.     RegrTest('test_mimetools.py'),
    308. 

  308.     RegrTest('test_mimetypes.py'),
    309. 

  309.     RegrTest('test_MimeWriter.py', core=False, usemodules='binascii'),
    310. 

  310.     RegrTest('test_minidom.py'),
    311. 

  311.     RegrTest('test_mmap.py', usemodules="mmap"),
    312. 

  312.     RegrTest('test_module.py', core=True),
    313. 

  313.     RegrTest('test_modulefinder.py'),
    314. 

  314.     RegrTest('test_msilib.py'),
    315. 

  315.     RegrTest('test_multibytecodec.py', usemodules='_multibytecodec'),
    316. 

  316.     RegrTest('test_multifile.py'),
    317. 

  317.     RegrTest('test_multiprocessing.py'),
    318. 

  318.     RegrTest('test_mutants.py', core="possibly"),
    319. 

  319.     RegrTest('test_mutex.py'),
    320. 

  320.     RegrTest('test_netrc.py'),
    321. 

  321.     RegrTest('test_new.py', core=True),
    322. 

  322.     RegrTest('test_nis.py'),
    323. 

  323.     RegrTest('test_normalization.py'),
    324. 

  324.     RegrTest('test_nntplib.py'),
    325. 

  325.     RegrTest('test_ntpath.py'),
    326. 

  326.     RegrTest('test_old_mailbox.py'),
    327. 

  327.     RegrTest('test_opcodes.py', core=True),
    328. 

  328.     RegrTest('test_openpty.py'),
    329. 

  329.     RegrTest('test_operator.py', core=True),
    330. 

  330.     RegrTest('test_optparse.py'),
    331. 

  331.     RegrTest('test_os.py', core=True),
    332. 

  332.     RegrTest('test_ossaudiodev.py'),
    333. 

  333.     RegrTest('test_parser.py', skip="slowly deprecating compiler"),
    334. 

  334.     RegrTest('test_pdb.py'),
    335. 

  335.     RegrTest('test_peepholer.py'),
    336. 

  336.     RegrTest('test_pep247.py'),
    337. 

  337.     RegrTest('test_pep263.py'),
    338. 

  338.     RegrTest('test_pep277.py'),
    339. 

  339.     RegrTest('test_pep292.py'),
    340. 

  340.     RegrTest('test_pep352.py'),
    341. 

  341.     RegrTest('test_pickle.py', core=True),
    342. 

  342.     RegrTest('test_pickletools.py', core=False),
    343. 

  343.     RegrTest('test_pipes.py'),
    344. 

  344.     RegrTest('test_pkg.py', core=True),
    345. 

  345.     RegrTest('test_pkgimport.py', core=True),
    346. 

  346.     RegrTest('test_pkgutil.py'),
    347. 

  347.     RegrTest('test_platform.py'),
    348. 

  348.     RegrTest('test_plistlib.py'),
    349. 

  349.     RegrTest('test_poll.py'),
    350. 

  350.     RegrTest('test_popen.py'),
    351. 

  351.     RegrTest('test_popen2.py'),
    352. 

  352.     RegrTest('test_poplib.py'),
    353. 

  353.     RegrTest('test_posix.py', usemodules="_rawffi"),
    354. 

  354.     RegrTest('test_posixpath.py'),
    355. 

  355.     RegrTest('test_pow.py', core=True),
    356. 

  356.     RegrTest('test_pprint.py', core=True),
    357. 

  357.     RegrTest('test_print.py', core=True),
    358. 

  358.     RegrTest('test_profile.py'),
    359. 

  359.     RegrTest('test_property.py', core=True),
    360. 

  360.     RegrTest('test_pstats.py'),
    361. 

  361.     RegrTest('test_pty.py', usemodules='fcntl termios select'),
    362. 

  362.     RegrTest('test_pwd.py', usemodules="pwd"),
    363. 

  363.     RegrTest('test_py3kwarn.py'),
    364. 

  364.     RegrTest('test_py_compile.py'),
    365. 

  365.     RegrTest('test_pyclbr.py'),
    366. 

  366.     RegrTest('test_pydoc.py'),
    367. 

  367.     RegrTest('test_pyexpat.py'),
    368. 

  368.     RegrTest('test_queue.py', usemodules='thread'),
    369. 

  369.     RegrTest('test_quopri.py'),
    370. 

  370.     RegrTest('test_random.py'),
    371. 

  371.     RegrTest('test_re.py', core=True),
    372. 

  372.     RegrTest('test_readline.py'),
    373. 

  373.     RegrTest('test_repr.py', core=True),
    374. 

  374.     RegrTest('test_resource.py'),
    375. 

  375.     RegrTest('test_rfc822.py'),
    376. 

  376.     RegrTest('test_richcmp.py', core=True),
    377. 

  377.     RegrTest('test_rlcompleter.py'),
    378. 

  378.     RegrTest('test_robotparser.py'),
    379. 

  379.     RegrTest('test_runpy.py'),
    380. 

  380.     RegrTest('test_sax.py'),
    381. 

  381.     RegrTest('test_scope.py', core=True),
    382. 

  382.     RegrTest('test_scriptpackages.py'),
    383. 

  383.     RegrTest('test_select.py'),
    384. 

  384.     RegrTest('test_set.py', core=True),
    385. 

  385.     RegrTest('test_sets.py'),
    386. 

  386.     RegrTest('test_setcomps.py', core=True),
    387. 

  387.     RegrTest('test_sgmllib.py'),
    388. 

  388.     RegrTest('test_sha.py'),
    389. 

  389.     RegrTest('test_shelve.py'),
    390. 

  390.     RegrTest('test_shlex.py'),
    391. 

  391.     RegrTest('test_shutil.py'),
    392. 

  392.     RegrTest('test_signal.py'),
    393. 

  393.     RegrTest('test_SimpleHTTPServer.py', usemodules='binascii'),
    394. 

  394.     RegrTest('test_site.py', core=False),
    395. 

  395.     RegrTest('test_slice.py', core=True),
    396. 

  396.     RegrTest('test_smtplib.py'),
    397. 

  397.     RegrTest('test_smtpnet.py'),
    398. 

  398.     RegrTest('test_socket.py', usemodules='thread _weakref'),
    399. 

  399.     RegrTest('test_socketserver.py', usemodules='thread'),
    400. 

  400.     RegrTest('test_softspace.py', core=True),
    401. 

  401.     RegrTest('test_sort.py', core=True),
    402. 

  402.     RegrTest('test_spwd.py'),
    403. 

  403.     RegrTest('test_sqlite.py', usemodules="thread _rawffi zlib"),
    404. 

  404.     RegrTest('test_ssl.py', usemodules='_ssl _socket select'),
    405. 

  405.     RegrTest('test_startfile.py'),
    406. 

  406.     RegrTest('test_stat.py'),
    407. 

  407.     RegrTest('test_str.py', core=True),
    408. 

  408.     RegrTest('test_strftime.py'),
    409. 

  409.     RegrTest('test_string.py', core=True),
    410. 

  410.     RegrTest('test_StringIO.py', core=True, usemodules='cStringIO array'),
    411. 

  411.     RegrTest('test_stringprep.py'),
    412. 

  412.     RegrTest('test_strop.py', skip="deprecated"),
    413. 

  413.     RegrTest('test_strptime.py'),
    414. 

  414.     RegrTest('test_strtod.py'),
    415. 

  415.     RegrTest('test_struct.py', usemodules='struct'),
    416. 

  416.     RegrTest('test_structmembers.py', skip="CPython specific"),
    417. 

  417.     RegrTest('test_structseq.py'),
    418. 

  418.     RegrTest('test_subprocess.py', usemodules='signal'),
    419. 

  419.     RegrTest('test_sunau.py'),
    420. 

  420.     RegrTest('test_sunaudiodev.py'),
    421. 

  421.     RegrTest('test_sundry.py'),
    422. 

  422.     RegrTest('test_symtable.py', skip="implementation detail"),
    423. 

  423.     RegrTest('test_syntax.py', core=True),
    424. 

  424.     RegrTest('test_sys.py', core=True, usemodules='struct'),
    425. 

  425.     RegrTest('test_sys_setprofile.py', core=True),
    426. 

  426.     RegrTest('test_sys_settrace.py', core=True),
    427. 

  427.     RegrTest('test_sysconfig.py'),
    428. 

  428.     RegrTest('test_tarfile.py'),
    429. 

  429.     RegrTest('test_tcl.py'),
    430. 

  430.     RegrTest('test_telnetlib.py'),
    431. 

  431.     RegrTest('test_tempfile.py'),
    432. 

  432.     RegrTest('test_textwrap.py'),
    433. 

  433.     RegrTest('test_thread.py', usemodules="thread", core=True),
    434. 

  434.     RegrTest('test_threaded_import.py', usemodules="thread", core=True),
    435. 

  435.     RegrTest('test_threadedtempfile.py',
    436. 

  436.              usemodules="thread", core=False),
    437. 

  437.     RegrTest('test_threading.py', usemodules="thread", core=True),
    438. 

  438.     RegrTest('test_threading_local.py', usemodules="thread", core=True),
    439. 

  439.     RegrTest('test_threadsignals.py', usemodules="thread"),
    440. 

  440.     RegrTest('test_time.py', core=True),
    441. 

  441.     RegrTest('test_timeit.py'),
    442. 

  442.     RegrTest('test_timeout.py'),
    443. 

  443.     RegrTest('test_tk.py'),
    444. 

  444.     RegrTest('test_tokenize.py'),
    445. 

  445.     RegrTest('test_tools.py'),
    446. 

  446.     RegrTest('test_trace.py'),
    447. 

  447.     RegrTest('test_traceback.py', core=True),
    448. 

  448.     RegrTest('test_transformer.py', core=True),
    449. 

  449.     RegrTest('test_ttk_guionly.py'),
    450. 

  450.     RegrTest('test_ttk_textonly.py'),
    451. 

  451.     RegrTest('test_tuple.py', core=True),
    452. 

  452.     RegrTest('test_typechecks.py'),
    453. 

  453.     RegrTest('test_types.py', core=True),
    454. 

  454.     RegrTest('test_ucn.py'),
    455. 

  455.     RegrTest('test_unary.py', core=True),
    456. 

  456.     RegrTest('test_undocumented_details.py'),
    457. 

  457.     RegrTest('test_unicode.py', core=True),
    458. 

  458.     RegrTest('test_unicode_file.py'),
    459. 

  459.     RegrTest('test_unicodedata.py'),
    460. 

  460.     RegrTest('test_unittest.py', core=True),
    461. 

  461.     RegrTest('test_univnewlines.py'),
    462. 

  462.     RegrTest('test_univnewlines2k.py', core=True),
    463. 

  463.     RegrTest('test_unpack.py', core=True),
    464. 

  464.     RegrTest('test_urllib.py'),
    465. 

  465.     RegrTest('test_urllib2.py'),
    466. 

  466.     RegrTest('test_urllib2_localnet.py', usemodules="thread"),
    467. 

  467.     RegrTest('test_urllib2net.py'),
    468. 

  468.     RegrTest('test_urllibnet.py'),
    469. 

  469.     RegrTest('test_urlparse.py'),
    470. 

  470.     RegrTest('test_userdict.py', core=True),
    471. 

  471.     RegrTest('test_userlist.py', core=True),
    472. 

  472.     RegrTest('test_userstring.py', core=True),
    473. 

  473.     RegrTest('test_uu.py'),
    474. 

  474.     RegrTest('test_uuid.py'),
    475. 

  475.     RegrTest('test_wait3.py', usemodules="thread"),
    476. 

  476.     RegrTest('test_wait4.py', usemodules="thread"),
    477. 

  477.     RegrTest('test_warnings.py', core=True),
    478. 

  478.     RegrTest('test_wave.py'),
    479. 

  479.     RegrTest('test_weakref.py', core=True, usemodules='_weakref'),
    480. 

  480.     RegrTest('test_weakset.py'),
    481. 

  481.     RegrTest('test_whichdb.py'),
    482. 

  482.     RegrTest('test_winreg.py'),
    483. 

  483.     RegrTest('test_winsound.py'),
    484. 

  484.     RegrTest('test_with.py'),
    485. 

  485.     RegrTest('test_wsgiref.py'),
    486. 

  486.     RegrTest('test_xdrlib.py'),
    487. 

  487.     RegrTest('test_xml_etree.py'),
    488. 

  488.     RegrTest('test_xml_etree_c.py'),
    489. 

  489.     RegrTest('test_xmllib.py'),
    490. 

  490.     RegrTest('test_xmlrpc.py'),
    491. 

  491.     RegrTest('test_xpickle.py'),
    492. 

  492.     RegrTest('test_xrange.py', core=True),
    493. 

  493.     RegrTest('test_zipfile.py'),
    494. 

  494.     RegrTest('test_zipfile64.py'),
    495. 

  495.     RegrTest('test_zipimport.py', usemodules='zlib zipimport'),
    496. 

  496.     RegrTest('test_zipimport_support.py', usemodules='zlib zipimport'),
    497. 

  497.     RegrTest('test_zlib.py', usemodules='zlib'),
    498. 

  498. ]
    499. 

  499. 

  500. def check_testmap_complete():
    501. 

  501.     listed_names = dict.fromkeys([regrtest.basename for regrtest in testmap])
    502. 

  502.     assert len(listed_names) == len(testmap)
    503. 

  503.     # names to ignore
    504. 

  504.     listed_names['test_support.py'] = True
    505. 

  505.     listed_names['test_multibytecodec_support.py'] = True
    506. 

  506.     missing = []
    507. 

  507.     for path in testdir.listdir(fil='test_*.py'):
    508. 

  508.         name = path.basename
    509. 

  509.         if name not in listed_names:
    510. 

  510.             missing.append('    RegrTest(%r),' % (name,))
    511. 

  511.     missing.sort()
    512. 

  512.     assert not missing, "non-listed tests:\n%s" % ('\n'.join(missing),)
    513. 

  513. check_testmap_complete()
    514. 

  514. 

  515. def pytest_configure(config):
    516. 

  516.     config._basename2spec = cache = {}
    517. 

  517.     for x in testmap:
    518. 

  518.         cache[x.basename] = x
    519. 

  519. 

  520. def pytest_collect_file(path, parent, __multicall__):
    521. 

  521.     # don't collect files except through this hook
    522. 

  522.     # implemented by clearing the list of to-be-called
    523. 

  523.     # remaining hook methods
    524. 

  524.     __multicall__.methods[:] = []
    525. 

  525.     regrtest = parent.config._basename2spec.get(path.basename, None)
    526. 

  526.     if regrtest is None:
    527. 

  527.         return
    528. 

  528.     if path.dirpath() != testdir:
    529. 

  529.         return
    530. 

  530.     return RunFileExternal(path.basename, parent=parent, regrtest=regrtest)
    531. 

  531. 

  532. class RunFileExternal(py.test.collect.File):
    533. 

  533.     def __init__(self, name, parent, regrtest):
    534. 

  534.         super(RunFileExternal, self).__init__(name, parent)
    535. 

  535.         self.regrtest = regrtest
    536. 

  536.         self.fspath = regrtest.getfspath()
    537. 

  537. 

  538.     def collect(self):
    539. 

  539.         if self.regrtest.ismodified():
    540. 

  540.             name = 'modified'
    541. 

  541.         else:
    542. 

  542.             name = 'unmodified'
    543. 

  543.         return [ReallyRunFileExternal(name, parent=self)]
    544. 

  544. 

  545. #
    546. 

  546. # testmethod:
    547. 

  547. # invoking in a separate process: py.py TESTFILE
    548. 

  548. #
    549. 

  549. import os
    550. 

  550. 

  551. class ReallyRunFileExternal(py.test.collect.Item):
    552. 

  552.     class ExternalFailure(Exception):
    553. 

  553.         """Failure in running subprocess"""
    554. 

  554. 

  555.     def getinvocation(self, regrtest):
    556. 

  556.         fspath = regrtest.getfspath()
    557. 

  557.         python = sys.executable
    558. 

  558.         pypy_script = pypydir.join('bin', 'pyinteractive.py')
    559. 

  559.         alarm_script = pypydir.join('tool', 'alarm.py')
    560. 

  560.         if sys.platform == 'win32':
    561. 

  561.             watchdog_name = 'watchdog_nt.py'
    562. 

  562.         else:
    563. 

  563.             watchdog_name = 'watchdog.py'
    564. 

  564.         watchdog_script = rpythondir.join('tool', watchdog_name)
    565. 

  565. 

  566.         regr_script = pypydir.join('tool', 'pytest',
    567. 

  567.                                    'run-script', 'regrverbose.py')
    568. 

  568. 

  569.         regrrun = str(regr_script)
    570. 

  570.         option = self.config.option
    571. 

  571.         TIMEOUT = gettimeout(option.timeout.lower())
    572. 

  572.         if option.pypy:
    573. 

  573.             execpath = py.path.local(option.pypy)
    574. 

  574.             if not execpath.check():
    575. 

  575.                 execpath = py.path.local.sysfind(option.pypy)
    576. 

  576.             if not execpath:
    577. 

  577.                 raise LookupError("could not find executable %r" % option.pypy)
    578. 

  578. 

  579.             # check modules
    580. 

  580.             info = py.process.cmdexec("%s --info" % execpath)
    581. 

  581.             info = parse_info(info)
    582. 

  582.             for mod in regrtest.usemodules:
    583. 

  583.                 if info.get('objspace.usemodules.%s' % mod) is not True:
    584. 

  584.                     py.test.skip("%s module not included in %s" % (mod,
    585. 

  585.                                                                    execpath))
    586. 

  586. 

  587.             cmd = "%s %s %s" % (execpath, regrrun, fspath.purebasename)
    588. 

  588.             # add watchdog for timing out
    589. 

  589.             cmd = "%s %s %s %s" % (python, watchdog_script, TIMEOUT, cmd)
    590. 

  590.         else:
    591. 

  591.             pypy_options = []
    592. 

  592.             pypy_options.extend(
    593. 

  593.                 ['--withmod-%s' % mod for mod in regrtest.usemodules])
    594. 

  594.             sopt = " ".join(pypy_options)
    595. 

  595.             cmd = "%s %s %d %s -S %s %s %s -v" % (
    596. 

  596.                 python, alarm_script, TIMEOUT,
    597. 

  597.                 pypy_script, sopt,
    598. 

  598.                 regrrun, fspath.purebasename)
    599. 

  599.         return cmd
    600. 

  600. 

  601.     def runtest(self):
    602. 

  602.         """ invoke a subprocess running the test file via PyPy.
    603. 

  603.             record its output into the 'result/user@host' subdirectory.
    604. 

  604.             (we might want to create subdirectories for
    605. 

  605.             each user, because we will probably all produce
    606. 

  606.             such result runs and they will not be the same
    607. 

  607.             i am afraid.
    608. 

  608.         """
    609. 

  609.         regrtest = self.parent.regrtest
    610. 

  610.         if regrtest.skip:
    611. 

  611.             if regrtest.skip is True:
    612. 

  612.                 msg = "obsolete or unsupported platform"
    613. 

  613.             else:
    614. 

  614.                 msg = regrtest.skip
    615. 

  615.             py.test.skip(msg)
    616. 

  616.         (skipped, exit_status, test_stdout, test_stderr) = \
    617. 

  617.             self.getresult(regrtest)
    618. 

  618.         if skipped:
    619. 

  619.             py.test.skip(test_stderr.splitlines()[-1])
    620. 

  620.         if exit_status:
    621. 

  621.             raise self.ExternalFailure(test_stdout, test_stderr)
    622. 

  622. 

  623.     def repr_failure(self, excinfo):
    624. 

  624.         if not excinfo.errisinstance(self.ExternalFailure):
    625. 

  625.             return super(ReallyRunFileExternal, self).repr_failure(excinfo)
    626. 

  626.         out, err = excinfo.value.args
    627. 

  627.         return out + err
    628. 

  628. 

  629.     def getstatusouterr(self, cmd):
    630. 

  630.         tempdir = py.test.ensuretemp(self.fspath.basename)
    631. 

  631.         stdout = tempdir.join(self.fspath.basename) + '.out'
    632. 

  632.         stderr = tempdir.join(self.fspath.basename) + '.err'
    633. 

  633.         if sys.platform == 'win32':
    634. 

  634.             status = os.system("%s >%s 2>%s" % (cmd, stdout, stderr))
    635. 

  635.             if status >= 0:
    636. 

  636.                 status = status
    637. 

  637.             else:
    638. 

  638.                 status = 'abnormal termination 0x%x' % status
    639. 

  639.         else:
    640. 

  640.             if self.config.option.unittest_filter is not None:
    641. 

  641.                 cmd += ' --filter %s' % self.config.option.unittest_filter
    642. 

  642.             if self.config.option.usepdb:
    643. 

  643.                 cmd += ' --pdb'
    644. 

  644.             if self.config.option.capture == 'no':
    645. 

  645.                 status = os.system(cmd)
    646. 

  646.                 stdout.write('')
    647. 

  647.                 stderr.write('')
    648. 

  648.             else:
    649. 

  649.                 status = os.system("%s >>%s 2>>%s" % (cmd, stdout, stderr))
    650. 

  650.             if os.WIFEXITED(status):
    651. 

  651.                 status = os.WEXITSTATUS(status)
    652. 

  652.             else:
    653. 

  653.                 status = 'abnormal termination 0x%x' % status
    654. 

  654.         return status, stdout.read(mode='rU'), stderr.read(mode='rU')
    655. 

  655. 

  656.     def getresult(self, regrtest):
    657. 

  657.         cmd = self.getinvocation(regrtest)
    658. 

  658.         tempdir = py.test.ensuretemp(self.fspath.basename)
    659. 

  659.         oldcwd = tempdir.chdir()
    660. 

  660.         exit_status, test_stdout, test_stderr = self.getstatusouterr(cmd)
    661. 

  661.         oldcwd.chdir()
    662. 

  662.         skipped = False
    663. 

  663.         timedout = test_stderr.rfind(26*"=" + "timedout" + 26*"=") != -1
    664. 

  664.         if not timedout:
    665. 

  665.             timedout = test_stderr.rfind("KeyboardInterrupt") != -1
    666. 

  666.         if test_stderr.rfind(26*"=" + "skipped" + 26*"=") != -1:
    667. 

  667.             skipped = True
    668. 

  668.         if not exit_status:
    669. 

  669.             # match "FAIL" but not e.g. "FAILURE", which is in the output of a
    670. 

  670.             # test in test_zipimport_support.py
    671. 

  671.             if re.search(r'\bFAIL\b', test_stdout) or re.search('[^:]ERROR', test_stderr):
    672. 

  672.                 exit_status = 2
    673. 

  673. 

  674.         return skipped, exit_status, test_stdout, test_stderr
    675. 

  675. 

  676.     def _keywords(self):
    677. 

  677.         lst = list(py.test.collect.Item._keywords(self))
    678. 

  678.         regrtest = self.parent.regrtest
    679. 

  679.         if regrtest.core:
    680. 

  680.             lst.append('core')
    681. 

  681.         return lst
    682. 

  682.