regen docs / examples for 2.2.2

I wonder if introducing "mp" as a shortcut to monkeypatch
is a good idea, actually :)

.hgignore

@@ -13,9 +13,13 @@ syntax:glob
 *.html
 *.class
 *.orig
+*~
 
+doc/_build
 build/
 dist/
-py.egg-info
+*.egg-info
 issue/
+env/
 3rdparty/
+.tox

.hgtags

@@ -21,3 +21,28 @@ e2a60653cb490aeed81bbbd83c070b99401c211c 1.0.0b9
 60c44bdbf093285dc69d5462d4dbb4acad325ca6 1.1.0
 319187fcda66714c5eb1353492babeec3d3c826f 1.1.1
 4fc5212f7626a56b9eb6437b5c673f56dd7eb942 1.2.0
+c143a8c8840a1c68570890c8ac6165bbf92fd3c6 1.2.1
+eafd3c256e8732dfb0a4d49d051b5b4339858926 1.3.0
+d5eacf390af74553227122b85e20345d47b2f9e6 1.3.1
+d5eacf390af74553227122b85e20345d47b2f9e6 1.3.1
+8b8e7c25a13cf863f01b2dd955978285ae9daf6a 1.3.1
+3bff44b188a7ec1af328d977b9d39b6757bb38df 1.3.2
+c59d3fa8681a5b5966b8375b16fccd64a3a8dbeb 1.3.3
+79ef6377705184c55633d456832eea318fedcf61 1.3.4
+79ef6377705184c55633d456832eea318fedcf61 1.3.4
+90fffd35373e9f125af233f78b19416f0938d841 1.3.4
+e9e127acd6f0497324ef7f40cfb997cad4c4cd17 2.0.0
+e4497c2aed358c1988cf7be83ca9394c3c707fa2 2.0.1
+84e5c54b72448194a0f6f815da7e048ac8019d50 2.0.2
+2ef82d82daacb72733a3a532a95c5a37164e5819 2.0.3
+2ef82d82daacb72733a3a532a95c5a37164e5819 2.0.3
+c777dcad166548b7499564cb49ae5c8b4b07f935 2.0.3
+c777dcad166548b7499564cb49ae5c8b4b07f935 2.0.3
+49f11dbff725acdcc5fe3657cbcdf9ae04e25bbc 2.0.3
+49f11dbff725acdcc5fe3657cbcdf9ae04e25bbc 2.0.3
+363e5a5a59c803e6bc176a6f9cc4bf1a1ca2dab0 2.0.3
+e5e1746a197f0398356a43fbe2eebac9690f795d 2.1.0
+5864412c6f3c903384243bd315639d101d7ebc67 2.1.2
+12a05d59249f80276e25fd8b96e8e545b1332b7a 2.1.3
+1522710369337d96bf9568569d5f0ca9b38a74e0 2.2.0
+3da8cec6c5326ed27c144c9b6d7a64a648370005 2.2.1

AUTHORS

@@ -1,16 +1,17 @@
 Holger Krekel, holger at merlinux eu
-Guido Wesdorp, johnny at johnnydebris net 
-Samuele Pedroni, pedronis at openend se 
-Carl Friedrich Bolz, cfbolz at gmx de
-Benjamin Peterson, benjamin at python org
-Ronny Pfannschmidt, Ronny.Pfannschmidt at gmx de
-Armin Rigo, arigo at tunes org 
-Maciek Fijalkowski, fijal at genesilico pl
-Brian Dorsey, briandorsey at gmail com 
 merlinux GmbH, Germany, office at merlinux eu
 
 Contributors include:: 
 
+Ronny Pfannschmidt
+Benjamin Peterson
+Floris Bruynooghe
+Samuele Pedroni
+Carl Friedrich Bolz
+Armin Rigo
+Maciek Fijalkowski
+Guido Wesdorp
+Brian Dorsey
 Ross Lawley
 Ralf Schmitt
 Chris Lamb 
@@ -21,3 +22,4 @@ Jan Balster
 Grig Gheorghiu
 Bob Ippolito
 Christian Tismer
+Daniel Nuri

ISSUES.txt

@@ -1,150 +1,286 @@
+refine parametrize API in 2.2 series
+-------------------------------------------------------------
+tags: critical feature 2.2
 
-introduce py.test.mark.nocollect
+extend metafunc.parametrize to better support indirection
+by specifying a setupfunc(request, val) which will _substitute_
+the funcarg factory.   Here is an example:
+
+    def setupdb(request, val):
+        # setup "resource" based on test request and the values passed 
+        # in to parametrize.  setupfunc is called for each such value.
+        # you may use request.addfinalizer() or request.cached_setup ...
+        return db
+
+    @pytest.mark.parametrize("db", ["pg", "mysql"], setupfunc=setupdb)
+    def test_heavy_functional_test(db):
+        ...
+
+There would be no need to write funcarg factories for this example, only
+to explain the attributes and functionality of "request".
+
+checks / deprecations for next release
+---------------------------------------------------------------
+tags: bug 2.4 core xdist
+
+* check oejskit plugin compatibility
+* move pytest_nose out of pylib because it implicitely extends
+  the protocol now - setup/teardown is called at module level.
+  consider making calling of setup/teardown configurable
+
+optimizations 
+---------------------------------------------------------------
+tags: 2.4 core
+
+- look at ihook optimization such that all lookups for
+  hooks relating to the same fspath are cached.
+
+fix start/finish partial finailization problem
+---------------------------------------------------------------
+tags: bug core
+
+if a configure/runtest_setup/sessionstart/... hook invocation partially
+fails the sessionfinishes is not called.  Each hook implementation
+should better be repsonsible for registering a cleanup/finalizer
+appropriately to avoid this issue.  Moreover/Alternatively, we could 
+record which implementations of a hook succeeded and only call their
+teardown.
+
+do early-teardown of test modules
+-----------------------------------------
+tags: feature 2.3
+
+currently teardowns are called when the next tests is setup
+except for the function/method level where interally
+"teardown_exact" tears down immediately.  Generalize
+this to perform the "neccessary" teardown compared to
+the "next" test item during teardown - this should
+get rid of some irritations because otherwise e.g.
+prints of teardown-code appear in the setup of the next test.
+
+consider and document __init__ file usage in test directories
+---------------------------------------------------------------
+tags: bug 2.3 core
+
+Currently, a test module is imported with its fully qualified
+package path, determined by checking __init__ files upwards.
+This has the side effect that a source package at the root
+of the test dir could be imported as well.  This is somewhat
+convenient but complicates the picture for running tests against
+different versions of a package.  Also, implicit sys.path
+manipulations are problematic per-se.  Maybe factorting out
+a pytest_addsyspath hook which can be disabled from the command line
+makes sense.  In any case documentation/recommendations for
+certain scenarios makes sense.
+
+relax requirement to have tests/testing contain an __init__
+----------------------------------------------------------------
+tags: feature 2.3
+bb: http://bitbucket.org/hpk42/py-trunk/issue/64
+
+A local test run of a "tests" directory may work
+but a remote one fail because the tests directory
+does not contain an "__init__.py". Either give
+an error or make it work without the __init__.py
+i.e. port the nose-logic of unloading a test module.
+
+customize test function collection
 -------------------------------------------------------
-tags: feature 1.2
+tags: feature 2.3
 
-for not considering a function for test collection at all. 
-maybe also introduce a py.test.mark.test to explicitely
-mark a function to become a tested one.  Lookup JUnit 
-ways of tagging tests. 
+- introduce py.test.mark.nocollect for not considering a function for
+  test collection at all.  maybe also introduce a py.test.mark.test to
+  explicitely mark a function to become a tested one.  Lookup JUnit ways
+  of tagging tests.
+
+introduce pytest.mark.importorskip
+-------------------------------------------------------
+tags: feature 2.3
+
+in addition to the imperative pytest.importorskip also introduce
+a pytest.mark.importorskip so that the test count is more correct.
+
+
+introduce py.test.mark.platform
+-------------------------------------------------------
+tags: feature 2.3
+
+Introduce nice-to-spell platform-skipping, examples:
+
+    @py.test.mark.platform("python3")
+    @py.test.mark.platform("not python3")
+    @py.test.mark.platform("win32 and not python3")
+    @py.test.mark.platform("darwin")
+    @py.test.mark.platform("not (jython and win32)")
+    @py.test.mark.platform("not (jython and win32)", xfail=True)
+
+etc. Idea is to allow Python expressions which can operate
+on common spellings for operating systems and python
+interpreter versions.
+
+pytest.mark.xfail signature change
+-------------------------------------------------------
+tags: feature 2.3
+
+change to pytest.mark.xfail(reason, (optional)condition)
+to better implement the word meaning.  It also signals
+better that we always have some kind of an implementation
+reason that can be formualated.
+Compatibility? how to introduce a new name/keep compat?
 
 introduce py.test.mark registration
 -----------------------------------------
-tags: feature 1.3
+tags: feature 2.3
 
 introduce a hook that allows to register a named mark decorator
 with documentation and add "py.test --marks" to get
 a list of available marks.  Deprecate "dynamic" mark
-definitions. 
+definitions.
 
-consider introducing py.test.mark.skip_[not]win32/jython/pyXY
--------------------------------------------------------------
-tags: feature 1.3 
+allow to non-intrusively apply skipfs/xfail/marks
+---------------------------------------------------
+tags: feature 2.3
 
-conveniently introduce markers for platforms to 
-have a shorter form for skipping. 
+use case: mark a module or directory structures
+to be skipped on certain platforms (i.e. no import
+attempt will be made).
 
-generalize parametrized testing to generate combinations
--------------------------------------------------------------
-tags: feature 1.3 
+consider introducing a hook/mechanism that allows to apply marks
+from conftests or plugins.
 
-think about extending metafunc.addcall or add a new method to allow to
-generate tests with combinations of all generated versions - what to do
-about "id" and "param" in such combinations though? 
-
-introduce py.test.mark.multi 
+explicit referencing of conftest.py files
 -----------------------------------------
-tags: feature 1.3
+tags: feature 2.3
 
-introduce py.test.mark.multi to specify a number
-of values for a given function argument. 
+allow to name conftest.py files (in sub directories) that should
+be imported early, as to include command line options.
 
-introduce py.test.mark.multi 
------------------------------------------
-tags: feature 1.3
+improve central py.test ini file
+----------------------------------
+tags: feature 2.3
 
-introduce py.test.mark.multi to specify a number
-of values for a given function argument. 
+introduce more declarative configuration options:
+- (to-be-collected test directories)
+- required plugins
+- test func/class/file matching patterns
+- skip/xfail (non-intrusive)
+- pytest.ini and tox.ini and setup.cfg configuration in the same file
+
+new documentation
+----------------------------------
+tags: feature 2.3
+
+- logo py.test
+- examples for unittest or functional testing
+- resource management for functional testing
+- patterns: page object
 
 have imported module mismatch honour relative paths
 --------------------------------------------------------
-tags: bug 1.2
+tags: bug 2.3
 
-With 1.1.1 py.test fails at least on windows if an import 
-is relative and compared against an absolute conftest.py 
+With 1.1.1 py.test fails at least on windows if an import
+is relative and compared against an absolute conftest.py
 path. Normalize.
 
-make node._checkcollectable more robust
--------------------------------------------------
-tags: bug 1.2
-
-currently node._checkcollectable() can raise
-exceptions for all kinds of reasons ('conftest.py' loading
-problems, missing rsync-dirs, platform-skip-at-import-level 
-issues, ...).  It should just return True/False and cause 
-a good error message.
-
 call termination with small timeout
 -------------------------------------------------
-tags: feature 1.2
+tags: feature 2.3
 test: testing/pytest/dist/test_dsession.py - test_terminate_on_hanging_node
 
-Call gateway group termination with a small timeout if available. 
+Call gateway group termination with a small timeout if available.
 Should make dist-testing less likely to leave lost processes.
 
-have --report=xfailed[-detail] report the actual tracebacks 
-------------------------------------------------------------------
-tags: feature
-
-there is no way to induce py.test to display the full tracebacks
-of the expected failure.  Introduce one.
-
-consider globals: py.test.ensuretemp and config 
+consider globals: py.test.ensuretemp and config
 --------------------------------------------------------------
-tags: experimental-wish 1.2
+tags: experimental-wish 2.3
 
-consider deprecating py.test.ensuretemp and py.test.config 
-to further reduce py.test globality.  Also consider 
+consider deprecating py.test.ensuretemp and py.test.config
+to further reduce py.test globality.  Also consider
 having py.test.config and ensuretemp coming from
 a plugin rather than being there from the start.
 
-consider allowing funcargs to setup methods
+consider allowing funcargs for setup methods
 --------------------------------------------------------------
-tags: experimental-wish 1.2
+tags: experimental-wish 2.3
 
-Users have expressed the wish to have funcargs available to setup 
+Users have expressed the wish to have funcargs available to setup
 functions.  Experiment with allowing funcargs there - it might
 also help to make the py.test.ensuretemp and config deprecation.
+For filling funcargs for setup methods, we could call funcarg
+factories with a request object that not have a cls/function
+attributes.  However, how to handle parametrized test functions
+and funcargs?
+
+maybe introduce a setup method like:
+
+    setup_invocation(self, request)
+
+which has full access to the test invocation through "request"
+through which you can get funcargvalues, use cached_setup etc.
+Therefore, the access to funcargs would be indirect but it
+could be consistently implemented.  setup_invocation() would
+be a "glue" function for bringing together the xUnit and funcargs
+world.
 
 consider pytest_addsyspath hook
 -----------------------------------------
-tags: 1.2
+tags: 2.3
 
 py.test could call a new pytest_addsyspath() in order to systematically
 allow manipulation of sys.path and to inhibit it via --no-addsyspath
-in order to more easily run against installed packages. 
+in order to more easily run against installed packages.
 
-Alternatively it could also be done via the config object 
-and pytest_configure. 
+Alternatively it could also be done via the config object
+and pytest_configure.
 
-relax requirement to have tests/testing contain an __init__
+
+show plugin information in test header
 ----------------------------------------------------------------
-tags: feature 1.2
-bb: http://bitbucket.org/hpk42/py-trunk/issue/64
+tags: feature 2.3
 
-A local test run of a "tests" directory may work 
-but a remote one fail because the tests directory
-does not contain an "__init__.py". Either give
-an error or make it work without the __init__.py
-
-
-show plugin information in test header 
-----------------------------------------------------------------
-tags: feature 1.2
-
-Now that external plugins are becoming more numerous 
+Now that external plugins are becoming more numerous
 it would be useful to have external plugins along with
-their versions displayed as a header line. 
+their versions displayed as a header line.
 
-generate/deal with plugin docs 
+deprecate global py.test.config usage
 ----------------------------------------------------------------
-tags: feature 1.2
+tags: feature 2.3
 
-review and prepare docs for 1.2.0 release.  Probably
-have docs living with the plugin and require them to
-be available on doc generation time, at least when 
-the target is the website?  Or rather go for interactive help? 
+py.test.ensuretemp and py.test.config are probably the last
+objects containing global state.  Often using them is not
+neccessary.  This is about trying to get rid of them, i.e.
+deprecating them and checking with PyPy's usages as well
+as others.
 
-improved reporting on funcarg usage / name mismatches
-----------------------------------------------------------------
-tags: feature 1.2
-
-see to improve help and support for funcarg usage, 
-i.e. when a funcarg does not match any provided one. 
-Also consider implementing py.test --funcargs to
-show available funcargs - it should honour the 
-path::TestClass syntax so one can easily inspect
-where funcargs come from or which are available. 
+remove deprecated bits in collect.py
+-------------------------------------------------------------------
+tags: feature 2.3
 
+In an effort to further simplify code, review and remove deprecated bits
+in collect.py.  Probably good:
+- inline consider_file/dir methods, no need to have them
+  subclass-overridable because of hooks
+
+implement fslayout decorator
+---------------------------------
+tags: feature 2.3
+
+Improve the way how tests can work with pre-made examples,
+keeping the layout close to the test function:
+
+@pytest.mark.fslayout("""
+    conftest.py:
+        #  empty
+    tests/
+        test_%(NAME)s:  # becomes test_run1.py
+            def test_function(self):
+                pass
+""")
+def test_run(pytester, fslayout):
+    p = fslayout.find("test_*.py")
+    result = pytester.runpytest(p)
+    assert result.ret == 0
+    assert result.passed == 1
 
 

MANIFEST.in

@@ -2,17 +2,6 @@ include CHANGELOG
 include README.txt
 include setup.py
 include distribute_setup.py
-include LICENSE 
-include conftest.py 
+include LICENSE
 graft doc
-graft contrib
-graft bin 
 graft testing
-#exclude *.orig 
-#exclude *.rej 
-#exclude .hginore
-#exclude *.pyc
-#recursive-exclude testing *.pyc *.orig *.rej *$py.class
-#prune .pyc
-#prune .svn 
-#prune .hg 

README.txt

@@ -1,8 +1,4 @@
-The py lib is a Python development support library featuring 
-the following tools and modules:
+py.test is a simple and popular testing tool for Python.
 
-* py.test: tool for distributed automated testing
-* py.code: dynamic code generation and introspection
-* py.path:  uniform local and svn path objects 
+See http://pytest.org for more documentation.
 
-For questions and more information please visit http://pylib.org

_pytest/__init__.py

@@ -0,0 +1,2 @@
+#
+__version__ = '2.2.2'

_pytest/assertion/__init__.py

@@ -0,0 +1,119 @@
+"""
+support for presenting detailed information in failing assertions.
+"""
+import py
+import sys
+import pytest
+from _pytest.monkeypatch import monkeypatch
+from _pytest.assertion import util
+
+def pytest_addoption(parser):
+    group = parser.getgroup("debugconfig")
+    group.addoption('--assert', action="store", dest="assertmode",
+                    choices=("rewrite", "reinterp", "plain",),
+                    default="rewrite", metavar="MODE",
+                    help="""control assertion debugging tools.
+'plain' performs no assertion debugging.
+'reinterp' reinterprets assert statements after they failed to provide assertion expression information.
+'rewrite' (the default) rewrites assert statements in test modules on import
+to provide assert expression information. """)
+    group.addoption('--no-assert', action="store_true", default=False,
+        dest="noassert", help="DEPRECATED equivalent to --assert=plain")
+    group.addoption('--nomagic', action="store_true", default=False,
+        dest="nomagic", help="DEPRECATED equivalent to --assert=plain")
+
+class AssertionState:
+    """State for the assertion plugin."""
+
+    def __init__(self, config, mode):
+        self.mode = mode
+        self.trace = config.trace.root.get("assertion")
+
+def pytest_configure(config):
+    mode = config.getvalue("assertmode")
+    if config.getvalue("noassert") or config.getvalue("nomagic"):
+        mode = "plain"
+    if mode == "rewrite":
+        try:
+            import ast
+        except ImportError:
+            mode = "reinterp"
+        else:
+            if sys.platform.startswith('java'):
+                mode = "reinterp"
+    if mode != "plain":
+        _load_modules(mode)
+        m = monkeypatch()
+        config._cleanup.append(m.undo)
+        m.setattr(py.builtin.builtins, 'AssertionError',
+                  reinterpret.AssertionError)
+    hook = None
+    if mode == "rewrite":
+        hook = rewrite.AssertionRewritingHook()
+        sys.meta_path.append(hook)
+    warn_about_missing_assertion(mode)
+    config._assertstate = AssertionState(config, mode)
+    config._assertstate.hook = hook
+    config._assertstate.trace("configured with mode set to %r" % (mode,))
+
+def pytest_unconfigure(config):
+    hook = config._assertstate.hook
+    if hook is not None:
+        sys.meta_path.remove(hook)
+
+def pytest_collection(session):
+    # this hook is only called when test modules are collected
+    # so for example not in the master process of pytest-xdist
+    # (which does not collect test modules)
+    hook = session.config._assertstate.hook
+    if hook is not None:
+        hook.set_session(session)
+
+def pytest_runtest_setup(item):
+    def callbinrepr(op, left, right):
+        hook_result = item.ihook.pytest_assertrepr_compare(
+            config=item.config, op=op, left=left, right=right)
+        for new_expl in hook_result:
+            if new_expl:
+                res = '\n~'.join(new_expl)
+                if item.config.getvalue("assertmode") == "rewrite":
+                    # The result will be fed back a python % formatting
+                    # operation, which will fail if there are extraneous
+                    # '%'s in the string. Escape them here.
+                    res = res.replace("%", "%%")
+                return res
+    util._reprcompare = callbinrepr
+
+def pytest_runtest_teardown(item):
+    util._reprcompare = None
+
+def pytest_sessionfinish(session):
+    hook = session.config._assertstate.hook
+    if hook is not None:
+        hook.session = None
+
+def _load_modules(mode):
+    """Lazily import assertion related code."""
+    global rewrite, reinterpret
+    from _pytest.assertion import reinterpret
+    if mode == "rewrite":
+        from _pytest.assertion import rewrite
+
+def warn_about_missing_assertion(mode):
+    try:
+        assert False
+    except AssertionError:
+        pass
+    else:
+        if mode == "rewrite":
+            specifically = ("assertions which are not in test modules "
+                            "will be ignored")
+        else:
+            specifically = "failing tests may report as passing"
+
+        sys.stderr.write("WARNING: " + specifically +
+                        " because assert statements are not executed "
+                        "by the underlying Python interpreter "
+                        "(are you using python -O?)\n")
+
+pytest_assertrepr_compare = util.assertrepr_compare

_pytest/assertion/newinterpret.py

@@ -1,13 +1,14 @@
 """
-Like _assertion.py but using builtin AST.  It should replace _assertion.py
-eventually.
+Find intermediate evalutation results in assert statements through builtin AST.
+This should replace oldinterpret.py eventually.
 """
 
 import sys
 import ast
 
 import py
-from py._code.assertion import _format_explanation, BuiltinAssertionError
+from _pytest.assertion import util
+from _pytest.assertion.reinterpret import BuiltinAssertionError
 
 
 if sys.platform.startswith("java") and sys.version_info < (2, 5, 2):
@@ -52,28 +53,25 @@ def interpret(source, frame, should_fail=False):
     if should_fail:
         return ("(assertion failed, but when it was re-run for "
                 "printing intermediate values, it did not fail.  Suggestions: "
-                "compute assert expression before the assert or use --no-assert)")
+                "compute assert expression before the assert or use --assert=plain)")
 
 def run(offending_line, frame=None):
     if frame is None:
         frame = py.code.Frame(sys._getframe(1))
     return interpret(offending_line, frame)
 
-def getfailure(failure):
-    explanation = _format_explanation(failure.explanation)
-    value = failure.cause[1]
+def getfailure(e):
+    explanation = util.format_explanation(e.explanation)
+    value = e.cause[1]
     if str(value):
-        lines = explanation.splitlines()
-        if not lines:
-            lines.append("")
-        lines[0] += " << %s" % (value,)
-        explanation = "\n".join(lines)
-    text = "%s: %s" % (failure.cause[0].__name__, explanation)
-    if text.startswith("AssertionError: assert "):
+        lines = explanation.split('\n')
+        lines[0] += "  << %s" % (value,)
+        explanation = '\n'.join(lines)
+    text = "%s: %s" % (e.cause[0].__name__, explanation)
+    if text.startswith('AssertionError: assert '):
         text = text[16:]
     return text
 
-
 operator_map = {
     ast.BitOr : "|",
     ast.BitXor : "^",
@@ -92,6 +90,7 @@ operator_map = {
     ast.LtE : "<=",
     ast.Gt : ">",
     ast.GtE : ">=",
+    ast.Pow : "**",
     ast.Is : "is",
     ast.IsNot : "is not",
     ast.In : "in",
@@ -107,7 +106,7 @@ unary_map = {
 
 
 class DebugInterpreter(ast.NodeVisitor):
-    """Interpret AST nodes to gleam useful debugging information."""
+    """Interpret AST nodes to gleam useful debugging information. """
 
     def __init__(self, frame):
         self.frame = frame
@@ -153,18 +152,15 @@ class DebugInterpreter(ast.NodeVisitor):
             local = self.frame.eval(co)
         except Exception:
             # have to assume it isn't
-            local = False
-        if not local:
+            local = None
+        if local is None or not self.frame.is_true(local):
             return name.id, result
         return explanation, result
 
     def visit_Compare(self, comp):
         left = comp.left
         left_explanation, left_result = self.visit(left)
-        got_result = False
         for op, next_op in zip(comp.ops, comp.comparators):
-            if got_result and not result:
-                break
             next_explanation, next_result = self.visit(next_op)
             op_symbol = operator_map[op.__class__]
             explanation = "%s %s %s" % (left_explanation, op_symbol,
@@ -176,9 +172,19 @@ class DebugInterpreter(ast.NodeVisitor):
                                          __exprinfo_right=next_result)
             except Exception:
                 raise Failure(explanation)
-            else:
-                got_result = True
+            try:
+                if not self.frame.is_true(result):
+                    break
+            except KeyboardInterrupt:
+                raise
+            except:
+                break
             left_explanation, left_result = next_explanation, next_result
+
+        if util._reprcompare is not None:
+            res = util._reprcompare(op_symbol, left_result, next_result)
+            if res:
+                explanation = res
         return explanation, result
 
     def visit_BoolOp(self, boolop):
@@ -258,20 +264,9 @@ class DebugInterpreter(ast.NodeVisitor):
             result = self.frame.eval(co, **ns)
         except Exception:
             raise Failure(explanation)
-        # Only show result explanation if it's not a builtin call or returns a
-        # bool.
-        if not isinstance(call.func, ast.Name) or \
-                not self._is_builtin_name(call.func):
-            source = "isinstance(__exprinfo_value, bool)"
-            co = self._compile(source)
-            try:
-                is_bool = self.frame.eval(co, __exprinfo_value=result)
-            except Exception:
-                is_bool = False
-            if not is_bool:
-                pattern = "%s\n{%s = %s\n}"
-                rep = self.frame.repr(result)
-                explanation = pattern % (rep, rep, explanation)
+        pattern = "%s\n{%s = %s\n}"
+        rep = self.frame.repr(result)
+        explanation = pattern % (rep, rep, explanation)
         return explanation, result
 
     def _is_builtin_name(self, name):
@@ -294,6 +289,9 @@ class DebugInterpreter(ast.NodeVisitor):
             result = self.frame.eval(co, __exprinfo_expr=source_result)
         except Exception:
             raise Failure(explanation)
+        explanation = "%s\n{%s = %s.%s\n}" % (self.frame.repr(result),
+                                              self.frame.repr(result),
+                                              source_explanation, attr.attr)
         # Check if the attr is from an instance.
         source = "%r in getattr(__exprinfo_expr, '__dict__', {})"
         source = source % (attr.attr,)
@@ -301,8 +299,8 @@ class DebugInterpreter(ast.NodeVisitor):
         try:
             from_instance = self.frame.eval(co, __exprinfo_expr=source_result)
         except Exception:
-            from_instance = True
-        if from_instance:
+            from_instance = None
+        if from_instance is None or self.frame.is_true(from_instance):
             rep = self.frame.repr(result)
             pattern = "%s\n{%s = %s\n}"
             explanation = pattern % (rep, rep, explanation)
@@ -310,11 +308,8 @@ class DebugInterpreter(ast.NodeVisitor):
 
     def visit_Assert(self, assrt):
         test_explanation, test_result = self.visit(assrt.test)
-        if test_explanation.startswith("False\n{False =") and \
-                test_explanation.endswith("\n"):
-            test_explanation = test_explanation[15:-2]
         explanation = "assert %s" % (test_explanation,)
-        if not test_result:
+        if not self.frame.is_true(test_result):
             try:
                 raise BuiltinAssertionError
             except Exception:
@@ -324,10 +319,11 @@ class DebugInterpreter(ast.NodeVisitor):
     def visit_Assign(self, assign):
         value_explanation, value_result = self.visit(assign.value)
         explanation = "... = %s" % (value_explanation,)
-        name = ast.Name("__exprinfo_expr", ast.Load(), assign.value.lineno,
-                        assign.value.col_offset)
-        new_assign = ast.Assign(assign.targets, name, assign.lineno,
-                                assign.col_offset)
+        name = ast.Name("__exprinfo_expr", ast.Load(),
+                        lineno=assign.value.lineno,
+                        col_offset=assign.value.col_offset)
+        new_assign = ast.Assign(assign.targets, name, lineno=assign.lineno,
+                                col_offset=assign.col_offset)
         mod = ast.Module([new_assign])
         co = self._compile(mod, "exec")
         try:

_pytest/assertion/oldinterpret.py

@@ -1,9 +1,10 @@
 import py
 import sys, inspect
 from compiler import parse, ast, pycodegen
-from py._code.assertion import BuiltinAssertionError, _format_explanation
+from _pytest.assertion.util import format_explanation
+from _pytest.assertion.reinterpret import BuiltinAssertionError
 
-passthroughex = (KeyboardInterrupt, SystemExit, MemoryError)
+passthroughex = py.builtin._sysex
 
 class Failure:
     def __init__(self, node):
@@ -131,35 +132,35 @@ class Interpretable(View):
             raise Failure(self)
 
     def nice_explanation(self):
-        return _format_explanation(self.explanation)
+        return format_explanation(self.explanation)
 
 
 class Name(Interpretable):
     __view__ = ast.Name
 
     def is_local(self, frame):
-        co = compile('%r in locals() is not globals()' % self.name, '?', 'eval')
+        source = '%r in locals() is not globals()' % self.name
         try:
-            return frame.is_true(frame.eval(co))
+            return frame.is_true(frame.eval(source))
         except passthroughex:
             raise
         except:
             return False
 
     def is_global(self, frame):
-        co = compile('%r in globals()' % self.name, '?', 'eval')
+        source = '%r in globals()' % self.name
         try:
-            return frame.is_true(frame.eval(co))
+            return frame.is_true(frame.eval(source))
         except passthroughex:
             raise
         except:
             return False
 
     def is_builtin(self, frame):
-        co = compile('%r not in locals() and %r not in globals()' % (
-            self.name, self.name), '?', 'eval')
+        source = '%r not in locals() and %r not in globals()' % (
+            self.name, self.name)
         try:
-            return frame.is_true(frame.eval(co))
+            return frame.is_true(frame.eval(source))
         except passthroughex:
             raise
         except:
@@ -185,11 +186,11 @@ class Compare(Interpretable):
             expr2.eval(frame)
             self.explanation = "%s %s %s" % (
                 expr.explanation, operation, expr2.explanation)
-            co = compile("__exprinfo_left %s __exprinfo_right" % operation,
-                         '?', 'eval')
+            source = "__exprinfo_left %s __exprinfo_right" % operation
             try:
-                self.result = frame.eval(co, __exprinfo_left=expr.result,
-                                             __exprinfo_right=expr2.result)
+                self.result = frame.eval(source,
+                                         __exprinfo_left=expr.result,
+                                         __exprinfo_right=expr2.result)
             except passthroughex:
                 raise
             except:
@@ -235,14 +236,14 @@ for astclass, astpattern in {
     class UnaryArith(Interpretable):
         __view__ = astclass
 
-        def eval(self, frame, astpattern=astpattern,
-                              co=compile(astpattern, '?', 'eval')):
+        def eval(self, frame, astpattern=astpattern):
             expr = Interpretable(self.expr)
             expr.eval(frame)
             self.explanation = astpattern.replace('__exprinfo_expr',
                                                   expr.explanation)
             try:
-                self.result = frame.eval(co, __exprinfo_expr=expr.result)
+                self.result = frame.eval(astpattern,
+                                         __exprinfo_expr=expr.result)
             except passthroughex:
                 raise
             except:
@@ -263,8 +264,7 @@ for astclass, astpattern in {
     class BinaryArith(Interpretable):
         __view__ = astclass
 
-        def eval(self, frame, astpattern=astpattern,
-                              co=compile(astpattern, '?', 'eval')):
+        def eval(self, frame, astpattern=astpattern):
             left = Interpretable(self.left)
             left.eval(frame)
             right = Interpretable(self.right)
@@ -273,8 +273,9 @@ for astclass, astpattern in {
                                 .replace('__exprinfo_left',  left .explanation)
                                 .replace('__exprinfo_right', right.explanation))
             try:
-                self.result = frame.eval(co, __exprinfo_left=left.result,
-                                             __exprinfo_right=right.result)
+                self.result = frame.eval(astpattern,
+                                         __exprinfo_left=left.result,
+                                         __exprinfo_right=right.result)
             except passthroughex:
                 raise
             except:
@@ -287,9 +288,10 @@ class CallFunc(Interpretable):
     __view__ = ast.CallFunc
 
     def is_bool(self, frame):
-        co = compile('isinstance(__exprinfo_value, bool)', '?', 'eval')
+        source = 'isinstance(__exprinfo_value, bool)'
         try:
-            return frame.is_true(frame.eval(co, __exprinfo_value=self.result))
+            return frame.is_true(frame.eval(source,
+                                            __exprinfo_value=self.result))
         except passthroughex:
             raise
         except:
@@ -336,9 +338,8 @@ class CallFunc(Interpretable):
         if source.endswith(','):
             source = source[:-1]
         source += ')'
-        co = compile(source, '?', 'eval')
         try:
-            self.result = frame.eval(co, **vars)
+            self.result = frame.eval(source, **vars)
         except passthroughex:
             raise
         except:
@@ -353,21 +354,20 @@ class Getattr(Interpretable):
     def eval(self, frame):
         expr = Interpretable(self.expr)
         expr.eval(frame)
-        co = compile('__exprinfo_expr.%s' % self.attrname, '?', 'eval')
+        source = '__exprinfo_expr.%s' % self.attrname
         try:
-            self.result = frame.eval(co, __exprinfo_expr=expr.result)
+            self.result = frame.eval(source, __exprinfo_expr=expr.result)
         except passthroughex:
             raise
         except:
             raise Failure(self)
         self.explanation = '%s.%s' % (expr.explanation, self.attrname)
         # if the attribute comes from the instance, its value is interesting
-        co = compile('hasattr(__exprinfo_expr, "__dict__") and '
-                     '%r in __exprinfo_expr.__dict__' % self.attrname,
-                     '?', 'eval')
+        source = ('hasattr(__exprinfo_expr, "__dict__") and '
+                  '%r in __exprinfo_expr.__dict__' % self.attrname)
         try:
             from_instance = frame.is_true(
-                frame.eval(co, __exprinfo_expr=expr.result))
+                frame.eval(source, __exprinfo_expr=expr.result))
         except passthroughex:
             raise
         except:
@@ -384,10 +384,6 @@ class Assert(Interpretable):
     def run(self, frame):
         test = Interpretable(self.test)
         test.eval(frame)
-        # simplify 'assert False where False = ...'
-        if (test.explanation.startswith('False\n{False = ') and
-            test.explanation.endswith('\n}')):
-            test.explanation = test.explanation[15:-2]
         # print the result as  'assert <explanation>'
         self.result = test.result
         self.explanation = 'assert ' + test.explanation
@@ -447,7 +443,6 @@ def report_failure(e):
 
 def check(s, frame=None):
     if frame is None:
-        import sys
         frame = sys._getframe(1)
         frame = py.code.Frame(frame)
     expr = parse(s, 'eval')
@@ -487,7 +482,7 @@ def interpret(source, frame, should_fail=False):
     if should_fail:
         return ("(assertion failed, but when it was re-run for "
                 "printing intermediate values, it did not fail.  Suggestions: "
-                "compute assert expression before the assert or use --nomagic)")
+                "compute assert expression before the assert or use --assert=plain)")
     else:
         return None
 
@@ -498,7 +493,7 @@ def getmsg(excinfo):
     #frame = py.code.Frame(frame)
     #return interpret(line, frame)
 
-    tb = excinfo.traceback[-1] 
+    tb = excinfo.traceback[-1]
     source = str(tb.statement).strip()
     x = interpret(source, tb.frame, should_fail=True)
     if not isinstance(x, str):
@@ -518,7 +513,6 @@ def getfailure(e):
 
 def run(s, frame=None):
     if frame is None:
-        import sys
         frame = sys._getframe(1)
         frame = py.code.Frame(frame)
     module = Interpretable(parse(s, 'exec').node)

_pytest/assertion/reinterpret.py

@@ -0,0 +1,48 @@
+import sys
+import py
+
+BuiltinAssertionError = py.builtin.builtins.AssertionError
+
+class AssertionError(BuiltinAssertionError):
+    def __init__(self, *args):
+        BuiltinAssertionError.__init__(self, *args)
+        if args:
+            try:
+                self.msg = str(args[0])
+            except py.builtin._sysex:
+                raise
+            except:
+                self.msg = "<[broken __repr__] %s at %0xd>" %(
+                    args[0].__class__, id(args[0]))
+        else:
+            f = py.code.Frame(sys._getframe(1))
+            try:
+                source = f.code.fullsource
+                if source is not None:
+                    try:
+                        source = source.getstatement(f.lineno, assertion=True)
+                    except IndexError:
+                        source = None
+                    else:
+                        source = str(source.deindent()).strip()
+            except py.error.ENOENT:
+                source = None
+                # this can also occur during reinterpretation, when the
+                # co_filename is set to "<run>".
+            if source:
+                self.msg = reinterpret(source, f, should_fail=True)
+            else:
+                self.msg = "<could not determine information>"
+            if not self.args:
+                self.args = (self.msg,)
+
+if sys.version_info > (3, 0):
+    AssertionError.__module__ = "builtins"
+    reinterpret_old = "old reinterpretation not available for py3"
+else:
+    from _pytest.assertion.oldinterpret import interpret as reinterpret_old
+if sys.version_info >= (2, 6) or (sys.platform.startswith("java")):
+    from _pytest.assertion.newinterpret import interpret as reinterpret
+else:
+    reinterpret = reinterpret_old
+

_pytest/assertion/rewrite.py

@@ -0,0 +1,598 @@
+"""Rewrite assertion AST to produce nice error messages"""
+
+import ast
+import collections
+import errno
+import itertools
+import imp
+import marshal
+import os
+import struct
+import sys
+import types
+
+import py
+from _pytest.assertion import util
+
+
+# Windows gives ENOENT in places *nix gives ENOTDIR.
+if sys.platform.startswith("win"):
+    PATH_COMPONENT_NOT_DIR = errno.ENOENT
+else:
+    PATH_COMPONENT_NOT_DIR = errno.ENOTDIR
+
+# py.test caches rewritten pycs in __pycache__.
+if hasattr(imp, "get_tag"):
+    PYTEST_TAG = imp.get_tag() + "-PYTEST"
+else:
+    if hasattr(sys, "pypy_version_info"):
+        impl = "pypy"
+    elif sys.platform == "java":
+        impl = "jython"
+    else:
+        impl = "cpython"
+    ver = sys.version_info
+    PYTEST_TAG = "%s-%s%s-PYTEST" % (impl, ver[0], ver[1])
+    del ver, impl
+
+PYC_EXT = ".py" + "c" if __debug__ else "o"
+PYC_TAIL = "." + PYTEST_TAG + PYC_EXT
+
+REWRITE_NEWLINES = sys.version_info[:2] != (2, 7) and sys.version_info < (3, 2)
+
+class AssertionRewritingHook(object):
+    """Import hook which rewrites asserts."""
+
+    def __init__(self):
+        self.session = None
+        self.modules = {}
+
+    def set_session(self, session):
+        self.fnpats = session.config.getini("python_files")
+        self.session = session
+
+    def find_module(self, name, path=None):
+        if self.session is None:
+            return None
+        sess = self.session
+        state = sess.config._assertstate
+        state.trace("find_module called for: %s" % name)
+        names = name.rsplit(".", 1)
+        lastname = names[-1]
+        pth = None
+        if path is not None and len(path) == 1:
+            pth = path[0]
+        if pth is None:
+            try:
+                fd, fn, desc = imp.find_module(lastname, path)
+            except ImportError:
+                return None
+            if fd is not None:
+                fd.close()
+            tp = desc[2]
+            if tp == imp.PY_COMPILED:
+                if hasattr(imp, "source_from_cache"):
+                    fn = imp.source_from_cache(fn)
+                else:
+                    fn = fn[:-1]
+            elif tp != imp.PY_SOURCE:
+                # Don't know what this is.
+                return None
+        else:
+            fn = os.path.join(pth, name.rpartition(".")[2] + ".py")
+        fn_pypath = py.path.local(fn)
+        # Is this a test file?
+        if not sess.isinitpath(fn):
+            # We have to be very careful here because imports in this code can
+            # trigger a cycle.
+            self.session = None
+            try:
+                for pat in self.fnpats:
+                    if fn_pypath.fnmatch(pat):
+                        state.trace("matched test file %r" % (fn,))
+                        break
+                else:
+                    return None
+            finally:
+                self.session = sess
+        else:
+            state.trace("matched test file (was specified on cmdline): %r" % (fn,))
+        # The requested module looks like a test file, so rewrite it. This is
+        # the most magical part of the process: load the source, rewrite the
+        # asserts, and load the rewritten source. We also cache the rewritten
+        # module code in a special pyc. We must be aware of the possibility of
+        # concurrent py.test processes rewriting and loading pycs. To avoid
+        # tricky race conditions, we maintain the following invariant: The
+        # cached pyc is always a complete, valid pyc. Operations on it must be
+        # atomic. POSIX's atomic rename comes in handy.
+        write = not sys.dont_write_bytecode
+        cache_dir = os.path.join(fn_pypath.dirname, "__pycache__")
+        if write:
+            try:
+                os.mkdir(cache_dir)
+            except OSError:
+                e = sys.exc_info()[1].errno
+                if e == errno.EEXIST:
+                    # Either the __pycache__ directory already exists (the
+                    # common case) or it's blocked by a non-dir node. In the
+                    # latter case, we'll ignore it in _write_pyc.
+                    pass
+                elif e == PATH_COMPONENT_NOT_DIR:
+                    # One of the path components was not a directory, likely
+                    # because we're in a zip file.
+                    write = False
+                elif e == errno.EACCES:
+                    state.trace("read only directory: %r" % (fn_pypath.dirname,))
+                    write = False
+                else:
+                    raise
+        cache_name = fn_pypath.basename[:-3] + PYC_TAIL
+        pyc = os.path.join(cache_dir, cache_name)
+        # Notice that even if we're in a read-only directory, I'm going to check
+        # for a cached pyc. This may not be optimal...
+        co = _read_pyc(fn_pypath, pyc)
+        if co is None:
+            state.trace("rewriting %r" % (fn,))
+            co = _rewrite_test(state, fn_pypath)
+            if co is None:
+                # Probably a SyntaxError in the test.
+                return None
+            if write:
+                _make_rewritten_pyc(state, fn_pypath, pyc, co)
+        else:
+            state.trace("found cached rewritten pyc for %r" % (fn,))
+        self.modules[name] = co, pyc
+        return self
+
+    def load_module(self, name):
+        co, pyc = self.modules.pop(name)
+        # I wish I could just call imp.load_compiled here, but __file__ has to
+        # be set properly. In Python 3.2+, this all would be handled correctly
+        # by load_compiled.
+        mod = sys.modules[name] = imp.new_module(name)
+        try:
+            mod.__file__ = co.co_filename
+            # Normally, this attribute is 3.2+.
+            mod.__cached__ = pyc
+            py.builtin.exec_(co, mod.__dict__)
+        except:
+            del sys.modules[name]
+            raise
+        return sys.modules[name]
+
+def _write_pyc(co, source_path, pyc):
+    # Technically, we don't have to have the same pyc format as (C)Python, since
+    # these "pycs" should never be seen by builtin import. However, there's
+    # little reason deviate, and I hope sometime to be able to use
+    # imp.load_compiled to load them. (See the comment in load_module above.)
+    mtime = int(source_path.mtime())
+    try:
+        fp = open(pyc, "wb")
+    except IOError:
+        err = sys.exc_info()[1].errno
+        if err == PATH_COMPONENT_NOT_DIR:
+            # This happens when we get a EEXIST in find_module creating the
+            # __pycache__ directory and __pycache__ is by some non-dir node.
+            return False
+        raise
+    try:
+        fp.write(imp.get_magic())
+        fp.write(struct.pack("<l", mtime))
+        marshal.dump(co, fp)
+    finally:
+        fp.close()
+    return True
+
+RN = "\r\n".encode("utf-8")
+N = "\n".encode("utf-8")
+
+def _rewrite_test(state, fn):
+    """Try to read and rewrite *fn* and return the code object."""
+    try:
+        source = fn.read("rb")
+    except EnvironmentError:
+        return None
+    # On Python versions which are not 2.7 and less than or equal to 3.1, the
+    # parser expects *nix newlines.
+    if REWRITE_NEWLINES:
+        source = source.replace(RN, N) + N
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        # Let this pop up again in the real import.
+        state.trace("failed to parse: %r" % (fn,))
+        return None
+    rewrite_asserts(tree)
+    try:
+        co = compile(tree, fn.strpath, "exec")
+    except SyntaxError:
+        # It's possible that this error is from some bug in the
+        # assertion rewriting, but I don't know of a fast way to tell.
+        state.trace("failed to compile: %r" % (fn,))
+        return None
+    return co
+
+def _make_rewritten_pyc(state, fn, pyc, co):
+    """Try to dump rewritten code to *pyc*."""
+    if sys.platform.startswith("win"):
+        # Windows grants exclusive access to open files and doesn't have atomic
+        # rename, so just write into the final file.
+        _write_pyc(co, fn, pyc)
+    else:
+        # When not on windows, assume rename is atomic. Dump the code object
+        # into a file specific to this process and atomically replace it.
+        proc_pyc = pyc + "." + str(os.getpid())
+        if _write_pyc(co, fn, proc_pyc):
+            os.rename(proc_pyc, pyc)
+
+def _read_pyc(source, pyc):
+    """Possibly read a py.test pyc containing rewritten code.
+
+    Return rewritten code if successful or None if not.
+    """
+    try:
+        fp = open(pyc, "rb")
+    except IOError:
+        return None
+    try:
+        try:
+            mtime = int(source.mtime())
+            data = fp.read(8)
+        except EnvironmentError:
+            return None
+        # Check for invalid or out of date pyc file.
+        if (len(data) != 8 or
+            data[:4] != imp.get_magic() or
+            struct.unpack("<l", data[4:])[0] != mtime):
+            return None
+        co = marshal.load(fp)
+        if not isinstance(co, types.CodeType):
+            # That's interesting....
+            return None
+        return co
+    finally:
+        fp.close()
+
+
+def rewrite_asserts(mod):
+    """Rewrite the assert statements in mod."""
+    AssertionRewriter().run(mod)
+
+
+_saferepr = py.io.saferepr
+from _pytest.assertion.util import format_explanation as _format_explanation
+
+def _format_boolop(explanations, is_or):
+    return "(" + (is_or and " or " or " and ").join(explanations) + ")"
+
+def _call_reprcompare(ops, results, expls, each_obj):
+    for i, res, expl in zip(range(len(ops)), results, expls):
+        try:
+            done = not res
+        except Exception:
+            done = True
+        if done:
+            break
+    if util._reprcompare is not None:
+        custom = util._reprcompare(ops[i], each_obj[i], each_obj[i + 1])
+        if custom is not None:
+            return custom
+    return expl
+
+
+unary_map = {
+    ast.Not : "not %s",
+    ast.Invert : "~%s",
+    ast.USub : "-%s",
+    ast.UAdd : "+%s"
+}
+
+binop_map = {
+    ast.BitOr : "|",
+    ast.BitXor : "^",
+    ast.BitAnd : "&",
+    ast.LShift : "<<",
+    ast.RShift : ">>",
+    ast.Add : "+",
+    ast.Sub : "-",
+    ast.Mult : "*",
+    ast.Div : "/",
+    ast.FloorDiv : "//",
+    ast.Mod : "%",
+    ast.Eq : "==",
+    ast.NotEq : "!=",
+    ast.Lt : "<",
+    ast.LtE : "<=",
+    ast.Gt : ">",
+    ast.GtE : ">=",
+    ast.Pow : "**",
+    ast.Is : "is",
+    ast.IsNot : "is not",
+    ast.In : "in",
+    ast.NotIn : "not in"
+}
+
+
+def set_location(node, lineno, col_offset):
+    """Set node location information recursively."""
+    def _fix(node, lineno, col_offset):
+        if "lineno" in node._attributes:
+            node.lineno = lineno
+        if "col_offset" in node._attributes:
+            node.col_offset = col_offset
+        for child in ast.iter_child_nodes(node):
+            _fix(child, lineno, col_offset)
+    _fix(node, lineno, col_offset)
+    return node
+
+
+class AssertionRewriter(ast.NodeVisitor):
+
+    def run(self, mod):
+        """Find all assert statements in *mod* and rewrite them."""
+        if not mod.body:
+            # Nothing to do.
+            return
+        # Insert some special imports at the top of the module but after any
+        # docstrings and __future__ imports.
+        aliases = [ast.alias(py.builtin.builtins.__name__, "@py_builtins"),
+                   ast.alias("_pytest.assertion.rewrite", "@pytest_ar")]
+        expect_docstring = True
+        pos = 0
+        lineno = 0
+        for item in mod.body:
+            if (expect_docstring and isinstance(item, ast.Expr) and
+                isinstance(item.value, ast.Str)):
+                doc = item.value.s
+                if "PYTEST_DONT_REWRITE" in doc:
+                    # The module has disabled assertion rewriting.
+                    return
+                lineno += len(doc) - 1
+                expect_docstring = False
+            elif (not isinstance(item, ast.ImportFrom) or item.level > 0 or
+                  item.module != "__future__"):
+                lineno = item.lineno
+                break
+            pos += 1
+        imports = [ast.Import([alias], lineno=lineno, col_offset=0)
+                   for alias in aliases]
+        mod.body[pos:pos] = imports
+        # Collect asserts.
+        nodes = [mod]
+        while nodes:
+            node = nodes.pop()
+            for name, field in ast.iter_fields(node):
+                if isinstance(field, list):
+                    new = []
+                    for i, child in enumerate(field):
+                        if isinstance(child, ast.Assert):
+                            # Transform assert.
+                            new.extend(self.visit(child))
+                        else:
+                            new.append(child)
+                            if isinstance(child, ast.AST):
+                                nodes.append(child)
+                    setattr(node, name, new)
+                elif (isinstance(field, ast.AST) and
+                      # Don't recurse into expressions as they can't contain
+                      # asserts.
+                      not isinstance(field, ast.expr)):
+                    nodes.append(field)
+
+    def variable(self):
+        """Get a new variable."""
+        # Use a character invalid in python identifiers to avoid clashing.
+        name = "@py_assert" + str(next(self.variable_counter))
+        self.variables.append(name)
+        return name
+
+    def assign(self, expr):
+        """Give *expr* a name."""
+        name = self.variable()
+        self.statements.append(ast.Assign([ast.Name(name, ast.Store())], expr))
+        return ast.Name(name, ast.Load())
+
+    def display(self, expr):
+        """Call py.io.saferepr on the expression."""
+        return self.helper("saferepr", expr)
+
+    def helper(self, name, *args):
+        """Call a helper in this module."""
+        py_name = ast.Name("@pytest_ar", ast.Load())
+        attr = ast.Attribute(py_name, "_" + name, ast.Load())
+        return ast.Call(attr, list(args), [], None, None)
+
+    def builtin(self, name):
+        """Return the builtin called *name*."""
+        builtin_name = ast.Name("@py_builtins", ast.Load())
+        return ast.Attribute(builtin_name, name, ast.Load())
+
+    def explanation_param(self, expr):
+        specifier = "py" + str(next(self.variable_counter))
+        self.explanation_specifiers[specifier] = expr
+        return "%(" + specifier + ")s"
+
+    def push_format_context(self):
+        self.explanation_specifiers = {}
+        self.stack.append(self.explanation_specifiers)
+
+    def pop_format_context(self, expl_expr):
+        current = self.stack.pop()
+        if self.stack:
+            self.explanation_specifiers = self.stack[-1]
+        keys = [ast.Str(key) for key in current.keys()]
+        format_dict = ast.Dict(keys, list(current.values()))
+        form = ast.BinOp(expl_expr, ast.Mod(), format_dict)
+        name = "@py_format" + str(next(self.variable_counter))
+        self.on_failure.append(ast.Assign([ast.Name(name, ast.Store())], form))
+        return ast.Name(name, ast.Load())
+
+    def generic_visit(self, node):
+        """Handle expressions we don't have custom code for."""
+        assert isinstance(node, ast.expr)
+        res = self.assign(node)
+        return res, self.explanation_param(self.display(res))
+
+    def visit_Assert(self, assert_):
+        if assert_.msg:
+            # There's already a message. Don't mess with it.
+            return [assert_]
+        self.statements = []
+        self.cond_chain = ()
+        self.variables = []
+        self.variable_counter = itertools.count()
+        self.stack = []
+        self.on_failure = []
+        self.push_format_context()
+        # Rewrite assert into a bunch of statements.
+        top_condition, explanation = self.visit(assert_.test)
+        # Create failure message.
+        body = self.on_failure
+        negation = ast.UnaryOp(ast.Not(), top_condition)
+        self.statements.append(ast.If(negation, body, []))
+        explanation = "assert " + explanation
+        template = ast.Str(explanation)
+        msg = self.pop_format_context(template)
+        fmt = self.helper("format_explanation", msg)
+        err_name = ast.Name("AssertionError", ast.Load())
+        exc = ast.Call(err_name, [fmt], [], None, None)
+        if sys.version_info[0] >= 3:
+            raise_ = ast.Raise(exc, None)
+        else:
+            raise_ = ast.Raise(exc, None, None)
+        body.append(raise_)
+        # Clear temporary variables by setting them to None.
+        if self.variables:
+            variables = [ast.Name(name, ast.Store()) for name in self.variables]
+            clear = ast.Assign(variables, ast.Name("None", ast.Load()))
+            self.statements.append(clear)
+        # Fix line numbers.
+        for stmt in self.statements:
+            set_location(stmt, assert_.lineno, assert_.col_offset)
+        return self.statements
+
+    def visit_Name(self, name):
+        # Check if the name is local or not.
+        locs = ast.Call(self.builtin("locals"), [], [], None, None)
+        globs = ast.Call(self.builtin("globals"), [], [], None, None)
+        ops = [ast.In(), ast.IsNot()]
+        test = ast.Compare(ast.Str(name.id), ops, [locs, globs])
+        expr = ast.IfExp(test, self.display(name), ast.Str(name.id))
+        return name, self.explanation_param(expr)
+
+    def visit_BoolOp(self, boolop):
+        res_var = self.variable()
+        expl_list = self.assign(ast.List([], ast.Load()))
+        app = ast.Attribute(expl_list, "append", ast.Load())
+        is_or = int(isinstance(boolop.op, ast.Or))
+        body = save = self.statements
+        fail_save = self.on_failure
+        levels = len(boolop.values) - 1
+        self.push_format_context()
+        # Process each operand, short-circuting if needed.
+        for i, v in enumerate(boolop.values):
+            if i:
+                fail_inner = []
+                self.on_failure.append(ast.If(cond, fail_inner, []))
+                self.on_failure = fail_inner
+            self.push_format_context()
+            res, expl = self.visit(v)
+            body.append(ast.Assign([ast.Name(res_var, ast.Store())], res))
+            expl_format = self.pop_format_context(ast.Str(expl))
+            call = ast.Call(app, [expl_format], [], None, None)
+            self.on_failure.append(ast.Expr(call))
+            if i < levels:
+                cond = res
+                if is_or:
+                    cond = ast.UnaryOp(ast.Not(), cond)
+                inner = []
+                self.statements.append(ast.If(cond, inner, []))
+                self.statements = body = inner
+        self.statements = save
+        self.on_failure = fail_save
+        expl_template = self.helper("format_boolop", expl_list, ast.Num(is_or))
+        expl = self.pop_format_context(expl_template)
+        return ast.Name(res_var, ast.Load()), self.explanation_param(expl)
+
+    def visit_UnaryOp(self, unary):
+        pattern = unary_map[unary.op.__class__]
+        operand_res, operand_expl = self.visit(unary.operand)
+        res = self.assign(ast.UnaryOp(unary.op, operand_res))
+        return res, pattern % (operand_expl,)
+
+    def visit_BinOp(self, binop):
+        symbol = binop_map[binop.op.__class__]
+        left_expr, left_expl = self.visit(binop.left)
+        right_expr, right_expl = self.visit(binop.right)
+        explanation = "(%s %s %s)" % (left_expl, symbol, right_expl)
+        res = self.assign(ast.BinOp(left_expr, binop.op, right_expr))
+        return res, explanation
+
+    def visit_Call(self, call):
+        new_func, func_expl = self.visit(call.func)
+        arg_expls = []
+        new_args = []
+        new_kwargs = []
+        new_star = new_kwarg = None
+        for arg in call.args:
+            res, expl = self.visit(arg)
+            new_args.append(res)
+            arg_expls.append(expl)
+        for keyword in call.keywords:
+            res, expl = self.visit(keyword.value)
+            new_kwargs.append(ast.keyword(keyword.arg, res))
+            arg_expls.append(keyword.arg + "=" + expl)
+        if call.starargs:
+            new_star, expl = self.visit(call.starargs)
+            arg_expls.append("*" + expl)
+        if call.kwargs:
+            new_kwarg, expl = self.visit(call.kwargs)
+            arg_expls.append("**" + expl)
+        expl = "%s(%s)" % (func_expl, ', '.join(arg_expls))
+        new_call = ast.Call(new_func, new_args, new_kwargs, new_star, new_kwarg)
+        res = self.assign(new_call)
+        res_expl = self.explanation_param(self.display(res))
+        outer_expl = "%s\n{%s = %s\n}" % (res_expl, res_expl, expl)
+        return res, outer_expl
+
+    def visit_Attribute(self, attr):
+        if not isinstance(attr.ctx, ast.Load):
+            return self.generic_visit(attr)
+        value, value_expl = self.visit(attr.value)
+        res = self.assign(ast.Attribute(value, attr.attr, ast.Load()))
+        res_expl = self.explanation_param(self.display(res))
+        pat = "%s\n{%s = %s.%s\n}"
+        expl = pat % (res_expl, res_expl, value_expl, attr.attr)
+        return res, expl
+
+    def visit_Compare(self, comp):
+        self.push_format_context()
+        left_res, left_expl = self.visit(comp.left)
+        res_variables = [self.variable() for i in range(len(comp.ops))]
+        load_names = [ast.Name(v, ast.Load()) for v in res_variables]
+        store_names = [ast.Name(v, ast.Store()) for v in res_variables]
+        it = zip(range(len(comp.ops)), comp.ops, comp.comparators)
+        expls = []
+        syms = []
+        results = [left_res]
+        for i, op, next_operand in it:
+            next_res, next_expl = self.visit(next_operand)
+            results.append(next_res)
+            sym = binop_map[op.__class__]
+            syms.append(ast.Str(sym))
+            expl = "%s %s %s" % (left_expl, sym, next_expl)
+            expls.append(ast.Str(expl))
+            res_expr = ast.Compare(left_res, [op], [next_res])
+            self.statements.append(ast.Assign([store_names[i]], res_expr))
+            left_res, left_expl = next_res, next_expl
+        # Use py.code._reprcompare if that's available.
+        expl_call = self.helper("call_reprcompare",
+                                ast.Tuple(syms, ast.Load()),
+                                ast.Tuple(load_names, ast.Load()),
+                                ast.Tuple(expls, ast.Load()),
+                                ast.Tuple(results, ast.Load()))
+        if len(comp.ops) > 1:
+            res = ast.BoolOp(ast.And(), load_names)
+        else:
+            res = load_names[0]
+        return res, self.explanation_param(self.pop_format_context(expl_call))

_pytest/assertion/util.py

@@ -0,0 +1,213 @@
+"""Utilities for assertion debugging"""
+
+import py
+
+
+# The _reprcompare attribute on the util module is used by the new assertion
+# interpretation code and assertion rewriter to detect this plugin was
+# loaded and in turn call the hooks defined here as part of the
+# DebugInterpreter.
+_reprcompare = None
+
+def format_explanation(explanation):
+    """This formats an explanation
+
+    Normally all embedded newlines are escaped, however there are
+    three exceptions: \n{, \n} and \n~.  The first two are intended
+    cover nested explanations, see function and attribute explanations
+    for examples (.visit_Call(), visit_Attribute()).  The last one is
+    for when one explanation needs to span multiple lines, e.g. when
+    displaying diffs.
+    """
+    # simplify 'assert False where False = ...'
+    where = 0
+    while True:
+        start = where = explanation.find("False\n{False = ", where)
+        if where == -1:
+            break
+        level = 0
+        for i, c in enumerate(explanation[start:]):
+            if c == "{":
+                level += 1
+            elif c == "}":
+                level -= 1
+                if not level:
+                    break
+        else:
+            raise AssertionError("unbalanced braces: %r" % (explanation,))
+        end = start + i
+        where = end
+        if explanation[end - 1] == '\n':
+            explanation = (explanation[:start] + explanation[start+15:end-1] +
+                           explanation[end+1:])
+            where -= 17
+    raw_lines = (explanation or '').split('\n')
+    # escape newlines not followed by {, } and ~
+    lines = [raw_lines[0]]
+    for l in raw_lines[1:]:
+        if l.startswith('{') or l.startswith('}') or l.startswith('~'):
+            lines.append(l)
+        else:
+            lines[-1] += '\\n' + l
+
+    result = lines[:1]
+    stack = [0]
+    stackcnt = [0]
+    for line in lines[1:]:
+        if line.startswith('{'):
+            if stackcnt[-1]:
+                s = 'and   '
+            else:
+                s = 'where '
+            stack.append(len(result))
+            stackcnt[-1] += 1
+            stackcnt.append(0)
+            result.append(' +' + '  '*(len(stack)-1) + s + line[1:])
+        elif line.startswith('}'):
+            assert line.startswith('}')
+            stack.pop()
+            stackcnt.pop()
+            result[stack[-1]] += line[1:]
+        else:
+            assert line.startswith('~')
+            result.append('  '*len(stack) + line[1:])
+    assert len(stack) == 1
+    return '\n'.join(result)
+
+
+# Provide basestring in python3
+try:
+    basestring = basestring
+except NameError:
+    basestring = str
+
+
+def assertrepr_compare(op, left, right):
+    """return specialised explanations for some operators/operands"""
+    width = 80 - 15 - len(op) - 2 # 15 chars indentation, 1 space around op
+    left_repr = py.io.saferepr(left, maxsize=int(width/2))
+    right_repr = py.io.saferepr(right, maxsize=width-len(left_repr))
+    summary = '%s %s %s' % (left_repr, op, right_repr)
+
+    issequence = lambda x: isinstance(x, (list, tuple))
+    istext = lambda x: isinstance(x, basestring)
+    isdict = lambda x: isinstance(x, dict)
+    isset = lambda x: isinstance(x, set)
+
+    explanation = None
+    try:
+        if op == '==':
+            if istext(left) and istext(right):
+                explanation = _diff_text(left, right)
+            elif issequence(left) and issequence(right):
+                explanation = _compare_eq_sequence(left, right)
+            elif isset(left) and isset(right):
+                explanation = _compare_eq_set(left, right)
+            elif isdict(left) and isdict(right):
+                explanation = _diff_text(py.std.pprint.pformat(left),
+                                         py.std.pprint.pformat(right))
+        elif op == 'not in':
+            if istext(left) and istext(right):
+                explanation = _notin_text(left, right)
+    except py.builtin._sysex:
+        raise
+    except:
+        excinfo = py.code.ExceptionInfo()
+        explanation = ['(pytest_assertion plugin: representation of '
+            'details failed. Probably an object has a faulty __repr__.)',
+            str(excinfo)
+            ]
+
+
+    if not explanation:
+        return None
+
+    # Don't include pageloads of data, should be configurable
+    if len(''.join(explanation)) > 80*8:
+        explanation = ['Detailed information too verbose, truncated']
+
+    return [summary] + explanation
+
+
+def _diff_text(left, right):
+    """Return the explanation for the diff between text
+
+    This will skip leading and trailing characters which are
+    identical to keep the diff minimal.
+    """
+    explanation = []
+    i = 0 # just in case left or right has zero length
+    for i in range(min(len(left), len(right))):
+        if left[i] != right[i]:
+            break
+    if i > 42:
+        i -= 10                 # Provide some context
+        explanation = ['Skipping %s identical '
+                       'leading characters in diff' % i]
+        left = left[i:]
+        right = right[i:]
+    if len(left) == len(right):
+        for i in range(len(left)):
+            if left[-i] != right[-i]:
+                break
+        if i > 42:
+            i -= 10     # Provide some context
+            explanation += ['Skipping %s identical '
+                            'trailing characters in diff' % i]
+            left = left[:-i]
+            right = right[:-i]
+    explanation += [line.strip('\n')
+                    for line in py.std.difflib.ndiff(left.splitlines(),
+                                                     right.splitlines())]
+    return explanation
+
+
+def _compare_eq_sequence(left, right):
+    explanation = []
+    for i in range(min(len(left), len(right))):
+        if left[i] != right[i]:
+            explanation += ['At index %s diff: %r != %r' %
+                            (i, left[i], right[i])]
+            break
+    if len(left) > len(right):
+        explanation += ['Left contains more items, '
+            'first extra item: %s' % py.io.saferepr(left[len(right)],)]
+    elif len(left) < len(right):
+        explanation += ['Right contains more items, '
+            'first extra item: %s' % py.io.saferepr(right[len(left)],)]
+    return explanation # + _diff_text(py.std.pprint.pformat(left),
+                       #             py.std.pprint.pformat(right))
+
+
+def _compare_eq_set(left, right):
+    explanation = []
+    diff_left = left - right
+    diff_right = right - left
+    if diff_left:
+        explanation.append('Extra items in the left set:')
+        for item in diff_left:
+            explanation.append(py.io.saferepr(item))
+    if diff_right:
+        explanation.append('Extra items in the right set:')
+        for item in diff_right:
+            explanation.append(py.io.saferepr(item))
+    return explanation
+
+
+def _notin_text(term, text):
+    index = text.find(term)
+    head = text[:index]
+    tail = text[index+len(term):]
+    correct_text = head + tail
+    diff = _diff_text(correct_text, text)
+    newdiff = ['%s is contained here:' % py.io.saferepr(term, maxsize=42)]
+    for line in diff:
+        if line.startswith('Skipping'):
+            continue
+        if line.startswith('- '):
+            continue
+        if line.startswith('+ '):
+            newdiff.append('  ' + line[2:])
+        else:
+            newdiff.append(line)
+    return newdiff

_pytest/capture.py

@@ -0,0 +1,214 @@
+""" per-test stdout/stderr capturing mechanisms, ``capsys`` and ``capfd`` function arguments.  """
+
+import pytest, py
+import os
+
+def pytest_addoption(parser):
+    group = parser.getgroup("general")
+    group._addoption('--capture', action="store", default=None,
+        metavar="method", type="choice", choices=['fd', 'sys', 'no'],
+        help="per-test capturing method: one of fd (default)|sys|no.")
+    group._addoption('-s', action="store_const", const="no", dest="capture",
+        help="shortcut for --capture=no.")
+
+@pytest.mark.tryfirst
+def pytest_cmdline_parse(pluginmanager, args):
+    # we want to perform capturing already for plugin/conftest loading
+    if '-s' in args or "--capture=no" in args:
+        method = "no"
+    elif hasattr(os, 'dup') and '--capture=sys' not in args:
+        method = "fd"
+    else:
+        method = "sys"
+    capman = CaptureManager(method)
+    pluginmanager.register(capman, "capturemanager")
+
+def addouterr(rep, outerr):
+    for secname, content in zip(["out", "err"], outerr):
+        if content:
+            rep.sections.append(("Captured std%s" % secname, content))
+
+class NoCapture:
+    def startall(self):
+        pass
+    def resume(self):
+        pass
+    def reset(self):
+        pass
+    def suspend(self):
+        return "", ""
+
+class CaptureManager:
+    def __init__(self, defaultmethod=None):
+        self._method2capture = {}
+        self._defaultmethod = defaultmethod
+
+    def _maketempfile(self):
+        f = py.std.tempfile.TemporaryFile()
+        newf = py.io.dupfile(f, encoding="UTF-8")
+        f.close()
+        return newf
+
+    def _makestringio(self):
+        return py.io.TextIO()
+
+    def _getcapture(self, method):
+        if method == "fd":
+            return py.io.StdCaptureFD(now=False,
+                out=self._maketempfile(), err=self._maketempfile()
+            )
+        elif method == "sys":
+            return py.io.StdCapture(now=False,
+                out=self._makestringio(), err=self._makestringio()
+            )
+        elif method == "no":
+            return NoCapture()
+        else:
+            raise ValueError("unknown capturing method: %r" % method)
+
+    def _getmethod(self, config, fspath):
+        if config.option.capture:
+            method = config.option.capture
+        else:
+            try:
+                method = config._conftest.rget("option_capture", path=fspath)
+            except KeyError:
+                method = "fd"
+        if method == "fd" and not hasattr(os, 'dup'): # e.g. jython
+            method = "sys"
+        return method
+
+    def reset_capturings(self):
+        for name, cap in self._method2capture.items():
+            cap.reset()
+
+    def resumecapture_item(self, item):
+        method = self._getmethod(item.config, item.fspath)
+        if not hasattr(item, 'outerr'):
+            item.outerr = ('', '') # we accumulate outerr on the item
+        return self.resumecapture(method)
+
+    def resumecapture(self, method=None):
+        if hasattr(self, '_capturing'):
+            raise ValueError("cannot resume, already capturing with %r" %
+                (self._capturing,))
+        if method is None:
+            method = self._defaultmethod
+        cap = self._method2capture.get(method)
+        self._capturing = method
+        if cap is None:
+            self._method2capture[method] = cap = self._getcapture(method)
+            cap.startall()
+        else:
+            cap.resume()
+
+    def suspendcapture(self, item=None):
+        self.deactivate_funcargs()
+        if hasattr(self, '_capturing'):
+            method = self._capturing
+            cap = self._method2capture.get(method)
+            if cap is not None:
+                outerr = cap.suspend()
+            del self._capturing
+            if item:
+                outerr = (item.outerr[0] + outerr[0],
+                          item.outerr[1] + outerr[1])
+            return outerr
+        if hasattr(item, 'outerr'):
+            return item.outerr
+        return "", ""
+
+    def activate_funcargs(self, pyfuncitem):
+        if not hasattr(pyfuncitem, 'funcargs'):
+            return
+        assert not hasattr(self, '_capturing_funcargs')
+        self._capturing_funcargs = capturing_funcargs = []
+        for name, capfuncarg in pyfuncitem.funcargs.items():
+            if name in ('capsys', 'capfd'):
+                capturing_funcargs.append(capfuncarg)
+                capfuncarg._start()
+
+    def deactivate_funcargs(self):
+        capturing_funcargs = getattr(self, '_capturing_funcargs', None)
+        if capturing_funcargs is not None:
+            while capturing_funcargs:
+                capfuncarg = capturing_funcargs.pop()
+                capfuncarg._finalize()
+            del self._capturing_funcargs
+
+    def pytest_make_collect_report(self, __multicall__, collector):
+        method = self._getmethod(collector.config, collector.fspath)
+        try:
+            self.resumecapture(method)
+        except ValueError:
+            return # recursive collect, XXX refactor capturing
+                   # to allow for more lightweight recursive capturing
+        try:
+            rep = __multicall__.execute()
+        finally:
+            outerr = self.suspendcapture()
+        addouterr(rep, outerr)
+        return rep
+
+    @pytest.mark.tryfirst
+    def pytest_runtest_setup(self, item):
+        self.resumecapture_item(item)
+
+    @pytest.mark.tryfirst
+    def pytest_runtest_call(self, item):
+        self.resumecapture_item(item)
+        self.activate_funcargs(item)
+
+    @pytest.mark.tryfirst
+    def pytest_runtest_teardown(self, item):
+        self.resumecapture_item(item)
+
+    def pytest_keyboard_interrupt(self, excinfo):
+        if hasattr(self, '_capturing'):
+            self.suspendcapture()
+
+    @pytest.mark.tryfirst
+    def pytest_runtest_makereport(self, __multicall__, item, call):
+        self.deactivate_funcargs()
+        rep = __multicall__.execute()
+        outerr = self.suspendcapture(item)
+        if not rep.passed:
+            addouterr(rep, outerr)
+        if not rep.passed or rep.when == "teardown":
+            outerr = ('', '')
+        item.outerr = outerr
+        return rep
+
+def pytest_funcarg__capsys(request):
+    """enables capturing of writes to sys.stdout/sys.stderr and makes
+    captured output available via ``capsys.readouterr()`` method calls
+    which return a ``(out, err)`` tuple.
+    """
+    return CaptureFuncarg(py.io.StdCapture)
+
+def pytest_funcarg__capfd(request):
+    """enables capturing of writes to file descriptors 1 and 2 and makes
+    captured output available via ``capsys.readouterr()`` method calls
+    which return a ``(out, err)`` tuple.
+    """
+    if not hasattr(os, 'dup'):
+        py.test.skip("capfd funcarg needs os.dup")
+    return CaptureFuncarg(py.io.StdCaptureFD)
+
+class CaptureFuncarg:
+    def __init__(self, captureclass):
+        self.capture = captureclass(now=False)
+
+    def _start(self):
+        self.capture.startall()
+
+    def _finalize(self):
+        if hasattr(self, 'capture'):
+            self.capture.reset()
+            del self.capture
+
+    def readouterr(self):
+        return self.capture.readouterr()
+
+    def close(self):
+        self._finalize()

_pytest/config.py

@@ -0,0 +1,463 @@
+""" command line options, ini-file and conftest.py processing. """
+
+import py
+import sys, os
+from _pytest.core import PluginManager
+import pytest
+
+def pytest_cmdline_parse(pluginmanager, args):
+    config = Config(pluginmanager)
+    config.parse(args)
+    return config
+
+def pytest_unconfigure(config):
+    while 1:
+        try:
+            fin = config._cleanup.pop()
+        except IndexError:
+            break
+        fin()
+
+class Parser:
+    """ Parser for command line arguments. """
+
+    def __init__(self, usage=None, processopt=None):
+        self._anonymous = OptionGroup("custom options", parser=self)
+        self._groups = []
+        self._processopt = processopt
+        self._usage = usage
+        self._inidict = {}
+        self._ininames = []
+        self.hints = []
+
+    def processoption(self, option):
+        if self._processopt:
+            if option.dest:
+                self._processopt(option)
+
+    def addnote(self, note):
+        self._notes.append(note)
+
+    def getgroup(self, name, description="", after=None):
+        """ get (or create) a named option Group.
+
+        :name: unique name of the option group.
+        :description: long description for --help output.
+        :after: name of other group, used for ordering --help output.
+        """
+        for group in self._groups:
+            if group.name == name:
+                return group
+        group = OptionGroup(name, description, parser=self)
+        i = 0
+        for i, grp in enumerate(self._groups):
+            if grp.name == after:
+                break
+        self._groups.insert(i+1, group)
+        return group
+
+    def addoption(self, *opts, **attrs):
+        """ add an optparse-style option. """
+        self._anonymous.addoption(*opts, **attrs)
+
+    def parse(self, args):
+        self.optparser = optparser = MyOptionParser(self)
+        groups = self._groups + [self._anonymous]
+        for group in groups:
+            if group.options:
+                desc = group.description or group.name
+                optgroup = py.std.optparse.OptionGroup(optparser, desc)
+                optgroup.add_options(group.options)
+                optparser.add_option_group(optgroup)
+        return self.optparser.parse_args([str(x) for x in args])
+
+    def parse_setoption(self, args, option):
+        parsedoption, args = self.parse(args)
+        for name, value in parsedoption.__dict__.items():
+            setattr(option, name, value)
+        return args
+
+    def addini(self, name, help, type=None, default=None):
+        """ add an ini-file option with the given name and description. """
+        assert type in (None, "pathlist", "args", "linelist")
+        self._inidict[name] = (help, type, default)
+        self._ininames.append(name)
+
+
+class OptionGroup:
+    def __init__(self, name, description="", parser=None):
+        self.name = name
+        self.description = description
+        self.options = []
+        self.parser = parser
+
+    def addoption(self, *optnames, **attrs):
+        """ add an option to this group. """
+        option = py.std.optparse.Option(*optnames, **attrs)
+        self._addoption_instance(option, shortupper=False)
+
+    def _addoption(self, *optnames, **attrs):
+        option = py.std.optparse.Option(*optnames, **attrs)
+        self._addoption_instance(option, shortupper=True)
+
+    def _addoption_instance(self, option, shortupper=False):
+        if not shortupper:
+            for opt in option._short_opts:
+                if opt[0] == '-' and opt[1].islower():
+                    raise ValueError("lowercase shortoptions reserved")
+        if self.parser:
+            self.parser.processoption(option)
+        self.options.append(option)
+
+
+class MyOptionParser(py.std.optparse.OptionParser):
+    def __init__(self, parser):
+        self._parser = parser
+        py.std.optparse.OptionParser.__init__(self, usage=parser._usage,
+            add_help_option=False)
+    def format_epilog(self, formatter):
+        hints = self._parser.hints
+        if hints:
+            s = "\n".join(["hint: " + x for x in hints]) + "\n"
+            s = "\n" + s + "\n"
+            return s
+        return ""
+
+class Conftest(object):
+    """ the single place for accessing values and interacting
+        towards conftest modules from py.test objects.
+    """
+    def __init__(self, onimport=None, confcutdir=None):
+        self._path2confmods = {}
+        self._onimport = onimport
+        self._conftestpath2mod = {}
+        self._confcutdir = confcutdir
+
+    def setinitial(self, args):
+        """ try to find a first anchor path for looking up global values
+            from conftests. This function is usually called _before_
+            argument parsing.  conftest files may add command line options
+            and we thus have no completely safe way of determining
+            which parts of the arguments are actually related to options
+            and which are file system paths.  We just try here to get
+            bootstrapped ...
+        """
+        current = py.path.local()
+        opt = '--confcutdir'
+        for i in range(len(args)):
+            opt1 = str(args[i])
+            if opt1.startswith(opt):
+                if opt1 == opt:
+                    if len(args) > i:
+                        p = current.join(args[i+1], abs=True)
+                elif opt1.startswith(opt + "="):
+                    p = current.join(opt1[len(opt)+1:], abs=1)
+                self._confcutdir = p
+                break
+        for arg in args + [current]:
+            if hasattr(arg, 'startswith') and arg.startswith("--"):
+                continue
+            anchor = current.join(arg, abs=1)
+            if anchor.check(): # we found some file object
+                self._path2confmods[None] = self.getconftestmodules(anchor)
+                # let's also consider test* dirs
+                if anchor.check(dir=1):
+                    for x in anchor.listdir("test*"):
+                        if x.check(dir=1):
+                            self.getconftestmodules(x)
+                break
+        else:
+            assert 0, "no root of filesystem?"
+
+    def getconftestmodules(self, path):
+        """ return a list of imported conftest modules for the given path.  """
+        try:
+            clist = self._path2confmods[path]
+        except KeyError:
+            if path is None:
+                raise ValueError("missing default confest.")
+            dp = path.dirpath()
+            clist = []
+            if dp != path:
+                cutdir = self._confcutdir
+                if cutdir and path != cutdir and not path.relto(cutdir):
+                    pass
+                else:
+                    conftestpath = path.join("conftest.py")
+                    if conftestpath.check(file=1):
+                        clist.append(self.importconftest(conftestpath))
+                clist[:0] = self.getconftestmodules(dp)
+            self._path2confmods[path] = clist
+        # be defensive: avoid changes from caller side to
+        # affect us by always returning a copy of the actual list
+        return clist[:]
+
+    def rget(self, name, path=None):
+        mod, value = self.rget_with_confmod(name, path)
+        return value
+
+    def rget_with_confmod(self, name, path=None):
+        modules = self.getconftestmodules(path)
+        modules.reverse()
+        for mod in modules:
+            try:
+                return mod, getattr(mod, name)
+            except AttributeError:
+                continue
+        raise KeyError(name)
+
+    def importconftest(self, conftestpath):
+        assert conftestpath.check(), conftestpath
+        try:
+            return self._conftestpath2mod[conftestpath]
+        except KeyError:
+            pkgpath = conftestpath.pypkgpath()
+            if pkgpath is None:
+                _ensure_removed_sysmodule(conftestpath.purebasename)
+            self._conftestpath2mod[conftestpath] = mod = conftestpath.pyimport()
+            dirpath = conftestpath.dirpath()
+            if dirpath in self._path2confmods:
+                for path, mods in self._path2confmods.items():
+                    if path and path.relto(dirpath) or path == dirpath:
+                        assert mod not in mods
+                        mods.append(mod)
+            self._postimport(mod)
+            return mod
+
+    def _postimport(self, mod):
+        if self._onimport:
+            self._onimport(mod)
+        return mod
+
+def _ensure_removed_sysmodule(modname):
+    try:
+        del sys.modules[modname]
+    except KeyError:
+        pass
+
+class CmdOptions(object):
+    """ holds cmdline options as attributes."""
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+    def __repr__(self):
+        return "<CmdOptions %r>" %(self.__dict__,)
+
+class Config(object):
+    """ access to configuration values, pluginmanager and plugin hooks.  """
+    def __init__(self, pluginmanager=None):
+        #: command line option values, usually added via parser.addoption(...)
+        #: or parser.getgroup(...).addoption(...) calls
+        self.option = CmdOptions()
+        self._parser = Parser(
+            usage="usage: %prog [options] [file_or_dir] [file_or_dir] [...]",
+            processopt=self._processopt,
+        )
+        #: a pluginmanager instance
+        self.pluginmanager = pluginmanager or PluginManager(load=True)
+        self.trace = self.pluginmanager.trace.root.get("config")
+        self._conftest = Conftest(onimport=self._onimportconftest)
+        self.hook = self.pluginmanager.hook
+        self._inicache = {}
+        self._cleanup = []
+
+    @classmethod
+    def fromdictargs(cls, option_dict, args):
+        """ constructor useable for subprocesses. """
+        config = cls()
+        # XXX slightly crude way to initialize capturing
+        import _pytest.capture
+        _pytest.capture.pytest_cmdline_parse(config.pluginmanager, args)
+        config._preparse(args, addopts=False)
+        config.option.__dict__.update(option_dict)
+        for x in config.option.plugins:
+            config.pluginmanager.consider_pluginarg(x)
+        return config
+
+    def _onimportconftest(self, conftestmodule):
+        self.trace("loaded conftestmodule %r" %(conftestmodule,))
+        self.pluginmanager.consider_conftest(conftestmodule)
+
+    def _processopt(self, opt):
+        if hasattr(opt, 'default') and opt.dest:
+            if not hasattr(self.option, opt.dest):
+                setattr(self.option, opt.dest, opt.default)
+
+    def _getmatchingplugins(self, fspath):
+        allconftests = self._conftest._conftestpath2mod.values()
+        plugins = [x for x in self.pluginmanager.getplugins()
+                        if x not in allconftests]
+        plugins += self._conftest.getconftestmodules(fspath)
+        return plugins
+
+    def _setinitialconftest(self, args):
+        # capture output during conftest init (#issue93)
+        # XXX introduce load_conftest hook to avoid needing to know
+        # about capturing plugin here
+        capman = self.pluginmanager.getplugin("capturemanager")
+        capman.resumecapture()
+        try:
+            try:
+                self._conftest.setinitial(args)
+            finally:
+                out, err = capman.suspendcapture() # logging might have got it
+        except:
+            sys.stdout.write(out)
+            sys.stderr.write(err)
+            raise
+
+    def _initini(self, args):
+        self.inicfg = getcfg(args, ["pytest.ini", "tox.ini", "setup.cfg"])
+        self._parser.addini('addopts', 'extra command line options', 'args')
+        self._parser.addini('minversion', 'minimally required pytest version')
+
+    def _preparse(self, args, addopts=True):
+        self._initini(args)
+        if addopts:
+            args[:] = self.getini("addopts") + args
+        self._checkversion()
+        self.pluginmanager.consider_preparse(args)
+        self.pluginmanager.consider_setuptools_entrypoints()
+        self.pluginmanager.consider_env()
+        self._setinitialconftest(args)
+        self.pluginmanager.do_addoption(self._parser)
+        if addopts:
+            self.hook.pytest_cmdline_preparse(config=self, args=args)
+
+    def _checkversion(self):
+        minver = self.inicfg.get('minversion', None)
+        if minver:
+            ver = minver.split(".")
+            myver = pytest.__version__.split(".")
+            if myver < ver:
+                raise pytest.UsageError(
+                    "%s:%d: requires pytest-%s, actual pytest-%s'" %(
+                    self.inicfg.config.path, self.inicfg.lineof('minversion'),
+                    minver, pytest.__version__))
+
+    def parse(self, args):
+        # parse given cmdline arguments into this config object.
+        # Note that this can only be called once per testing process.
+        assert not hasattr(self, 'args'), (
+                "can only parse cmdline args at most once per Config object")
+        self._origargs = args
+        self._preparse(args)
+        self._parser.hints.extend(self.pluginmanager._hints)
+        args = self._parser.parse_setoption(args, self.option)
+        if not args:
+            args.append(py.std.os.getcwd())
+        self.args = args
+
+    def addinivalue_line(self, name, line):
+        """ add a line to an ini-file option. The option must have been
+        declared but might not yet be set in which case the line becomes the
+        the first line in its value. """
+        x = self.getini(name)
+        assert isinstance(x, list)
+        x.append(line) # modifies the cached list inline
+
+    def getini(self, name):
+        """ return configuration value from an ini file. If the
+        specified name hasn't been registered through a prior ``parse.addini``
+        call (usually from a plugin), a ValueError is raised. """
+        try:
+            return self._inicache[name]
+        except KeyError:
+            self._inicache[name] = val = self._getini(name)
+            return val
+
+    def _getini(self, name):
+        try:
+            description, type, default = self._parser._inidict[name]
+        except KeyError:
+            raise ValueError("unknown configuration value: %r" %(name,))
+        try:
+            value = self.inicfg[name]
+        except KeyError:
+            if default is not None:
+                return default
+            if type is None:
+                return ''
+            return []
+        if type == "pathlist":
+            dp = py.path.local(self.inicfg.config.path).dirpath()
+            l = []
+            for relpath in py.std.shlex.split(value):
+                l.append(dp.join(relpath, abs=True))
+            return l
+        elif type == "args":
+            return py.std.shlex.split(value)
+        elif type == "linelist":
+            return [t for t in map(lambda x: x.strip(), value.split("\n")) if t]
+        else:
+            assert type is None
+            return value
+
+    def _getconftest_pathlist(self, name, path=None):
+        try:
+            mod, relroots = self._conftest.rget_with_confmod(name, path)
+        except KeyError:
+            return None
+        modpath = py.path.local(mod.__file__).dirpath()
+        l = []
+        for relroot in relroots:
+            if not isinstance(relroot, py.path.local):
+                relroot = relroot.replace("/", py.path.local.sep)
+                relroot = modpath.join(relroot, abs=True)
+            l.append(relroot)
+        return l
+
+    def _getconftest(self, name, path=None, check=False):
+        if check:
+            self._checkconftest(name)
+        return self._conftest.rget(name, path)
+
+    def getvalue(self, name, path=None):
+        """ return ``name`` value looked set from command line options.
+
+        (deprecated) if we can't find the option also lookup
+        the name in a matching conftest file.
+        """
+        try:
+            return getattr(self.option, name)
+        except AttributeError:
+            return self._getconftest(name, path, check=False)
+
+    def getvalueorskip(self, name, path=None):
+        """ (deprecated) return getvalue(name) or call
+        py.test.skip if no value exists. """
+        __tracebackhide__ = True
+        try:
+            val = self.getvalue(name, path)
+            if val is None:
+                raise KeyError(name)
+            return val
+        except KeyError:
+            py.test.skip("no %r value found" %(name,))
+
+
+def getcfg(args, inibasenames):
+    args = [x for x in args if not str(x).startswith("-")]
+    if not args:
+        args = [py.path.local()]
+    for arg in args:
+        arg = py.path.local(arg)
+        for base in arg.parts(reverse=True):
+            for inibasename in inibasenames:
+                p = base.join(inibasename)
+                if p.check():
+                    iniconfig = py.iniconfig.IniConfig(p)
+                    if 'pytest' in iniconfig.sections:
+                        return iniconfig['pytest']
+    return {}
+
+def findupwards(current, basename):
+    current = py.path.local(current)
+    while 1:
+        p = current.join(basename)
+        if p.check():
+            return p
+        p = current.dirpath()
+        if p == current:
+            return
+        current = p
+

_pytest/core.py

@@ -0,0 +1,477 @@
+"""
+pytest PluginManager, basic initialization and tracing.
+(c) Holger Krekel 2004-2010
+"""
+import sys, os
+import inspect
+import py
+from _pytest import hookspec # the extension point definitions
+
+assert py.__version__.split(".")[:2] >= ['1', '4'], ("installation problem: "
+    "%s is too old, remove or upgrade 'py'" % (py.__version__))
+
+default_plugins = (
+ "config mark main terminal runner python pdb unittest capture skipping "
+ "tmpdir monkeypatch recwarn pastebin helpconfig nose assertion genscript "
+ "junitxml resultlog doctest").split()
+
+class TagTracer:
+    def __init__(self):
+        self._tag2proc = {}
+        self.writer = None
+        self.indent = 0
+
+    def get(self, name):
+        return TagTracerSub(self, (name,))
+
+    def processmessage(self, tags, args):
+        if self.writer is not None:
+            if args:
+                indent = "  " * self.indent
+                content = " ".join(map(str, args))
+                self.writer("%s%s [%s]\n" %(indent, content, ":".join(tags)))
+        try:
+            self._tag2proc[tags](tags, args)
+        except KeyError:
+            pass
+
+    def setwriter(self, writer):
+        self.writer = writer
+
+    def setprocessor(self, tags, processor):
+        if isinstance(tags, str):
+            tags = tuple(tags.split(":"))
+        else:
+            assert isinstance(tags, tuple)
+        self._tag2proc[tags] = processor
+
+class TagTracerSub:
+    def __init__(self, root, tags):
+        self.root = root
+        self.tags = tags
+    def __call__(self, *args):
+        self.root.processmessage(self.tags, args)
+    def setmyprocessor(self, processor):
+        self.root.setprocessor(self.tags, processor)
+    def get(self, name):
+        return self.__class__(self.root, self.tags + (name,))
+
+class PluginManager(object):
+    def __init__(self, load=False):
+        self._name2plugin = {}
+        self._listattrcache = {}
+        self._plugins = []
+        self._hints = []
+        self.trace = TagTracer().get("pluginmanage")
+        self._plugin_distinfo = []
+        if os.environ.get('PYTEST_DEBUG'):
+            err = sys.stderr
+            encoding = getattr(err, 'encoding', 'utf8')
+            try:
+                err = py.io.dupfile(err, encoding=encoding)
+            except Exception:
+                pass
+            self.trace.root.setwriter(err.write)
+        self.hook = HookRelay([hookspec], pm=self)
+        self.register(self)
+        if load:
+            for spec in default_plugins:
+                self.import_plugin(spec)
+
+    def register(self, plugin, name=None, prepend=False):
+        assert not self.isregistered(plugin), plugin
+        name = name or getattr(plugin, '__name__', str(id(plugin)))
+        if name in self._name2plugin:
+            return False
+        #self.trace("registering", name, plugin)
+        self._name2plugin[name] = plugin
+        self.call_plugin(plugin, "pytest_addhooks", {'pluginmanager': self})
+        self.hook.pytest_plugin_registered(manager=self, plugin=plugin)
+        if not prepend:
+            self._plugins.append(plugin)
+        else:
+            self._plugins.insert(0, plugin)
+        return True
+
+    def unregister(self, plugin=None, name=None):
+        if plugin is None:
+            plugin = self.getplugin(name=name)
+        self._plugins.remove(plugin)
+        self.hook.pytest_plugin_unregistered(plugin=plugin)
+        for name, value in list(self._name2plugin.items()):
+            if value == plugin:
+                del self._name2plugin[name]
+
+    def isregistered(self, plugin, name=None):
+        if self.getplugin(name) is not None:
+            return True
+        for val in self._name2plugin.values():
+            if plugin == val:
+                return True
+
+    def addhooks(self, spec):
+        self.hook._addhooks(spec, prefix="pytest_")
+
+    def getplugins(self):
+        return list(self._plugins)
+
+    def skipifmissing(self, name):
+        if not self.hasplugin(name):
+            py.test.skip("plugin %r is missing" % name)
+
+    def hasplugin(self, name):
+        return bool(self.getplugin(name))
+
+    def getplugin(self, name):
+        if name is None:
+            return None
+        try:
+            return self._name2plugin[name]
+        except KeyError:
+            return self._name2plugin.get("_pytest." + name, None)
+
+    # API for bootstrapping
+    #
+    def _envlist(self, varname):
+        val = py.std.os.environ.get(varname, None)
+        if val is not None:
+            return val.split(',')
+        return ()
+
+    def consider_env(self):
+        for spec in self._envlist("PYTEST_PLUGINS"):
+            self.import_plugin(spec)
+
+    def consider_setuptools_entrypoints(self):
+        try:
+            from pkg_resources import iter_entry_points, DistributionNotFound
+        except ImportError:
+            return # XXX issue a warning
+        for ep in iter_entry_points('pytest11'):
+            name = ep.name
+            if name.startswith("pytest_"):
+                name = name[7:]
+            if ep.name in self._name2plugin or name in self._name2plugin:
+                continue
+            try:
+                plugin = ep.load()
+            except DistributionNotFound:
+                continue
+            self._plugin_distinfo.append((ep.dist, plugin))
+            self.register(plugin, name=name)
+
+    def consider_preparse(self, args):
+        for opt1,opt2 in zip(args, args[1:]):
+            if opt1 == "-p":
+                self.consider_pluginarg(opt2)
+
+    def consider_pluginarg(self, arg):
+        if arg.startswith("no:"):
+            name = arg[3:]
+            if self.getplugin(name) is not None:
+                self.unregister(None, name=name)
+            self._name2plugin[name] = -1
+        else:
+            if self.getplugin(arg) is None:
+                self.import_plugin(arg)
+
+    def consider_conftest(self, conftestmodule):
+        if self.register(conftestmodule, name=conftestmodule.__file__):
+            self.consider_module(conftestmodule)
+
+    def consider_module(self, mod):
+        attr = getattr(mod, "pytest_plugins", ())
+        if attr:
+            if not isinstance(attr, (list, tuple)):
+                attr = (attr,)
+            for spec in attr:
+                self.import_plugin(spec)
+
+    def import_plugin(self, modname):
+        assert isinstance(modname, str)
+        if self.getplugin(modname) is not None:
+            return
+        try:
+            #self.trace("importing", modname)
+            mod = importplugin(modname)
+        except KeyboardInterrupt:
+            raise
+        except ImportError:
+            if modname.startswith("pytest_"):
+                return self.import_plugin(modname[7:])
+            raise
+        except:
+            e = py.std.sys.exc_info()[1]
+            if not hasattr(py.test, 'skip'):
+                raise
+            elif not isinstance(e, py.test.skip.Exception):
+                raise
+            self._hints.append("skipped plugin %r: %s" %((modname, e.msg)))
+        else:
+            self.register(mod, modname)
+            self.consider_module(mod)
+
+    def pytest_configure(self, config):
+        config.addinivalue_line("markers",
+            "tryfirst: mark a hook implementation function such that the "
+            "plugin machinery will try to call it first/as early as possible.")
+        config.addinivalue_line("markers",
+            "trylast: mark a hook implementation function such that the "
+            "plugin machinery will try to call it last/as late as possible.")
+
+    def pytest_plugin_registered(self, plugin):
+        import pytest
+        dic = self.call_plugin(plugin, "pytest_namespace", {}) or {}
+        if dic:
+            self._setns(pytest, dic)
+        if hasattr(self, '_config'):
+            self.call_plugin(plugin, "pytest_addoption",
+                {'parser': self._config._parser})
+            self.call_plugin(plugin, "pytest_configure",
+                {'config': self._config})
+
+    def _setns(self, obj, dic):
+        import pytest
+        for name, value in dic.items():
+            if isinstance(value, dict):
+                mod = getattr(obj, name, None)
+                if mod is None:
+                    modname = "pytest.%s" % name
+                    mod = py.std.types.ModuleType(modname)
+                    sys.modules[modname] = mod
+                    mod.__all__ = []
+                    setattr(obj, name, mod)
+                obj.__all__.append(name)
+                self._setns(mod, value)
+            else:
+                setattr(obj, name, value)
+                obj.__all__.append(name)
+                #if obj != pytest:
+                #    pytest.__all__.append(name)
+                setattr(pytest, name, value)
+
+    def pytest_terminal_summary(self, terminalreporter):
+        tw = terminalreporter._tw
+        if terminalreporter.config.option.traceconfig:
+            for hint in self._hints:
+                tw.line("hint: %s" % hint)
+
+    def do_addoption(self, parser):
+        mname = "pytest_addoption"
+        methods = reversed(self.listattr(mname))
+        MultiCall(methods, {'parser': parser}).execute()
+
+    def do_configure(self, config):
+        assert not hasattr(self, '_config')
+        self._config = config
+        config.hook.pytest_configure(config=self._config)
+
+    def do_unconfigure(self, config):
+        config = self._config
+        del self._config
+        config.hook.pytest_unconfigure(config=config)
+        config.pluginmanager.unregister(self)
+
+    def notify_exception(self, excinfo, option=None):
+        if option and option.fulltrace:
+            style = "long"
+        else:
+            style = "native"
+        excrepr = excinfo.getrepr(funcargs=True,
+            showlocals=getattr(option, 'showlocals', False),
+            style=style,
+        )
+        res = self.hook.pytest_internalerror(excrepr=excrepr)
+        if not py.builtin.any(res):
+            for line in str(excrepr).split("\n"):
+                sys.stderr.write("INTERNALERROR> %s\n" %line)
+                sys.stderr.flush()
+
+    def listattr(self, attrname, plugins=None):
+        if plugins is None:
+            plugins = self._plugins
+        key = (attrname,) + tuple(plugins)
+        try:
+            return list(self._listattrcache[key])
+        except KeyError:
+            pass
+        l = []
+        last = []
+        for plugin in plugins:
+            try:
+                meth = getattr(plugin, attrname)
+                if hasattr(meth, 'tryfirst'):
+                    last.append(meth)
+                elif hasattr(meth, 'trylast'):
+                    l.insert(0, meth)
+                else:
+                    l.append(meth)
+            except AttributeError:
+                continue
+        l.extend(last)
+        self._listattrcache[key] = list(l)
+        return l
+
+    def call_plugin(self, plugin, methname, kwargs):
+        return MultiCall(methods=self.listattr(methname, plugins=[plugin]),
+                kwargs=kwargs, firstresult=True).execute()
+
+
+def importplugin(importspec):
+    name = importspec
+    try:
+        mod = "_pytest." + name
+        return __import__(mod, None, None, '__doc__')
+    except ImportError:
+        #e = py.std.sys.exc_info()[1]
+        #if str(e).find(name) == -1:
+        #    raise
+        pass #
+    return __import__(importspec, None, None, '__doc__')
+
+class MultiCall:
+    """ execute a call into multiple python functions/methods. """
+    def __init__(self, methods, kwargs, firstresult=False):
+        self.methods = list(methods)
+        self.kwargs = kwargs
+        self.results = []
+        self.firstresult = firstresult
+
+    def __repr__(self):
+        status = "%d results, %d meths" % (len(self.results), len(self.methods))
+        return "<MultiCall %s, kwargs=%r>" %(status, self.kwargs)
+
+    def execute(self):
+        while self.methods:
+            method = self.methods.pop()
+            kwargs = self.getkwargs(method)
+            res = method(**kwargs)
+            if res is not None:
+                self.results.append(res)
+                if self.firstresult:
+                    return res
+        if not self.firstresult:
+            return self.results
+
+    def getkwargs(self, method):
+        kwargs = {}
+        for argname in varnames(method):
+            try:
+                kwargs[argname] = self.kwargs[argname]
+            except KeyError:
+                if argname == "__multicall__":
+                    kwargs[argname] = self
+        return kwargs
+
+def varnames(func):
+    try:
+        return func._varnames
+    except AttributeError:
+        pass
+    if not inspect.isfunction(func) and not inspect.ismethod(func):
+        func = getattr(func, '__call__', func)
+    ismethod = inspect.ismethod(func)
+    rawcode = py.code.getrawcode(func)
+    try:
+        x = rawcode.co_varnames[ismethod:rawcode.co_argcount]
+    except AttributeError:
+        x = ()
+    py.builtin._getfuncdict(func)['_varnames'] = x
+    return x
+
+class HookRelay:
+    def __init__(self, hookspecs, pm, prefix="pytest_"):
+        if not isinstance(hookspecs, list):
+            hookspecs = [hookspecs]
+        self._hookspecs = []
+        self._pm = pm
+        self.trace = pm.trace.root.get("hook")
+        for hookspec in hookspecs:
+            self._addhooks(hookspec, prefix)
+
+    def _addhooks(self, hookspecs, prefix):
+        self._hookspecs.append(hookspecs)
+        added = False
+        for name, method in vars(hookspecs).items():
+            if name.startswith(prefix):
+                firstresult = getattr(method, 'firstresult', False)
+                hc = HookCaller(self, name, firstresult=firstresult)
+                setattr(self, name, hc)
+                added = True
+                #print ("setting new hook", name)
+        if not added:
+            raise ValueError("did not find new %r hooks in %r" %(
+                prefix, hookspecs,))
+
+
+class HookCaller:
+    def __init__(self, hookrelay, name, firstresult):
+        self.hookrelay = hookrelay
+        self.name = name
+        self.firstresult = firstresult
+        self.trace = self.hookrelay.trace
+
+    def __repr__(self):
+        return "<HookCaller %r>" %(self.name,)
+
+    def __call__(self, **kwargs):
+        methods = self.hookrelay._pm.listattr(self.name)
+        return self._docall(methods, kwargs)
+
+    def pcall(self, plugins, **kwargs):
+        methods = self.hookrelay._pm.listattr(self.name, plugins=plugins)
+        return self._docall(methods, kwargs)
+
+    def _docall(self, methods, kwargs):
+        self.trace(self.name, kwargs)
+        self.trace.root.indent += 1
+        mc = MultiCall(methods, kwargs, firstresult=self.firstresult)
+        try:
+            res = mc.execute()
+            if res:
+                self.trace("finish", self.name, "-->", res)
+        finally:
+            self.trace.root.indent -= 1
+        return res
+
+_preinit = []
+
+def _preloadplugins():
+    _preinit.append(PluginManager(load=True))
+
+def _prepareconfig(args=None, plugins=None):
+    if args is None:
+        args = sys.argv[1:]
+    elif isinstance(args, py.path.local):
+        args = [str(args)]
+    elif not isinstance(args, (tuple, list)):
+        if not isinstance(args, str):
+            raise ValueError("not a string or argument list: %r" % (args,))
+        args = py.std.shlex.split(args)
+    if _preinit:
+       _pluginmanager = _preinit.pop(0)
+    else: # subsequent calls to main will create a fresh instance
+        _pluginmanager = PluginManager(load=True)
+    hook = _pluginmanager.hook
+    if plugins:
+        for plugin in plugins:
+            _pluginmanager.register(plugin)
+    return hook.pytest_cmdline_parse(
+            pluginmanager=_pluginmanager, args=args)
+
+def main(args=None, plugins=None):
+    """ returned exit code integer, after an in-process testing run
+    with the given command line arguments, preloading an optional list
+    of passed in plugin objects. """
+    try:
+        config = _prepareconfig(args, plugins)
+        exitstatus = config.hook.pytest_cmdline_main(config=config)
+    except UsageError:
+        e = sys.exc_info()[1]
+        sys.stderr.write("ERROR: %s\n" %(e.args[0],))
+        exitstatus = 3
+    return exitstatus
+
+class UsageError(Exception):
+    """ error in py.test usage or invocation"""
+

_pytest/doctest.py

@@ -0,0 +1,87 @@
+""" discover and run doctests in modules and test files."""
+
+import pytest, py
+from py._code.code import TerminalRepr, ReprFileLocation
+
+def pytest_addoption(parser):
+    group = parser.getgroup("collect")
+    group.addoption("--doctest-modules",
+        action="store_true", default=False,
+        help="run doctests in all .py modules",
+        dest="doctestmodules")
+    group.addoption("--doctest-glob",
+        action="store", default="test*.txt", metavar="pat",
+        help="doctests file matching pattern, default: test*.txt",
+        dest="doctestglob")
+
+def pytest_collect_file(path, parent):
+    config = parent.config
+    if path.ext == ".py":
+        if config.option.doctestmodules:
+            return DoctestModule(path, parent)
+    elif (path.ext in ('.txt', '.rst') and parent.session.isinitpath(path)) or \
+        path.check(fnmatch=config.getvalue("doctestglob")):
+        return DoctestTextfile(path, parent)
+
+class ReprFailDoctest(TerminalRepr):
+    def __init__(self, reprlocation, lines):
+        self.reprlocation = reprlocation
+        self.lines = lines
+    def toterminal(self, tw):
+        for line in self.lines:
+            tw.line(line)
+        self.reprlocation.toterminal(tw)
+
+class DoctestItem(pytest.Item):
+    def repr_failure(self, excinfo):
+        doctest = py.std.doctest
+        if excinfo.errisinstance((doctest.DocTestFailure,
+                                  doctest.UnexpectedException)):
+            doctestfailure = excinfo.value
+            example = doctestfailure.example
+            test = doctestfailure.test
+            filename = test.filename
+            lineno = test.lineno + example.lineno + 1
+            message = excinfo.type.__name__
+            reprlocation = ReprFileLocation(filename, lineno, message)
+            checker = py.std.doctest.OutputChecker()
+            REPORT_UDIFF = py.std.doctest.REPORT_UDIFF
+            filelines = py.path.local(filename).readlines(cr=0)
+            i = max(test.lineno, max(0, lineno - 10)) # XXX?
+            lines = []
+            for line in filelines[i:lineno]:
+                lines.append("%03d %s" % (i+1, line))
+                i += 1
+            if excinfo.errisinstance(doctest.DocTestFailure):
+                lines += checker.output_difference(example,
+                        doctestfailure.got, REPORT_UDIFF).split("\n")
+            else:
+                inner_excinfo = py.code.ExceptionInfo(excinfo.value.exc_info)
+                lines += ["UNEXPECTED EXCEPTION: %s" %
+                            repr(inner_excinfo.value)]
+                lines += py.std.traceback.format_exception(*excinfo.value.exc_info)
+            return ReprFailDoctest(reprlocation, lines)
+        else:
+            return super(DoctestItem, self).repr_failure(excinfo)
+
+    def reportinfo(self):
+        return self.fspath, None, "[doctest]"
+
+class DoctestTextfile(DoctestItem, pytest.File):
+    def runtest(self):
+        doctest = py.std.doctest
+        failed, tot = doctest.testfile(
+            str(self.fspath), module_relative=False,
+            optionflags=doctest.ELLIPSIS,
+            raise_on_error=True, verbose=0)
+
+class DoctestModule(DoctestItem, pytest.File):
+    def runtest(self):
+        doctest = py.std.doctest
+        if self.fspath.basename == "conftest.py":
+            module = self.config._conftest.importconftest(self.fspath)
+        else:
+            module = self.fspath.pyimport()
+        failed, tot = doctest.testmod(
+            module, raise_on_error=True, verbose=0,
+            optionflags=doctest.ELLIPSIS)

_pytest/genscript.py

@@ -0,0 +1,69 @@
+""" generate a single-file self-contained version of py.test """
+import py
+
+def find_toplevel(name):
+    for syspath in py.std.sys.path:
+        base = py.path.local(syspath)
+        lib = base/name
+        if lib.check(dir=1):
+            return lib
+        mod = base.join("%s.py" % name)
+        if mod.check(file=1):
+            return mod
+    raise LookupError(name)
+
+def pkgname(toplevel, rootpath, path):
+    parts = path.parts()[len(rootpath.parts()):]
+    return '.'.join([toplevel] + [x.purebasename for x in parts])
+
+def pkg_to_mapping(name):
+    toplevel = find_toplevel(name)
+    name2src = {}
+    if toplevel.check(file=1): # module
+        name2src[toplevel.purebasename] = toplevel.read()
+    else: # package
+        for pyfile in toplevel.visit('*.py'):
+            pkg = pkgname(name, toplevel, pyfile)
+            name2src[pkg] = pyfile.read()
+    return name2src
+
+def compress_mapping(mapping):
+    data = py.std.pickle.dumps(mapping, 2)
+    data = py.std.zlib.compress(data, 9)
+    data = py.std.base64.encodestring(data)
+    data = data.decode('ascii')
+    return data
+
+
+def compress_packages(names):
+    mapping = {}
+    for name in names:
+        mapping.update(pkg_to_mapping(name))
+    return compress_mapping(mapping)
+
+def generate_script(entry, packages):
+    data = compress_packages(packages)
+    tmpl = py.path.local(__file__).dirpath().join('standalonetemplate.py')
+    exe = tmpl.read()
+    exe = exe.replace('@SOURCES@', data)
+    exe = exe.replace('@ENTRY@', entry)
+    return exe
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("debugconfig")
+    group.addoption("--genscript", action="store", default=None,
+        dest="genscript", metavar="path",
+        help="create standalone py.test script at given target path.")
+
+def pytest_cmdline_main(config):
+    genscript = config.getvalue("genscript")
+    if genscript:
+        script = generate_script(
+            'import py; raise SystemExit(py.test.cmdline.main())',
+            ['py', '_pytest', 'pytest'],
+        )
+
+        genscript = py.path.local(genscript)
+        genscript.write(script)
+        return 0

_pytest/helpconfig.py

@@ -0,0 +1,197 @@
+""" version info, help messages, tracing configuration.  """
+import py
+import pytest
+import os, inspect, sys
+from _pytest.core import varnames
+
+def pytest_addoption(parser):
+    group = parser.getgroup('debugconfig')
+    group.addoption('--version', action="store_true",
+            help="display pytest lib version and import information.")
+    group._addoption("-h", "--help", action="store_true", dest="help",
+            help="show help message and configuration info")
+    group._addoption('-p', action="append", dest="plugins", default = [],
+               metavar="name",
+               help="early-load given plugin (multi-allowed).")
+    group.addoption('--traceconfig',
+               action="store_true", dest="traceconfig", default=False,
+               help="trace considerations of conftest.py files."),
+    group.addoption('--debug',
+               action="store_true", dest="debug", default=False,
+               help="store internal tracing debug information in 'pytestdebug.log'.")
+
+
+def pytest_cmdline_parse(__multicall__):
+    config = __multicall__.execute()
+    if config.option.debug:
+        path = os.path.abspath("pytestdebug.log")
+        f = open(path, 'w')
+        config._debugfile = f
+        f.write("versions pytest-%s, py-%s, python-%s\ncwd=%s\nargs=%s\n\n" %(
+            pytest.__version__, py.__version__, ".".join(map(str, sys.version_info)),
+            os.getcwd(), config._origargs))
+        config.trace.root.setwriter(f.write)
+        sys.stderr.write("writing pytestdebug information to %s\n" % path)
+    return config
+
+@pytest.mark.trylast
+def pytest_unconfigure(config):
+    if hasattr(config, '_debugfile'):
+        config._debugfile.close()
+        sys.stderr.write("wrote pytestdebug information to %s\n" %
+            config._debugfile.name)
+        config.trace.root.setwriter(None)
+
+
+def pytest_cmdline_main(config):
+    if config.option.version:
+        p = py.path.local(pytest.__file__)
+        sys.stderr.write("This is py.test version %s, imported from %s\n" %
+            (pytest.__version__, p))
+        plugininfo = getpluginversioninfo(config)
+        if plugininfo:
+            for line in plugininfo:
+                sys.stderr.write(line + "\n")
+        return 0
+    elif config.option.help:
+        config.pluginmanager.do_configure(config)
+        showhelp(config)
+        config.pluginmanager.do_unconfigure(config)
+        return 0
+
+def showhelp(config):
+    tw = py.io.TerminalWriter()
+    tw.write(config._parser.optparser.format_help())
+    tw.line()
+    tw.line()
+    #tw.sep( "=", "config file settings")
+    tw.line("[pytest] ini-options in the next "
+            "pytest.ini|tox.ini|setup.cfg file:")
+    tw.line()
+
+    for name in config._parser._ininames:
+        help, type, default = config._parser._inidict[name]
+        if type is None:
+            type = "string"
+        spec = "%s (%s)" % (name, type)
+        line = "  %-24s %s" %(spec, help)
+        tw.line(line[:tw.fullwidth])
+
+    tw.line() ; tw.line()
+    #tw.sep("=")
+    return
+
+    tw.line("conftest.py options:")
+    tw.line()
+    conftestitems = sorted(config._parser._conftestdict.items())
+    for name, help in conftest_options + conftestitems:
+        line = "   %-15s  %s" %(name, help)
+        tw.line(line[:tw.fullwidth])
+    tw.line()
+    #tw.sep( "=")
+
+conftest_options = [
+    ('pytest_plugins', 'list of plugin names to load'),
+]
+
+def getpluginversioninfo(config):
+    lines = []
+    plugininfo = config.pluginmanager._plugin_distinfo
+    if plugininfo:
+        lines.append("setuptools registered plugins:")
+        for dist, plugin in plugininfo:
+            loc = getattr(plugin, '__file__', repr(plugin))
+            content = "%s-%s at %s" % (dist.project_name, dist.version, loc)
+            lines.append("  " + content)
+    return lines
+
+def pytest_report_header(config):
+    lines = []
+    if config.option.debug or config.option.traceconfig:
+        lines.append("using: pytest-%s pylib-%s" %
+            (pytest.__version__,py.__version__))
+
+        verinfo = getpluginversioninfo(config)
+        if verinfo:
+            lines.extend(verinfo)
+
+    if config.option.traceconfig:
+        lines.append("active plugins:")
+        plugins = []
+        items = config.pluginmanager._name2plugin.items()
+        for name, plugin in items:
+            if hasattr(plugin, '__file__'):
+                r = plugin.__file__
+            else:
+                r = repr(plugin)
+            lines.append("    %-20s: %s" %(name, r))
+    return lines
+
+
+# =====================================================
+# validate plugin syntax and hooks
+# =====================================================
+
+def pytest_plugin_registered(manager, plugin):
+    methods = collectattr(plugin)
+    hooks = {}
+    for hookspec in manager.hook._hookspecs:
+        hooks.update(collectattr(hookspec))
+
+    stringio = py.io.TextIO()
+    def Print(*args):
+        if args:
+            stringio.write(" ".join(map(str, args)))
+        stringio.write("\n")
+
+    fail = False
+    while methods:
+        name, method = methods.popitem()
+        #print "checking", name
+        if isgenerichook(name):
+            continue
+        if name not in hooks:
+            if not getattr(method, 'optionalhook', False):
+                Print("found unknown hook:", name)
+                fail = True
+        else:
+            #print "checking", method
+            method_args = list(varnames(method))
+            if '__multicall__' in method_args:
+                method_args.remove('__multicall__')
+            hook = hooks[name]
+            hookargs = varnames(hook)
+            for arg in method_args:
+                if arg not in hookargs:
+                    Print("argument %r not available"  %(arg, ))
+                    Print("actual definition: %s" %(formatdef(method)))
+                    Print("available hook arguments: %s" %
+                            ", ".join(hookargs))
+                    fail = True
+                    break
+            #if not fail:
+            #    print "matching hook:", formatdef(method)
+        if fail:
+            name = getattr(plugin, '__name__', plugin)
+            raise PluginValidationError("%s:\n%s" % (name, stringio.getvalue()))
+
+class PluginValidationError(Exception):
+    """ plugin failed validation. """
+
+def isgenerichook(name):
+    return name == "pytest_plugins" or \
+           name.startswith("pytest_funcarg__")
+
+def collectattr(obj):
+    methods = {}
+    for apiname in dir(obj):
+        if apiname.startswith("pytest_"):
+            methods[apiname] = getattr(obj, apiname)
+    return methods
+
+def formatdef(func):
+    return "%s%s" % (
+        func.__name__,
+        inspect.formatargspec(*inspect.getargspec(func))
+    )
+

_pytest/hookspec.py

@@ -0,0 +1,228 @@
+""" hook specifications for pytest plugins, invoked from main.py and builtin plugins.  """
+
+# -------------------------------------------------------------------------
+# Initialization
+# -------------------------------------------------------------------------
+
+def pytest_addhooks(pluginmanager):
+    """called at plugin load time to allow adding new hooks via a call to
+    pluginmanager.registerhooks(module)."""
+
+
+def pytest_namespace():
+    """return dict of name->object to be made globally available in
+    the py.test/pytest namespace.  This hook is called before command
+    line options are parsed.
+    """
+
+def pytest_cmdline_parse(pluginmanager, args):
+    """return initialized config object, parsing the specified args. """
+pytest_cmdline_parse.firstresult = True
+
+def pytest_cmdline_preparse(config, args):
+    """modify command line arguments before option parsing. """
+
+def pytest_addoption(parser):
+    """add optparse-style options and ini-style config values via calls
+    to ``parser.addoption`` and ``parser.addini(...)``.
+    """
+
+def pytest_cmdline_main(config):
+    """ called for performing the main command line action. The default
+    implementation will invoke the configure hooks and runtest_mainloop. """
+pytest_cmdline_main.firstresult = True
+
+def pytest_configure(config):
+    """ called after command line options have been parsed.
+        and all plugins and initial conftest files been loaded.
+    """
+
+def pytest_unconfigure(config):
+    """ called before test process is exited.  """
+
+def pytest_runtestloop(session):
+    """ called for performing the main runtest loop
+    (after collection finished). """
+pytest_runtestloop.firstresult = True
+
+# -------------------------------------------------------------------------
+# collection hooks
+# -------------------------------------------------------------------------
+
+def pytest_collection(session):
+    """ perform the collection protocol for the given session. """
+pytest_collection.firstresult = True
+
+def pytest_collection_modifyitems(session, config, items):
+    """ called after collection has been performed, may filter or re-order
+    the items in-place."""
+
+def pytest_collection_finish(session):
+    """ called after collection has been performed and modified. """
+
+def pytest_ignore_collect(path, config):
+    """ return True to prevent considering this path for collection.
+    This hook is consulted for all files and directories prior to calling
+    more specific hooks.
+    """
+pytest_ignore_collect.firstresult = True
+
+def pytest_collect_directory(path, parent):
+    """ called before traversing a directory for collection files. """
+pytest_collect_directory.firstresult = True
+
+def pytest_collect_file(path, parent):
+    """ return collection Node or None for the given path. Any new node
+    needs to have the specified ``parent`` as a parent."""
+
+# logging hooks for collection
+def pytest_collectstart(collector):
+    """ collector starts collecting. """
+
+def pytest_itemcollected(item):
+    """ we just collected a test item. """
+
+def pytest_collectreport(report):
+    """ collector finished collecting. """
+
+def pytest_deselected(items):
+    """ called for test items deselected by keyword. """
+
+def pytest_make_collect_report(collector):
+    """ perform ``collector.collect()`` and return a CollectReport. """
+pytest_make_collect_report.firstresult = True
+
+# -------------------------------------------------------------------------
+# Python test function related hooks
+# -------------------------------------------------------------------------
+
+def pytest_pycollect_makemodule(path, parent):
+    """ return a Module collector or None for the given path.
+    This hook will be called for each matching test module path.
+    The pytest_collect_file hook needs to be used if you want to
+    create test modules for files that do not match as a test module.
+    """
+pytest_pycollect_makemodule.firstresult = True
+
+def pytest_pycollect_makeitem(collector, name, obj):
+    """ return custom item/collector for a python object in a module, or None.  """
+pytest_pycollect_makeitem.firstresult = True
+
+def pytest_pyfunc_call(pyfuncitem):
+    """ call underlying test function. """
+pytest_pyfunc_call.firstresult = True
+
+def pytest_generate_tests(metafunc):
+    """ generate (multiple) parametrized calls to a test function."""
+
+# -------------------------------------------------------------------------
+# generic runtest related hooks
+# -------------------------------------------------------------------------
+def pytest_itemstart(item, node=None):
+    """ (deprecated, use pytest_runtest_logstart). """
+
+def pytest_runtest_protocol(item, nextitem):
+    """ implements the runtest_setup/call/teardown protocol for
+    the given test item, including capturing exceptions and calling
+    reporting hooks.
+
+    :arg item: test item for which the runtest protocol is performed.
+
+    :arg nexitem: the scheduled-to-be-next test item (or None if this
+                  is the end my friend).  This argument is passed on to
+                  :py:func:`pytest_runtest_teardown`.
+
+    :return boolean: True if no further hook implementations should be invoked.
+    """
+pytest_runtest_protocol.firstresult = True
+
+def pytest_runtest_logstart(nodeid, location):
+    """ signal the start of running a single test item. """
+
+def pytest_runtest_setup(item):
+    """ called before ``pytest_runtest_call(item)``. """
+
+def pytest_runtest_call(item):
+    """ called to execute the test ``item``. """
+
+def pytest_runtest_teardown(item, nextitem):
+    """ called after ``pytest_runtest_call``.
+
+    :arg nexitem: the scheduled-to-be-next test item (None if no further
+                  test item is scheduled).  This argument can be used to
+                  perform exact teardowns, i.e. calling just enough finalizers
+                  so that nextitem only needs to call setup-functions.
+    """
+
+def pytest_runtest_makereport(item, call):
+    """ return a :py:class:`_pytest.runner.TestReport` object
+    for the given :py:class:`pytest.Item` and
+    :py:class:`_pytest.runner.CallInfo`.
+    """
+pytest_runtest_makereport.firstresult = True
+
+def pytest_runtest_logreport(report):
+    """ process a test setup/call/teardown report relating to
+    the respective phase of executing a test. """
+
+# -------------------------------------------------------------------------
+# test session related hooks
+# -------------------------------------------------------------------------
+
+def pytest_sessionstart(session):
+    """ before session.main() is called. """
+
+def pytest_sessionfinish(session, exitstatus):
+    """ whole test run finishes. """
+
+
+# -------------------------------------------------------------------------
+# hooks for customising the assert methods
+# -------------------------------------------------------------------------
+
+def pytest_assertrepr_compare(config, op, left, right):
+    """return explanation for comparisons in failing assert expressions.
+
+    Return None for no custom explanation, otherwise return a list
+    of strings.  The strings will be joined by newlines but any newlines
+    *in* a string will be escaped.  Note that all but the first line will
+    be indented sligthly, the intention is for the first line to be a summary.
+    """
+
+# -------------------------------------------------------------------------
+# hooks for influencing reporting (invoked from _pytest_terminal)
+# -------------------------------------------------------------------------
+
+def pytest_report_header(config):
+    """ return a string to be displayed as header info for terminal reporting."""
+
+def pytest_report_teststatus(report):
+    """ return result-category, shortletter and verbose word for reporting."""
+pytest_report_teststatus.firstresult = True
+
+def pytest_terminal_summary(terminalreporter):
+    """ add additional section in terminal summary reporting. """
+
+# -------------------------------------------------------------------------
+# doctest hooks
+# -------------------------------------------------------------------------
+
+def pytest_doctest_prepare_content(content):
+    """ return processed content for a given doctest"""
+pytest_doctest_prepare_content.firstresult = True
+
+# -------------------------------------------------------------------------
+# error handling and internal debugging hooks
+# -------------------------------------------------------------------------
+
+def pytest_plugin_registered(plugin, manager):
+    """ a new py lib plugin got registered. """
+
+def pytest_plugin_unregistered(plugin):
+    """ a py lib plugin got unregistered. """
+
+def pytest_internalerror(excrepr):
+    """ called for internal errors. """
+
+def pytest_keyboard_interrupt(excinfo):
+    """ called for keyboard interrupt. """

_pytest/junitxml.py

@@ -0,0 +1,214 @@
+""" report test results in JUnit-XML format, for use with Hudson and build integration servers.
+
+Based on initial code from Ross Lawley.
+"""
+
+import py
+import os
+import re
+import sys
+import time
+
+
+# Python 2.X and 3.X compatibility
+try:
+    unichr(65)
+except NameError:
+    unichr = chr
+try:
+    unicode('A')
+except NameError:
+    unicode = str
+try:
+    long(1)
+except NameError:
+    long = int
+
+
+class Junit(py.xml.Namespace):
+    pass
+
+
+# We need to get the subset of the invalid unicode ranges according to
+# XML 1.0 which are valid in this python build.  Hence we calculate
+# this dynamically instead of hardcoding it.  The spec range of valid
+# chars is: Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
+#                    | [#x10000-#x10FFFF]
+_illegal_unichrs = [(0x00, 0x08), (0x0B, 0x0C), (0x0E, 0x19),
+                   (0xD800, 0xDFFF), (0xFDD0, 0xFFFF)]
+_illegal_ranges = [unicode("%s-%s") % (unichr(low), unichr(high))
+                  for (low, high) in _illegal_unichrs
+                  if low < sys.maxunicode]
+illegal_xml_re = re.compile(unicode('[%s]') %
+                            unicode('').join(_illegal_ranges))
+del _illegal_unichrs
+del _illegal_ranges
+
+def bin_xml_escape(arg):
+    def repl(matchobj):
+        i = ord(matchobj.group())
+        if i <= 0xFF:
+            return unicode('#x%02X') % i
+        else:
+            return unicode('#x%04X') % i
+    return illegal_xml_re.sub(repl, py.xml.escape(arg))
+
+def pytest_addoption(parser):
+    group = parser.getgroup("terminal reporting")
+    group.addoption('--junitxml', action="store", dest="xmlpath",
+           metavar="path", default=None,
+           help="create junit-xml style report file at given path.")
+    group.addoption('--junitprefix', action="store", dest="junitprefix",
+           metavar="str", default=None,
+           help="prepend prefix to classnames in junit-xml output")
+
+def pytest_configure(config):
+    xmlpath = config.option.xmlpath
+    if xmlpath:
+        config._xml = LogXML(xmlpath, config.option.junitprefix)
+        config.pluginmanager.register(config._xml)
+
+def pytest_unconfigure(config):
+    xml = getattr(config, '_xml', None)
+    if xml:
+        del config._xml
+        config.pluginmanager.unregister(xml)
+
+
+class LogXML(object):
+    def __init__(self, logfile, prefix):
+        logfile = os.path.expanduser(os.path.expandvars(logfile))
+        self.logfile = os.path.normpath(logfile)
+        self.prefix = prefix
+        self.tests = []
+        self.passed = self.skipped = 0
+        self.failed = self.errors = 0
+
+    def _opentestcase(self, report):
+        names = report.nodeid.split("::")
+        names[0] = names[0].replace("/", '.')
+        names = [x.replace(".py", "") for x in names if x != "()"]
+        classnames = names[:-1]
+        if self.prefix:
+            classnames.insert(0, self.prefix)
+        self.tests.append(Junit.testcase(
+            classname=".".join(classnames),
+            name=names[-1],
+            time=getattr(report, 'duration', 0)
+        ))
+
+    def append(self, obj):
+        self.tests[-1].append(obj)
+
+    def append_pass(self, report):
+        self.passed += 1
+
+    def append_failure(self, report):
+        #msg = str(report.longrepr.reprtraceback.extraline)
+        if "xfail" in report.keywords:
+            self.append(
+                Junit.skipped(message="xfail-marked test passes unexpectedly"))
+            self.skipped += 1
+        else:
+            sec = dict(report.sections)
+            fail = Junit.failure(message="test failure")
+            fail.append(str(report.longrepr))
+            self.append(fail)
+            for name in ('out', 'err'):
+                content = sec.get("Captured std%s" % name)
+                if content:
+                    tag = getattr(Junit, 'system-'+name)
+                    self.append(tag(bin_xml_escape(content)))
+            self.failed += 1
+
+    def append_collect_failure(self, report):
+        #msg = str(report.longrepr.reprtraceback.extraline)
+        self.append(Junit.failure(str(report.longrepr),
+                                  message="collection failure"))
+        self.errors += 1
+
+    def append_collect_skipped(self, report):
+        #msg = str(report.longrepr.reprtraceback.extraline)
+        self.append(Junit.skipped(str(report.longrepr),
+                                  message="collection skipped"))
+        self.skipped += 1
+
+    def append_error(self, report):
+        self.append(Junit.error(str(report.longrepr),
+                                message="test setup failure"))
+        self.errors += 1
+
+    def append_skipped(self, report):
+        if "xfail" in report.keywords:
+            self.append(Junit.skipped(str(report.keywords['xfail']),
+                                      message="expected test failure"))
+        else:
+            filename, lineno, skipreason = report.longrepr
+            if skipreason.startswith("Skipped: "):
+                skipreason = skipreason[9:]
+            self.append(
+                Junit.skipped("%s:%s: %s" % report.longrepr,
+                              type="pytest.skip",
+                              message=skipreason
+                ))
+        self.skipped += 1
+
+    def pytest_runtest_logreport(self, report):
+        if report.passed:
+            if report.when == "call": # ignore setup/teardown
+                self._opentestcase(report)
+                self.append_pass(report)
+        elif report.failed:
+            self._opentestcase(report)
+            if report.when != "call":
+                self.append_error(report)
+            else:
+                self.append_failure(report)
+        elif report.skipped:
+            self._opentestcase(report)
+            self.append_skipped(report)
+
+    def pytest_collectreport(self, report):
+        if not report.passed:
+            self._opentestcase(report)
+            if report.failed:
+                self.append_collect_failure(report)
+            else:
+                self.append_collect_skipped(report)
+
+    def pytest_internalerror(self, excrepr):
+        self.errors += 1
+        data = py.xml.escape(excrepr)
+        self.tests.append(
+            Junit.testcase(
+                    Junit.error(data, message="internal error"),
+                    classname="pytest",
+                    name="internal"))
+
+    def pytest_sessionstart(self, session):
+        self.suite_start_time = time.time()
+
+    def pytest_sessionfinish(self, session, exitstatus, __multicall__):
+        if py.std.sys.version_info[0] < 3:
+            logfile = py.std.codecs.open(self.logfile, 'w', encoding='utf-8')
+        else:
+            logfile = open(self.logfile, 'w', encoding='utf-8')
+
+        suite_stop_time = time.time()
+        suite_time_delta = suite_stop_time - self.suite_start_time
+        numtests = self.passed + self.failed
+
+        logfile.write('<?xml version="1.0" encoding="utf-8"?>')
+        logfile.write(Junit.testsuite(
+            self.tests,
+            name="",
+            errors=self.errors,
+            failures=self.failed,
+            skips=self.skipped,
+            tests=numtests,
+            time="%.3f" % suite_time_delta,
+        ).unicode(indent=0))
+        logfile.close()
+
+    def pytest_terminal_summary(self, terminalreporter):
+        terminalreporter.write_sep("-", "generated xml file: %s" % (self.logfile))

_pytest/main.py

@@ -0,0 +1,576 @@
+""" core implementation of testing process: init, session, runtest loop. """
+
+import py
+import pytest, _pytest
+import os, sys, imp
+tracebackcutdir = py.path.local(_pytest.__file__).dirpath()
+
+# exitcodes for the command line
+EXIT_OK = 0
+EXIT_TESTSFAILED = 1
+EXIT_INTERRUPTED = 2
+EXIT_INTERNALERROR = 3
+
+name_re = py.std.re.compile("^[a-zA-Z_]\w*$")
+
+def pytest_addoption(parser):
+    parser.addini("norecursedirs", "directory patterns to avoid for recursion",
+        type="args", default=('.*', 'CVS', '_darcs', '{arch}'))
+    #parser.addini("dirpatterns",
+    #    "patterns specifying possible locations of test files",
+    #    type="linelist", default=["**/test_*.txt",
+    #            "**/test_*.py", "**/*_test.py"]
+    #)
+    group = parser.getgroup("general", "running and selection options")
+    group._addoption('-x', '--exitfirst', action="store_true", default=False,
+               dest="exitfirst",
+               help="exit instantly on first error or failed test."),
+    group._addoption('--maxfail', metavar="num",
+               action="store", type="int", dest="maxfail", default=0,
+               help="exit after first num failures or errors.")
+
+    group._addoption('--strict', action="store_true",
+               help="run pytest in strict mode, warnings become errors.")
+
+    group = parser.getgroup("collect", "collection")
+    group.addoption('--collectonly',
+        action="store_true", dest="collectonly",
+        help="only collect tests, don't execute them."),
+    group.addoption('--pyargs', action="store_true",
+        help="try to interpret all arguments as python packages.")
+    group.addoption("--ignore", action="append", metavar="path",
+        help="ignore path during collection (multi-allowed).")
+    group.addoption('--confcutdir', dest="confcutdir", default=None,
+        metavar="dir",
+        help="only load conftest.py's relative to specified dir.")
+
+    group = parser.getgroup("debugconfig",
+        "test session debugging and configuration")
+    group.addoption('--basetemp', dest="basetemp", default=None, metavar="dir",
+               help="base temporary directory for this test run.")
+
+
+def pytest_namespace():
+    collect = dict(Item=Item, Collector=Collector, File=File, Session=Session)
+    return dict(collect=collect)
+
+def pytest_configure(config):
+    py.test.config = config # compatibiltiy
+    if config.option.exitfirst:
+        config.option.maxfail = 1
+
+def wrap_session(config, doit):
+    """Skeleton command line program"""
+    session = Session(config)
+    session.exitstatus = EXIT_OK
+    initstate = 0
+    try:
+        config.pluginmanager.do_configure(config)
+        initstate = 1
+        config.hook.pytest_sessionstart(session=session)
+        initstate = 2
+        doit(config, session)
+    except pytest.UsageError:
+        raise
+    except KeyboardInterrupt:
+        excinfo = py.code.ExceptionInfo()
+        config.hook.pytest_keyboard_interrupt(excinfo=excinfo)
+        session.exitstatus = EXIT_INTERRUPTED
+    except:
+        excinfo = py.code.ExceptionInfo()
+        config.pluginmanager.notify_exception(excinfo, config.option)
+        session.exitstatus = EXIT_INTERNALERROR
+        if excinfo.errisinstance(SystemExit):
+            sys.stderr.write("mainloop: caught Spurious SystemExit!\n")
+    if initstate >= 2:
+        config.hook.pytest_sessionfinish(session=session,
+            exitstatus=session.exitstatus or (session._testsfailed and 1))
+    if not session.exitstatus and session._testsfailed:
+        session.exitstatus = EXIT_TESTSFAILED
+    if initstate >= 1:
+        config.pluginmanager.do_unconfigure(config)
+    return session.exitstatus
+
+def pytest_cmdline_main(config):
+    return wrap_session(config, _main)
+
+def _main(config, session):
+    """ default command line protocol for initialization, session,
+    running tests and reporting. """
+    config.hook.pytest_collection(session=session)
+    config.hook.pytest_runtestloop(session=session)
+
+def pytest_collection(session):
+    return session.perform_collect()
+
+def pytest_runtestloop(session):
+    if session.config.option.collectonly:
+        return True
+    for i, item in enumerate(session.items):
+        try:
+            nextitem = session.items[i+1]
+        except IndexError:
+            nextitem = None
+        item.config.hook.pytest_runtest_protocol(item=item, nextitem=nextitem)
+        if session.shouldstop:
+            raise session.Interrupted(session.shouldstop)
+    return True
+
+def pytest_ignore_collect(path, config):
+    p = path.dirpath()
+    ignore_paths = config._getconftest_pathlist("collect_ignore", path=p)
+    ignore_paths = ignore_paths or []
+    excludeopt = config.getvalue("ignore")
+    if excludeopt:
+        ignore_paths.extend([py.path.local(x) for x in excludeopt])
+    return path in ignore_paths
+
+class HookProxy:
+    def __init__(self, fspath, config):
+        self.fspath = fspath
+        self.config = config
+    def __getattr__(self, name):
+        hookmethod = getattr(self.config.hook, name)
+        def call_matching_hooks(**kwargs):
+            plugins = self.config._getmatchingplugins(self.fspath)
+            return hookmethod.pcall(plugins, **kwargs)
+        return call_matching_hooks
+
+def compatproperty(name):
+    def fget(self):
+        return getattr(pytest, name)
+    return property(fget, None, None,
+        "deprecated attribute %r, use pytest.%s" % (name,name))
+
+class Node(object):
+    """ base class for all Nodes in the collection tree.
+    Collector subclasses have children, Items are terminal nodes."""
+
+    def __init__(self, name, parent=None, config=None, session=None):
+        #: a unique name with the scope of the parent
+        self.name = name
+
+        #: the parent collector node.
+        self.parent = parent
+
+        #: the test config object
+        self.config = config or parent.config
+
+        #: the collection this node is part of
+        self.session = session or parent.session
+
+        #: filesystem path where this node was collected from
+        self.fspath = getattr(parent, 'fspath', None)
+        self.ihook = self.session.gethookproxy(self.fspath)
+        self.keywords = {self.name: True}
+
+    Module = compatproperty("Module")
+    Class = compatproperty("Class")
+    Instance = compatproperty("Instance")
+    Function = compatproperty("Function")
+    File = compatproperty("File")
+    Item = compatproperty("Item")
+
+    def _getcustomclass(self, name):
+        cls = getattr(self, name)
+        if cls != getattr(pytest, name):
+            py.log._apiwarn("2.0", "use of node.%s is deprecated, "
+                "use pytest_pycollect_makeitem(...) to create custom "
+                "collection nodes" % name)
+        return cls
+
+    def __repr__(self):
+        return "<%s %r>" %(self.__class__.__name__, getattr(self, 'name', None))
+
+    # methods for ordering nodes
+    @property
+    def nodeid(self):
+        try:
+            return self._nodeid
+        except AttributeError:
+            self._nodeid = x = self._makeid()
+            return x
+
+    def _makeid(self):
+        return self.parent.nodeid + "::" + self.name
+
+    def __eq__(self, other):
+        if not isinstance(other, Node):
+            return False
+        return self.__class__ == other.__class__ and \
+               self.name == other.name and self.parent == other.parent
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        return hash((self.name, self.parent))
+
+    def setup(self):
+        pass
+
+    def teardown(self):
+        pass
+
+    def _memoizedcall(self, attrname, function):
+        exattrname = "_ex_" + attrname
+        failure = getattr(self, exattrname, None)
+        if failure is not None:
+            py.builtin._reraise(failure[0], failure[1], failure[2])
+        if hasattr(self, attrname):
+            return getattr(self, attrname)
+        try:
+            res = function()
+        except py.builtin._sysex:
+            raise
+        except:
+            failure = py.std.sys.exc_info()
+            setattr(self, exattrname, failure)
+            raise
+        setattr(self, attrname, res)
+        return res
+
+    def listchain(self):
+        """ return list of all parent collectors up to self,
+            starting from root of collection tree. """
+        chain = []
+        item = self
+        while item is not None:
+            chain.append(item)
+            item = item.parent
+        chain.reverse()
+        return chain
+
+    def listnames(self):
+        return [x.name for x in self.listchain()]
+
+    def getplugins(self):
+        return self.config._getmatchingplugins(self.fspath)
+
+    def getparent(self, cls):
+        current = self
+        while current and not isinstance(current, cls):
+            current = current.parent
+        return current
+
+    def _prunetraceback(self, excinfo):
+        pass
+
+    def _repr_failure_py(self, excinfo, style=None):
+        if self.config.option.fulltrace:
+            style="long"
+        else:
+            self._prunetraceback(excinfo)
+        # XXX should excinfo.getrepr record all data and toterminal()
+        # process it?
+        if style is None:
+            if self.config.option.tbstyle == "short":
+                style = "short"
+            else:
+                style = "long"
+        return excinfo.getrepr(funcargs=True,
+                               showlocals=self.config.option.showlocals,
+                               style=style)
+
+    repr_failure = _repr_failure_py
+
+class Collector(Node):
+    """ Collector instances create children through collect()
+        and thus iteratively build a tree.
+    """
+    class CollectError(Exception):
+        """ an error during collection, contains a custom message. """
+
+    def collect(self):
+        """ returns a list of children (items and collectors)
+            for this collection node.
+        """
+        raise NotImplementedError("abstract")
+
+    def repr_failure(self, excinfo):
+        """ represent a collection failure. """
+        if excinfo.errisinstance(self.CollectError):
+            exc = excinfo.value
+            return str(exc.args[0])
+        return self._repr_failure_py(excinfo, style="short")
+
+    def _memocollect(self):
+        """ internal helper method to cache results of calling collect(). """
+        return self._memoizedcall('_collected', lambda: list(self.collect()))
+
+    def _prunetraceback(self, excinfo):
+        if hasattr(self, 'fspath'):
+            path = self.fspath
+            traceback = excinfo.traceback
+            ntraceback = traceback.cut(path=self.fspath)
+            if ntraceback == traceback:
+                ntraceback = ntraceback.cut(excludepath=tracebackcutdir)
+            excinfo.traceback = ntraceback.filter()
+
+class FSCollector(Collector):
+    def __init__(self, fspath, parent=None, config=None, session=None):
+        fspath = py.path.local(fspath) # xxx only for test_resultlog.py?
+        name = fspath.basename
+        if parent is not None:
+            rel = fspath.relto(parent.fspath)
+            if rel:
+                name = rel
+            name = name.replace(os.sep, "/")
+        super(FSCollector, self).__init__(name, parent, config, session)
+        self.fspath = fspath
+
+    def _makeid(self):
+        if self == self.session:
+            return "."
+        relpath = self.session.fspath.bestrelpath(self.fspath)
+        if os.sep != "/":
+            relpath = relpath.replace(os.sep, "/")
+        return relpath
+
+class File(FSCollector):
+    """ base class for collecting tests from a file. """
+
+class Item(Node):
+    """ a basic test invocation item. Note that for a single function
+    there might be multiple test invocation items.
+    """
+    nextitem = None
+
+    def reportinfo(self):
+        return self.fspath, None, ""
+
+    @property
+    def location(self):
+        try:
+            return self._location
+        except AttributeError:
+            location = self.reportinfo()
+            # bestrelpath is a quite slow function
+            cache = self.config.__dict__.setdefault("_bestrelpathcache", {})
+            try:
+                fspath = cache[location[0]]
+            except KeyError:
+                fspath = self.session.fspath.bestrelpath(location[0])
+                cache[location[0]] = fspath
+            location = (fspath, location[1], str(location[2]))
+            self._location = location
+            return location
+
+class NoMatch(Exception):
+    """ raised if matching cannot locate a matching names. """
+
+class Session(FSCollector):
+    class Interrupted(KeyboardInterrupt):
+        """ signals an interrupted test run. """
+        __module__ = 'builtins' # for py3
+
+    def __init__(self, config):
+        super(Session, self).__init__(py.path.local(), parent=None,
+            config=config, session=self)
+        assert self.config.pluginmanager.register(self, name="session", prepend=True)
+        self._testsfailed = 0
+        self.shouldstop = False
+        self.trace = config.trace.root.get("collection")
+        self._norecursepatterns = config.getini("norecursedirs")
+
+    def pytest_collectstart(self):
+        if self.shouldstop:
+            raise self.Interrupted(self.shouldstop)
+
+    def pytest_runtest_logreport(self, report):
+        if report.failed and 'xfail' not in getattr(report, 'keywords', []):
+            self._testsfailed += 1
+            maxfail = self.config.getvalue("maxfail")
+            if maxfail and self._testsfailed >= maxfail:
+                self.shouldstop = "stopping after %d failures" % (
+                    self._testsfailed)
+    pytest_collectreport = pytest_runtest_logreport
+
+    def isinitpath(self, path):
+        return path in self._initialpaths
+
+    def gethookproxy(self, fspath):
+        return HookProxy(fspath, self.config)
+
+    def perform_collect(self, args=None, genitems=True):
+        hook = self.config.hook
+        try:
+            items = self._perform_collect(args, genitems)
+            hook.pytest_collection_modifyitems(session=self,
+                config=self.config, items=items)
+        finally:
+            hook.pytest_collection_finish(session=self)
+        return items
+
+    def _perform_collect(self, args, genitems):
+        if args is None:
+            args = self.config.args
+        self.trace("perform_collect", self, args)
+        self.trace.root.indent += 1
+        self._notfound = []
+        self._initialpaths = set()
+        self._initialparts = []
+        self.items = items = []
+        for arg in args:
+            parts = self._parsearg(arg)
+            self._initialparts.append(parts)
+            self._initialpaths.add(parts[0])
+        self.ihook.pytest_collectstart(collector=self)
+        rep = self.ihook.pytest_make_collect_report(collector=self)
+        self.ihook.pytest_collectreport(report=rep)
+        self.trace.root.indent -= 1
+        if self._notfound:
+            for arg, exc in self._notfound:
+                line = "(no name %r in any of %r)" % (arg, exc.args[0])
+                raise pytest.UsageError("not found: %s\n%s" %(arg, line))
+        if not genitems:
+            return rep.result
+        else:
+            if rep.passed:
+                for node in rep.result:
+                    self.items.extend(self.genitems(node))
+            return items
+
+    def collect(self):
+        for parts in self._initialparts:
+            arg = "::".join(map(str, parts))
+            self.trace("processing argument", arg)
+            self.trace.root.indent += 1
+            try:
+                for x in self._collect(arg):
+                    yield x
+            except NoMatch:
+                # we are inside a make_report hook so
+                # we cannot directly pass through the exception
+                self._notfound.append((arg, sys.exc_info()[1]))
+                self.trace.root.indent -= 1
+                break
+            self.trace.root.indent -= 1
+
+    def _collect(self, arg):
+        names = self._parsearg(arg)
+        path = names.pop(0)
+        if path.check(dir=1):
+            assert not names, "invalid arg %r" %(arg,)
+            for path in path.visit(fil=lambda x: x.check(file=1),
+                rec=self._recurse, bf=True, sort=True):
+                for x in self._collectfile(path):
+                    yield x
+        else:
+            assert path.check(file=1)
+            for x in self.matchnodes(self._collectfile(path), names):
+                yield x
+
+    def _collectfile(self, path):
+        ihook = self.gethookproxy(path)
+        if not self.isinitpath(path):
+            if ihook.pytest_ignore_collect(path=path, config=self.config):
+               return ()
+        return ihook.pytest_collect_file(path=path, parent=self)
+
+    def _recurse(self, path):
+        ihook = self.gethookproxy(path.dirpath())
+        if ihook.pytest_ignore_collect(path=path, config=self.config):
+           return
+        for pat in self._norecursepatterns:
+            if path.check(fnmatch=pat):
+                return False
+        ihook = self.gethookproxy(path)
+        ihook.pytest_collect_directory(path=path, parent=self)
+        return True
+
+    def _tryconvertpyarg(self, x):
+        mod = None
+        path = [os.path.abspath('.')] + sys.path
+        for name in x.split('.'):
+            # ignore anything that's not a proper name here
+            # else something like --pyargs will mess up '.'
+            # since imp.find_module will actually sometimes work for it
+            # but it's supposed to be considered a filesystem path
+            # not a package
+            if name_re.match(name) is None:
+                return x
+            try:
+                fd, mod, type_ = imp.find_module(name, path)
+            except ImportError:
+                return x
+            else:
+                if fd is not None:
+                    fd.close()
+
+            if type_[2] != imp.PKG_DIRECTORY:
+                path = [os.path.dirname(mod)]
+            else:
+                path = [mod]
+        return mod
+
+    def _parsearg(self, arg):
+        """ return (fspath, names) tuple after checking the file exists. """
+        arg = str(arg)
+        if self.config.option.pyargs:
+            arg = self._tryconvertpyarg(arg)
+        parts = str(arg).split("::")
+        relpath = parts[0].replace("/", os.sep)
+        path = self.fspath.join(relpath, abs=True)
+        if not path.check():
+            if self.config.option.pyargs:
+                msg = "file or package not found: "
+            else:
+                msg = "file not found: "
+            raise pytest.UsageError(msg + arg)
+        parts[0] = path
+        return parts
+
+    def matchnodes(self, matching, names):
+        self.trace("matchnodes", matching, names)
+        self.trace.root.indent += 1
+        nodes = self._matchnodes(matching, names)
+        num = len(nodes)
+        self.trace("matchnodes finished -> ", num, "nodes")
+        self.trace.root.indent -= 1
+        if num == 0:
+            raise NoMatch(matching, names[:1])
+        return nodes
+
+    def _matchnodes(self, matching, names):
+        if not matching or not names:
+            return matching
+        name = names[0]
+        assert name
+        nextnames = names[1:]
+        resultnodes = []
+        for node in matching:
+            if isinstance(node, pytest.Item):
+                if not names:
+                    resultnodes.append(node)
+                continue
+            assert isinstance(node, pytest.Collector)
+            node.ihook.pytest_collectstart(collector=node)
+            rep = node.ihook.pytest_make_collect_report(collector=node)
+            if rep.passed:
+                has_matched = False
+                for x in rep.result:
+                    if x.name == name:
+                        resultnodes.extend(self.matchnodes([x], nextnames))
+                        has_matched = True
+                # XXX accept IDs that don't have "()" for class instances
+                if not has_matched and len(rep.result) == 1 and x.name == "()":
+                    nextnames.insert(0, name)
+                    resultnodes.extend(self.matchnodes([x], nextnames))
+            node.ihook.pytest_collectreport(report=rep)
+        return resultnodes
+
+    def genitems(self, node):
+        self.trace("genitems", node)
+        if isinstance(node, pytest.Item):
+            node.ihook.pytest_itemcollected(item=node)
+            yield node
+        else:
+            assert isinstance(node, pytest.Collector)
+            node.ihook.pytest_collectstart(collector=node)
+            rep = node.ihook.pytest_make_collect_report(collector=node)
+            if rep.passed:
+                for subnode in rep.result:
+                    for x in self.genitems(subnode):
+                        yield x
+            node.ihook.pytest_collectreport(report=rep)

_pytest/mark.py

@@ -0,0 +1,226 @@
+""" generic mechanism for marking and selecting python functions. """
+import pytest, py
+
+def pytest_namespace():
+    return {'mark': MarkGenerator()}
+
+def pytest_addoption(parser):
+    group = parser.getgroup("general")
+    group._addoption('-k',
+        action="store", dest="keyword", default='', metavar="KEYWORDEXPR",
+        help="only run tests which match given keyword expression.  "
+             "An expression consists of space-separated terms. "
+             "Each term must match. Precede a term with '-' to negate. "
+             "Terminate expression with ':' to make the first match match "
+             "all subsequent tests (usually file-order). ")
+
+    group._addoption("-m",
+        action="store", dest="markexpr", default="", metavar="MARKEXPR",
+        help="only run tests matching given mark expression.  "
+             "example: -m 'mark1 and not mark2'."
+             )
+
+    group.addoption("--markers", action="store_true", help=
+        "show markers (builtin, plugin and per-project ones).")
+
+    parser.addini("markers", "markers for test functions", 'linelist')
+
+def pytest_cmdline_main(config):
+    if config.option.markers:
+        config.pluginmanager.do_configure(config)
+        tw = py.io.TerminalWriter()
+        for line in config.getini("markers"):
+            name, rest = line.split(":", 1)
+            tw.write("@pytest.mark.%s:" %  name, bold=True)
+            tw.line(rest)
+            tw.line()
+        config.pluginmanager.do_unconfigure(config)
+        return 0
+pytest_cmdline_main.tryfirst = True
+
+def pytest_collection_modifyitems(items, config):
+    keywordexpr = config.option.keyword
+    matchexpr = config.option.markexpr
+    if not keywordexpr and not matchexpr:
+        return
+    selectuntil = False
+    if keywordexpr[-1:] == ":":
+        selectuntil = True
+        keywordexpr = keywordexpr[:-1]
+
+    remaining = []
+    deselected = []
+    for colitem in items:
+        if keywordexpr and skipbykeyword(colitem, keywordexpr):
+            deselected.append(colitem)
+        else:
+            if selectuntil:
+                keywordexpr = None
+            if matchexpr:
+                if not matchmark(colitem, matchexpr):
+                    deselected.append(colitem)
+                    continue
+            remaining.append(colitem)
+
+    if deselected:
+        config.hook.pytest_deselected(items=deselected)
+        items[:] = remaining
+
+class BoolDict:
+    def __init__(self, mydict):
+        self._mydict = mydict
+    def __getitem__(self, name):
+        return name in self._mydict
+
+def matchmark(colitem, matchexpr):
+    return eval(matchexpr, {}, BoolDict(colitem.obj.__dict__))
+
+def pytest_configure(config):
+    if config.option.strict:
+        pytest.mark._config = config
+
+def skipbykeyword(colitem, keywordexpr):
+    """ return True if they given keyword expression means to
+        skip this collector/item.
+    """
+    if not keywordexpr:
+        return
+
+    itemkeywords = getkeywords(colitem)
+    for key in filter(None, keywordexpr.split()):
+        eor = key[:1] == '-'
+        if eor:
+            key = key[1:]
+        if not (eor ^ matchonekeyword(key, itemkeywords)):
+            return True
+
+def getkeywords(node):
+    keywords = {}
+    while node is not None:
+        keywords.update(node.keywords)
+        node = node.parent
+    return keywords
+
+
+def matchonekeyword(key, itemkeywords):
+    for elem in key.split("."):
+        for kw in itemkeywords:
+            if elem in kw:
+                break
+        else:
+            return False
+    return True
+
+class MarkGenerator:
+    """ Factory for :class:`MarkDecorator` objects - exposed as
+    a ``py.test.mark`` singleton instance.  Example::
+
+         import py
+         @py.test.mark.slowtest
+         def test_function():
+            pass
+
+    will set a 'slowtest' :class:`MarkInfo` object
+    on the ``test_function`` object. """
+
+    def __getattr__(self, name):
+        if name[0] == "_":
+            raise AttributeError(name)
+        if hasattr(self, '_config'):
+            self._check(name)
+        return MarkDecorator(name)
+
+    def _check(self, name):
+        try:
+            if name in self._markers:
+                return
+        except AttributeError:
+            pass
+        self._markers = l = set()
+        for line in self._config.getini("markers"):
+            beginning = line.split(":", 1)
+            x = beginning[0].split("(", 1)[0]
+            l.add(x)
+        if name not in self._markers:
+            raise AttributeError("%r not a registered marker" % (name,))
+
+class MarkDecorator:
+    """ A decorator for test functions and test classes.  When applied
+    it will create :class:`MarkInfo` objects which may be
+    :ref:`retrieved by hooks as item keywords <excontrolskip>`.
+    MarkDecorator instances are often created like this::
+
+        mark1 = py.test.mark.NAME              # simple MarkDecorator
+        mark2 = py.test.mark.NAME(name1=value) # parametrized MarkDecorator
+
+    and can then be applied as decorators to test functions::
+
+        @mark2
+        def test_function():
+            pass
+    """
+    def __init__(self, name, args=None, kwargs=None):
+        self.markname = name
+        self.args = args or ()
+        self.kwargs = kwargs or {}
+
+    def __repr__(self):
+        d = self.__dict__.copy()
+        name = d.pop('markname')
+        return "<MarkDecorator %r %r>" %(name, d)
+
+    def __call__(self, *args, **kwargs):
+        """ if passed a single callable argument: decorate it with mark info.
+            otherwise add *args/**kwargs in-place to mark information. """
+        if args:
+            func = args[0]
+            if len(args) == 1 and hasattr(func, '__call__') or \
+               hasattr(func, '__bases__'):
+                if hasattr(func, '__bases__'):
+                    if hasattr(func, 'pytestmark'):
+                        l = func.pytestmark
+                        if not isinstance(l, list):
+                           func.pytestmark = [l, self]
+                        else:
+                           l.append(self)
+                    else:
+                       func.pytestmark = [self]
+                else:
+                    holder = getattr(func, self.markname, None)
+                    if holder is None:
+                        holder = MarkInfo(self.markname, self.args, self.kwargs)
+                        setattr(func, self.markname, holder)
+                    else:
+                        holder.add(self.args, self.kwargs)
+                return func
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        args = self.args + args
+        return self.__class__(self.markname, args=args, kwargs=kw)
+
+class MarkInfo:
+    """ Marking object created by :class:`MarkDecorator` instances. """
+    def __init__(self, name, args, kwargs):
+        #: name of attribute
+        self.name = name
+        #: positional argument list, empty if none specified
+        self.args = args
+        #: keyword argument dictionary, empty if nothing specified
+        self.kwargs = kwargs
+        self._arglist = [(args, kwargs.copy())]
+
+    def __repr__(self):
+        return "<MarkInfo %r args=%r kwargs=%r>" % (
+                self.name, self.args, self.kwargs)
+
+    def add(self, args, kwargs):
+        """ add a MarkInfo with the given args and kwargs. """
+        self._arglist.append((args, kwargs))
+        self.args += args
+        self.kwargs.update(kwargs)
+
+    def __iter__(self):
+        """ yield MarkInfo objects each relating to a marking-call. """
+        for args, kwargs in self._arglist:
+            yield MarkInfo(self.name, args, kwargs)
+

_pytest/monkeypatch.py

@@ -0,0 +1,124 @@
+""" monkeypatching and mocking functionality.  """
+
+import os, sys
+
+def pytest_funcarg__monkeypatch(request):
+    """The returned ``monkeypatch`` funcarg provides these
+    helper methods to modify objects, dictionaries or os.environ::
+
+        monkeypatch.setattr(obj, name, value, raising=True)
+        monkeypatch.delattr(obj, name, raising=True)
+        monkeypatch.setitem(mapping, name, value)
+        monkeypatch.delitem(obj, name, raising=True)
+        monkeypatch.setenv(name, value, prepend=False)
+        monkeypatch.delenv(name, value, raising=True)
+        monkeypatch.syspath_prepend(path)
+        monkeypatch.chdir(path)
+
+    All modifications will be undone after the requesting
+    test function has finished. The ``raising``
+    parameter determines if a KeyError or AttributeError
+    will be raised if the set/deletion operation has no target.
+    """
+    mpatch = monkeypatch()
+    request.addfinalizer(mpatch.undo)
+    return mpatch
+
+notset = object()
+
+class monkeypatch:
+    """ object keeping a record of setattr/item/env/syspath changes. """
+    def __init__(self):
+        self._setattr = []
+        self._setitem = []
+        self._cwd = None
+
+    def setattr(self, obj, name, value, raising=True):
+        """ set attribute ``name`` on ``obj`` to ``value``, by default
+        raise AttributeEror if the attribute did not exist. """
+        oldval = getattr(obj, name, notset)
+        if raising and oldval is notset:
+            raise AttributeError("%r has no attribute %r" %(obj, name))
+        self._setattr.insert(0, (obj, name, oldval))
+        setattr(obj, name, value)
+
+    def delattr(self, obj, name, raising=True):
+        """ delete attribute ``name`` from ``obj``, by default raise
+        AttributeError it the attribute did not previously exist. """
+        if not hasattr(obj, name):
+            if raising:
+                raise AttributeError(name)
+        else:
+            self._setattr.insert(0, (obj, name, getattr(obj, name, notset)))
+            delattr(obj, name)
+
+    def setitem(self, dic, name, value):
+        """ set dictionary entry ``name`` to value. """
+        self._setitem.insert(0, (dic, name, dic.get(name, notset)))
+        dic[name] = value
+
+    def delitem(self, dic, name, raising=True):
+        """ delete ``name`` from dict, raise KeyError if it doesn't exist."""
+        if name not in dic:
+            if raising:
+                raise KeyError(name)
+        else:
+            self._setitem.insert(0, (dic, name, dic.get(name, notset)))
+            del dic[name]
+
+    def setenv(self, name, value, prepend=None):
+        """ set environment variable ``name`` to ``value``.  if ``prepend``
+        is a character, read the current environment variable value
+        and prepend the ``value`` adjoined with the ``prepend`` character."""
+        value = str(value)
+        if prepend and name in os.environ:
+            value = value + prepend + os.environ[name]
+        self.setitem(os.environ, name, value)
+
+    def delenv(self, name, raising=True):
+        """ delete ``name`` from environment, raise KeyError it not exists."""
+        self.delitem(os.environ, name, raising=raising)
+
+    def syspath_prepend(self, path):
+        """ prepend ``path`` to ``sys.path`` list of import locations. """
+        if not hasattr(self, '_savesyspath'):
+            self._savesyspath = sys.path[:]
+        sys.path.insert(0, str(path))
+
+    def chdir(self, path):
+        """ change the current working directory to the specified path
+        path can be a string or a py.path.local object
+        """
+        if self._cwd is None:
+            self._cwd = os.getcwd()
+        if hasattr(path, "chdir"):
+            path.chdir()
+        else:
+            os.chdir(path)
+
+    def undo(self):
+        """ undo previous changes.  This call consumes the
+        undo stack.  Calling it a second time has no effect unless
+        you  do more monkeypatching after the undo call."""
+        for obj, name, value in self._setattr:
+            if value is not notset:
+                setattr(obj, name, value)
+            else:
+                delattr(obj, name)
+        self._setattr[:] = []
+        for dictionary, name, value in self._setitem:
+            if value is notset:
+                try:
+                    del dictionary[name]
+                except KeyError:
+                    pass # was already deleted, so we have the desired state
+            else:
+                dictionary[name] = value
+        self._setitem[:] = []
+        if hasattr(self, '_savesyspath'):
+            sys.path[:] = self._savesyspath
+            del self._savesyspath
+
+        if self._cwd is not None:
+            os.chdir(self._cwd)
+            self._cwd = None

_pytest/nose.py

@@ -0,0 +1,48 @@
+""" run test suites written for nose. """
+
+import pytest, py
+import inspect
+import sys
+
+def pytest_runtest_makereport(__multicall__, item, call):
+    SkipTest = getattr(sys.modules.get('nose', None), 'SkipTest', None)
+    if SkipTest:
+        if call.excinfo and call.excinfo.errisinstance(SkipTest):
+            # let's substitute the excinfo with a py.test.skip one
+            call2 = call.__class__(lambda: py.test.skip(str(call.excinfo.value)), call.when)
+            call.excinfo = call2.excinfo
+
+
+@pytest.mark.trylast
+def pytest_runtest_setup(item):
+    if isinstance(item, (pytest.Function)):
+        if isinstance(item.parent, pytest.Generator):
+            gen = item.parent
+            if not hasattr(gen, '_nosegensetup'):
+                call_optional(gen.obj, 'setup')
+                if isinstance(gen.parent, pytest.Instance):
+                    call_optional(gen.parent.obj, 'setup')
+                gen._nosegensetup = True
+        if not call_optional(item.obj, 'setup'):
+            # call module level setup if there is no object level one
+            call_optional(item.parent.obj, 'setup')
+
+def pytest_runtest_teardown(item):
+    if isinstance(item, pytest.Function):
+        if not call_optional(item.obj, 'teardown'):
+            call_optional(item.parent.obj, 'teardown')
+        #if hasattr(item.parent, '_nosegensetup'):
+        #    #call_optional(item._nosegensetup, 'teardown')
+        #    del item.parent._nosegensetup
+
+def pytest_make_collect_report(collector):
+    if isinstance(collector, pytest.Generator):
+        call_optional(collector.obj, 'setup')
+
+def call_optional(obj, name):
+    method = getattr(obj, name, None)
+    if method:
+        # If there's any problems allow the exception to raise rather than
+        # silently ignoring them
+        method()
+        return True

_pytest/pastebin.py

@@ -1,24 +1,4 @@
-"""
-submit failure or test session information to a pastebin service. 
-
-Usage
-----------
-
-**Creating a URL for each test failure**::
-
-    py.test --pastebin=failed 
-
-This will submit test run information to a remote Paste service and
-provide a URL for each failure.  You may select tests as usual or add
-for example ``-x`` if you only want to send one particular failure. 
-
-**Creating a URL for a whole test session log**::
-
-    py.test --pastebin=all 
-
-Currently only pasting to the http://paste.pocoo.org service is implemented.  
-
-"""
+""" submit failure or test session information to a pastebin service. """
 import py, sys
 
 class url:
@@ -29,8 +9,8 @@ class url:
 def pytest_addoption(parser):
     group = parser.getgroup("terminal reporting")
     group._addoption('--pastebin', metavar="mode",
-        action='store', dest="pastebin", default=None, 
-        type="choice", choices=['failed', 'all'], 
+        action='store', dest="pastebin", default=None,
+        type="choice", choices=['failed', 'all'],
         help="send failed|all info to Pocoo pastebin service.")
 
 def pytest_configure(__multicall__, config):
@@ -39,13 +19,13 @@ def pytest_configure(__multicall__, config):
     if config.option.pastebin == "all":
         config._pastebinfile = tempfile.TemporaryFile('w+')
         tr = config.pluginmanager.getplugin('terminalreporter')
-        oldwrite = tr._tw.write 
+        oldwrite = tr._tw.write
         def tee_write(s, **kwargs):
             oldwrite(s, **kwargs)
             config._pastebinfile.write(str(s))
-        tr._tw.write = tee_write 
+        tr._tw.write = tee_write
 
-def pytest_unconfigure(config): 
+def pytest_unconfigure(config):
     if hasattr(config, '_pastebinfile'):
         config._pastebinfile.seek(0)
         sessionlog = config._pastebinfile.read()
@@ -56,9 +36,13 @@ def pytest_unconfigure(config):
         sys.stderr.write("pastebin session-log: %s\n" % pastebinurl)
         tr = config.pluginmanager.getplugin('terminalreporter')
         del tr._tw.__dict__['write']
-        
+
 def getproxy():
-    return py.std.xmlrpclib.ServerProxy(url.xmlrpc).pastes
+    if sys.version_info < (3, 0):
+        from xmlrpclib import ServerProxy
+    else:
+        from xmlrpc.client import ServerProxy
+    return ServerProxy(url.xmlrpc).pastes
 
 def pytest_terminal_summary(terminalreporter):
     if terminalreporter.config.option.pastebin != "failed":

_pytest/pdb.py

@@ -0,0 +1,95 @@
+""" interactive debugging with PDB, the Python Debugger. """
+
+import pytest, py
+import sys
+
+def pytest_addoption(parser):
+    group = parser.getgroup("general")
+    group._addoption('--pdb',
+               action="store_true", dest="usepdb", default=False,
+               help="start the interactive Python debugger on errors.")
+
+def pytest_namespace():
+    return {'set_trace': pytestPDB().set_trace}
+
+def pytest_configure(config):
+    if config.getvalue("usepdb"):
+        config.pluginmanager.register(PdbInvoke(), 'pdbinvoke')
+
+class pytestPDB:
+    """ Pseudo PDB that defers to the real pdb. """
+    item = None
+    collector = None
+
+    def set_trace(self):
+        """ invoke PDB set_trace debugging, dropping any IO capturing. """
+        frame = sys._getframe().f_back
+        item = self.item or self.collector
+
+        if item is not None:
+            capman = item.config.pluginmanager.getplugin("capturemanager")
+            out, err = capman.suspendcapture()
+            if hasattr(item, 'outerr'):
+                item.outerr = (item.outerr[0] + out, item.outerr[1] + err)
+            tw = py.io.TerminalWriter()
+            tw.line()
+            tw.sep(">", "PDB set_trace (IO-capturing turned off)")
+        py.std.pdb.Pdb().set_trace(frame)
+
+def pdbitem(item):
+    pytestPDB.item = item
+pytest_runtest_setup = pytest_runtest_call = pytest_runtest_teardown = pdbitem
+
+@pytest.mark.tryfirst
+def pytest_make_collect_report(__multicall__, collector):
+    try:
+        pytestPDB.collector = collector
+        return __multicall__.execute()
+    finally:
+        pytestPDB.collector = None
+
+def pytest_runtest_makereport():
+    pytestPDB.item = None
+    
+class PdbInvoke:
+    @pytest.mark.tryfirst
+    def pytest_runtest_makereport(self, item, call, __multicall__):
+        rep = __multicall__.execute()
+        if not call.excinfo or \
+            call.excinfo.errisinstance(pytest.skip.Exception) or \
+            call.excinfo.errisinstance(py.std.bdb.BdbQuit):
+            return rep
+        if "xfail" in rep.keywords:
+            return rep
+        # we assume that the above execute() suspended capturing
+        # XXX we re-use the TerminalReporter's terminalwriter
+        # because this seems to avoid some encoding related troubles
+        # for not completely clear reasons.
+        tw = item.config.pluginmanager.getplugin("terminalreporter")._tw
+        tw.line()
+        tw.sep(">", "traceback")
+        rep.toterminal(tw)
+        tw.sep(">", "entering PDB")
+        # A doctest.UnexpectedException is not useful for post_mortem.
+        # Use the underlying exception instead:
+        if isinstance(call.excinfo.value, py.std.doctest.UnexpectedException):
+            tb = call.excinfo.value.exc_info[2]
+        else:
+            tb = call.excinfo._excinfo[2]
+        post_mortem(tb)
+        rep._pdbshown = True
+        return rep
+
+def post_mortem(t):
+    pdb = py.std.pdb
+    class Pdb(pdb.Pdb):
+        def get_stack(self, f, t):
+            stack, i = pdb.Pdb.get_stack(self, f, t)
+            if f is None:
+                i = max(0, len(stack) - 1)
+                while i and stack[i][0].f_locals.get("__tracebackhide__", False):
+                    i-=1
+            return stack, i
+    p = Pdb()
+    p.reset()
+    p.interaction(None, t)

_pytest/pytester.py

@@ -0,0 +1,680 @@
+""" (disabled by default) support for testing py.test and py.test plugins. """
+
+import py, pytest
+import sys, os
+import re
+import inspect
+import time
+from fnmatch import fnmatch
+from _pytest.main import Session, EXIT_OK
+from py.builtin import print_
+from _pytest.core import HookRelay
+
+def pytest_addoption(parser):
+    group = parser.getgroup("pylib")
+    group.addoption('--no-tools-on-path',
+           action="store_true", dest="notoolsonpath", default=False,
+           help=("discover tools on PATH instead of going through py.cmdline.")
+    )
+
+def pytest_configure(config):
+    # This might be called multiple times. Only take the first.
+    global _pytest_fullpath
+    import pytest
+    try:
+        _pytest_fullpath
+    except NameError:
+        _pytest_fullpath = os.path.abspath(pytest.__file__.rstrip("oc"))
+        _pytest_fullpath = _pytest_fullpath.replace("$py.class", ".py")
+
+def pytest_funcarg___pytest(request):
+    return PytestArg(request)
+
+class PytestArg:
+    def __init__(self, request):
+        self.request = request
+
+    def gethookrecorder(self, hook):
+        hookrecorder = HookRecorder(hook._pm)
+        hookrecorder.start_recording(hook._hookspecs)
+        self.request.addfinalizer(hookrecorder.finish_recording)
+        return hookrecorder
+
+class ParsedCall:
+    def __init__(self, name, locals):
+        assert '_name' not in locals
+        self.__dict__.update(locals)
+        self.__dict__.pop('self')
+        self._name = name
+
+    def __repr__(self):
+        d = self.__dict__.copy()
+        del d['_name']
+        return "<ParsedCall %r(**%r)>" %(self._name, d)
+
+class HookRecorder:
+    def __init__(self, pluginmanager):
+        self._pluginmanager = pluginmanager
+        self.calls = []
+        self._recorders = {}
+
+    def start_recording(self, hookspecs):
+        if not isinstance(hookspecs, (list, tuple)):
+            hookspecs = [hookspecs]
+        for hookspec in hookspecs:
+            assert hookspec not in self._recorders
+            class RecordCalls:
+                _recorder = self
+            for name, method in vars(hookspec).items():
+                if name[0] != "_":
+                    setattr(RecordCalls, name, self._makecallparser(method))
+            recorder = RecordCalls()
+            self._recorders[hookspec] = recorder
+            self._pluginmanager.register(recorder)
+        self.hook = HookRelay(hookspecs, pm=self._pluginmanager,
+            prefix="pytest_")
+
+    def finish_recording(self):
+        for recorder in self._recorders.values():
+            self._pluginmanager.unregister(recorder)
+        self._recorders.clear()
+
+    def _makecallparser(self, method):
+        name = method.__name__
+        args, varargs, varkw, default = py.std.inspect.getargspec(method)
+        if not args or args[0] != "self":
+            args.insert(0, 'self')
+        fspec = py.std.inspect.formatargspec(args, varargs, varkw, default)
+        # we use exec because we want to have early type
+        # errors on wrong input arguments, using
+        # *args/**kwargs delays this and gives errors
+        # elsewhere
+        exec (py.code.compile("""
+            def %(name)s%(fspec)s:
+                        self._recorder.calls.append(
+                            ParsedCall(%(name)r, locals()))
+        """ % locals()))
+        return locals()[name]
+
+    def getcalls(self, names):
+        if isinstance(names, str):
+            names = names.split()
+        for name in names:
+            for cls in self._recorders:
+                if name in vars(cls):
+                    break
+            else:
+                raise ValueError("callname %r not found in %r" %(
+                name, self._recorders.keys()))
+        l = []
+        for call in self.calls:
+            if call._name in names:
+                l.append(call)
+        return l
+
+    def contains(self, entries):
+        __tracebackhide__ = True
+        from py.builtin import print_
+        i = 0
+        entries = list(entries)
+        backlocals = py.std.sys._getframe(1).f_locals
+        while entries:
+            name, check = entries.pop(0)
+            for ind, call in enumerate(self.calls[i:]):
+                if call._name == name:
+                    print_("NAMEMATCH", name, call)
+                    if eval(check, backlocals, call.__dict__):
+                        print_("CHECKERMATCH", repr(check), "->", call)
+                    else:
+                        print_("NOCHECKERMATCH", repr(check), "-", call)
+                        continue
+                    i += ind + 1
+                    break
+                print_("NONAMEMATCH", name, "with", call)
+            else:
+                py.test.fail("could not find %r check %r" % (name, check))
+
+    def popcall(self, name):
+        __tracebackhide__ = True
+        for i, call in enumerate(self.calls):
+            if call._name == name:
+                del self.calls[i]
+                return call
+        lines = ["could not find call %r, in:" % (name,)]
+        lines.extend(["  %s" % str(x) for x in self.calls])
+        py.test.fail("\n".join(lines))
+
+    def getcall(self, name):
+        l = self.getcalls(name)
+        assert len(l) == 1, (name, l)
+        return l[0]
+
+
+def pytest_funcarg__linecomp(request):
+    return LineComp()
+
+def pytest_funcarg__LineMatcher(request):
+    return LineMatcher
+
+def pytest_funcarg__testdir(request):
+    tmptestdir = TmpTestdir(request)
+    return tmptestdir
+
+rex_outcome = re.compile("(\d+) (\w+)")
+class RunResult:
+    def __init__(self, ret, outlines, errlines, duration):
+        self.ret = ret
+        self.outlines = outlines
+        self.errlines = errlines
+        self.stdout = LineMatcher(outlines)
+        self.stderr = LineMatcher(errlines)
+        self.duration = duration
+
+    def parseoutcomes(self):
+        for line in reversed(self.outlines):
+            if 'seconds' in line:
+                outcomes = rex_outcome.findall(line)
+                if outcomes:
+                    d = {}
+                    for num, cat in outcomes:
+                        d[cat] = int(num)
+                    return d
+
+class TmpTestdir:
+    def __init__(self, request):
+        self.request = request
+        self.Config = request.config.__class__
+        self._pytest = request.getfuncargvalue("_pytest")
+        # XXX remove duplication with tmpdir plugin
+        basetmp = request.config._tmpdirhandler.ensuretemp("testdir")
+        name = request.function.__name__
+        for i in range(100):
+            try:
+                tmpdir = basetmp.mkdir(name + str(i))
+            except py.error.EEXIST:
+                continue
+            break
+        # we need to create another subdir
+        # because Directory.collect() currently loads
+        # conftest.py from sibling directories
+        self.tmpdir = tmpdir.mkdir(name)
+        self.plugins = []
+        self._syspathremove = []
+        self.chdir() # always chdir
+        self.request.addfinalizer(self.finalize)
+
+    def __repr__(self):
+        return "<TmpTestdir %r>" % (self.tmpdir,)
+
+    def finalize(self):
+        for p in self._syspathremove:
+            py.std.sys.path.remove(p)
+        if hasattr(self, '_olddir'):
+            self._olddir.chdir()
+        # delete modules that have been loaded from tmpdir
+        for name, mod in list(sys.modules.items()):
+            if mod:
+                fn = getattr(mod, '__file__', None)
+                if fn and fn.startswith(str(self.tmpdir)):
+                    del sys.modules[name]
+
+    def getreportrecorder(self, obj):
+        if hasattr(obj, 'config'):
+            obj = obj.config
+        if hasattr(obj, 'hook'):
+            obj = obj.hook
+        assert hasattr(obj, '_hookspecs'), obj
+        reprec = ReportRecorder(obj)
+        reprec.hookrecorder = self._pytest.gethookrecorder(obj)
+        reprec.hook = reprec.hookrecorder.hook
+        return reprec
+
+    def chdir(self):
+        old = self.tmpdir.chdir()
+        if not hasattr(self, '_olddir'):
+            self._olddir = old
+
+    def _makefile(self, ext, args, kwargs):
+        items = list(kwargs.items())
+        if args:
+            source = py.builtin._totext("\n").join(
+                map(py.builtin._totext, args)) + py.builtin._totext("\n")
+            basename = self.request.function.__name__
+            items.insert(0, (basename, source))
+        ret = None
+        for name, value in items:
+            p = self.tmpdir.join(name).new(ext=ext)
+            source = py.builtin._totext(py.code.Source(value)).lstrip()
+            p.write(source.encode("utf-8"), "wb")
+            if ret is None:
+                ret = p
+        return ret
+
+
+    def makefile(self, ext, *args, **kwargs):
+        return self._makefile(ext, args, kwargs)
+
+    def makeini(self, source):
+        return self.makefile('cfg', setup=source)
+
+    def makeconftest(self, source):
+        return self.makepyfile(conftest=source)
+
+    def makeini(self, source):
+        return self.makefile('.ini', tox=source)
+
+    def getinicfg(self, source):
+        p = self.makeini(source)
+        return py.iniconfig.IniConfig(p)['pytest']
+
+    def makepyfile(self, *args, **kwargs):
+        return self._makefile('.py', args, kwargs)
+
+    def maketxtfile(self, *args, **kwargs):
+        return self._makefile('.txt', args, kwargs)
+
+    def syspathinsert(self, path=None):
+        if path is None:
+            path = self.tmpdir
+        py.std.sys.path.insert(0, str(path))
+        self._syspathremove.append(str(path))
+
+    def mkdir(self, name):
+        return self.tmpdir.mkdir(name)
+
+    def mkpydir(self, name):
+        p = self.mkdir(name)
+        p.ensure("__init__.py")
+        return p
+
+    Session = Session
+    def getnode(self, config, arg):
+        session = Session(config)
+        assert '::' not in str(arg)
+        p = py.path.local(arg)
+        x = session.fspath.bestrelpath(p)
+        config.hook.pytest_sessionstart(session=session)
+        res = session.perform_collect([x], genitems=False)[0]
+        config.hook.pytest_sessionfinish(session=session, exitstatus=EXIT_OK)
+        return res
+
+    def getpathnode(self, path):
+        config = self.parseconfigure(path)
+        session = Session(config)
+        x = session.fspath.bestrelpath(path)
+        config.hook.pytest_sessionstart(session=session)
+        res = session.perform_collect([x], genitems=False)[0]
+        config.hook.pytest_sessionfinish(session=session, exitstatus=EXIT_OK)
+        return res
+
+    def genitems(self, colitems):
+        session = colitems[0].session
+        result = []
+        for colitem in colitems:
+            result.extend(session.genitems(colitem))
+        return result
+
+    def runitem(self, source):
+        # used from runner functional tests
+        item = self.getitem(source)
+        # the test class where we are called from wants to provide the runner
+        testclassinstance = py.builtin._getimself(self.request.function)
+        runner = testclassinstance.getrunner()
+        return runner(item)
+
+    def inline_runsource(self, source, *cmdlineargs):
+        p = self.makepyfile(source)
+        l = list(cmdlineargs) + [p]
+        return self.inline_run(*l)
+
+    def inline_runsource1(self, *args):
+        args = list(args)
+        source = args.pop()
+        p = self.makepyfile(source)
+        l = list(args) + [p]
+        reprec = self.inline_run(*l)
+        reports = reprec.getreports("pytest_runtest_logreport")
+        assert len(reports) == 3, reports # setup/call/teardown
+        return reports[1]
+
+    def inline_genitems(self, *args):
+        return self.inprocess_run(list(args) + ['--collectonly'])
+
+    def inline_run(self, *args):
+        items, rec = self.inprocess_run(args)
+        return rec
+
+    def inprocess_run(self, args, plugins=None):
+        rec = []
+        items = []
+        class Collect:
+            def pytest_configure(x, config):
+                rec.append(self.getreportrecorder(config))
+            def pytest_itemcollected(self, item):
+                items.append(item)
+        if not plugins:
+            plugins = []
+        plugins.append(Collect())
+        ret = self.pytestmain(list(args), plugins=[Collect()])
+        reprec = rec[0]
+        reprec.ret = ret
+        assert len(rec) == 1
+        return items, reprec
+
+    def parseconfig(self, *args):
+        args = [str(x) for x in args]
+        for x in args:
+            if str(x).startswith('--basetemp'):
+                break
+        else:
+            args.append("--basetemp=%s" % self.tmpdir.dirpath('basetemp'))
+        import _pytest.core
+        config = _pytest.core._prepareconfig(args, self.plugins)
+        # the in-process pytest invocation needs to avoid leaking FDs
+        # so we register a "reset_capturings" callmon the capturing manager
+        # and make sure it gets called
+        config._cleanup.append(
+            config.pluginmanager.getplugin("capturemanager").reset_capturings)
+        import _pytest.config
+        self.request.addfinalizer(
+            lambda: _pytest.config.pytest_unconfigure(config))
+        return config
+
+    def parseconfigure(self, *args):
+        config = self.parseconfig(*args)
+        config.pluginmanager.do_configure(config)
+        self.request.addfinalizer(lambda:
+        config.pluginmanager.do_unconfigure(config))
+        return config
+
+    def getitem(self,  source, funcname="test_func"):
+        for item in self.getitems(source):
+            if item.name == funcname:
+                return item
+        assert 0, "%r item not found in module:\n%s" %(funcname, source)
+
+    def getitems(self,  source):
+        modcol = self.getmodulecol(source)
+        return self.genitems([modcol])
+
+    def getmodulecol(self,  source, configargs=(), withinit=False):
+        kw = {self.request.function.__name__: py.code.Source(source).strip()}
+        path = self.makepyfile(**kw)
+        if withinit:
+            self.makepyfile(__init__ = "#")
+        self.config = config = self.parseconfigure(path, *configargs)
+        node = self.getnode(config, path)
+        return node
+
+    def collect_by_name(self, modcol, name):
+        for colitem in modcol._memocollect():
+            if colitem.name == name:
+                return colitem
+
+    def popen(self, cmdargs, stdout, stderr, **kw):
+        env = os.environ.copy()
+        env['PYTHONPATH'] = os.pathsep.join(filter(None, [
+            str(os.getcwd()), env.get('PYTHONPATH', '')]))
+        kw['env'] = env
+        #print "env", env
+        return py.std.subprocess.Popen(cmdargs, stdout=stdout, stderr=stderr, **kw)
+
+    def pytestmain(self, *args, **kwargs):
+        class ResetCapturing:
+            @pytest.mark.trylast
+            def pytest_unconfigure(self, config):
+                capman = config.pluginmanager.getplugin("capturemanager")
+                capman.reset_capturings()
+        plugins = kwargs.setdefault("plugins", [])
+        rc = ResetCapturing()
+        plugins.append(rc)
+        return pytest.main(*args, **kwargs)
+
+    def run(self, *cmdargs):
+        return self._run(*cmdargs)
+
+    def _run(self, *cmdargs):
+        cmdargs = [str(x) for x in cmdargs]
+        p1 = self.tmpdir.join("stdout")
+        p2 = self.tmpdir.join("stderr")
+        print_("running", cmdargs, "curdir=", py.path.local())
+        f1 = p1.open("wb")
+        f2 = p2.open("wb")
+        now = time.time()
+        popen = self.popen(cmdargs, stdout=f1, stderr=f2,
+            close_fds=(sys.platform != "win32"))
+        ret = popen.wait()
+        f1.close()
+        f2.close()
+        out = p1.read("rb")
+        out = getdecoded(out).splitlines()
+        err = p2.read("rb")
+        err = getdecoded(err).splitlines()
+        def dump_lines(lines, fp):
+            try:
+                for line in lines:
+                    py.builtin.print_(line, file=fp)
+            except UnicodeEncodeError:
+                print("couldn't print to %s because of encoding" % (fp,))
+        dump_lines(out, sys.stdout)
+        dump_lines(err, sys.stderr)
+        return RunResult(ret, out, err, time.time()-now)
+
+    def runpybin(self, scriptname, *args):
+        fullargs = self._getpybinargs(scriptname) + args
+        return self.run(*fullargs)
+
+    def _getpybinargs(self, scriptname):
+        if not self.request.config.getvalue("notoolsonpath"):
+            # XXX we rely on script refering to the correct environment
+            # we cannot use "(py.std.sys.executable,script)"
+            # becaue on windows the script is e.g. a py.test.exe
+            return (py.std.sys.executable, _pytest_fullpath,)
+        else:
+            py.test.skip("cannot run %r with --no-tools-on-path" % scriptname)
+
+    def runpython(self, script, prepend=True):
+        if prepend:
+            s = self._getsysprepend()
+            if s:
+                script.write(s + "\n" + script.read())
+        return self.run(sys.executable, script)
+
+    def _getsysprepend(self):
+        if self.request.config.getvalue("notoolsonpath"):
+            s = "import sys;sys.path.insert(0,%r);" % str(py._pydir.dirpath())
+        else:
+            s = ""
+        return s
+
+    def runpython_c(self, command):
+        command = self._getsysprepend() + command
+        return self.run(py.std.sys.executable, "-c", command)
+
+    def runpytest(self, *args):
+        p = py.path.local.make_numbered_dir(prefix="runpytest-",
+            keep=None, rootdir=self.tmpdir)
+        args = ('--basetemp=%s' % p, ) + args
+        #for x in args:
+        #    if '--confcutdir' in str(x):
+        #        break
+        #else:
+        #    pass
+        #    args = ('--confcutdir=.',) + args
+        plugins = [x for x in self.plugins if isinstance(x, str)]
+        if plugins:
+            args = ('-p', plugins[0]) + args
+        return self.runpybin("py.test", *args)
+
+    def spawn_pytest(self, string, expect_timeout=10.0):
+        if self.request.config.getvalue("notoolsonpath"):
+            py.test.skip("--no-tools-on-path prevents running pexpect-spawn tests")
+        basetemp = self.tmpdir.mkdir("pexpect")
+        invoke = " ".join(map(str, self._getpybinargs("py.test")))
+        cmd = "%s --basetemp=%s %s" % (invoke, basetemp, string)
+        return self.spawn(cmd, expect_timeout=expect_timeout)
+
+    def spawn(self, cmd, expect_timeout=10.0):
+        pexpect = py.test.importorskip("pexpect", "2.4")
+        if hasattr(sys, 'pypy_version_info') and '64' in py.std.platform.machine():
+            pytest.skip("pypy-64 bit not supported")
+        if sys.platform == "darwin":
+            pytest.xfail("pexpect does not work reliably on darwin?!")
+        logfile = self.tmpdir.join("spawn.out")
+        child = pexpect.spawn(cmd, logfile=logfile.open("w"))
+        child.timeout = expect_timeout
+        return child
+
+def getdecoded(out):
+        try:
+            return out.decode("utf-8")
+        except UnicodeDecodeError:
+            return "INTERNAL not-utf8-decodeable, truncated string:\n%s" % (
+                    py.io.saferepr(out),)
+
+class ReportRecorder(object):
+    def __init__(self, hook):
+        self.hook = hook
+        self.pluginmanager = hook._pm
+        self.pluginmanager.register(self)
+
+    def getcall(self, name):
+        return self.hookrecorder.getcall(name)
+
+    def popcall(self, name):
+        return self.hookrecorder.popcall(name)
+
+    def getcalls(self, names):
+        """ return list of ParsedCall instances matching the given eventname. """
+        return self.hookrecorder.getcalls(names)
+
+    # functionality for test reports
+
+    def getreports(self, names="pytest_runtest_logreport pytest_collectreport"):
+        return [x.report for x in self.getcalls(names)]
+
+    def matchreport(self, inamepart="",
+        names="pytest_runtest_logreport pytest_collectreport", when=None):
+        """ return a testreport whose dotted import path matches """
+        l = []
+        for rep in self.getreports(names=names):
+            try:
+                if not when and rep.when != "call" and rep.passed:
+                    # setup/teardown passing reports - let's ignore those
+                    continue
+            except AttributeError:
+                pass
+            if when and getattr(rep, 'when', None) != when:
+                continue
+            if not inamepart or inamepart in rep.nodeid.split("::"):
+                l.append(rep)
+        if not l:
+            raise ValueError("could not find test report matching %r: no test reports at all!" %
+                (inamepart,))
+        if len(l) > 1:
+            raise ValueError("found more than one testreport matching %r: %s" %(
+                             inamepart, l))
+        return l[0]
+
+    def getfailures(self, names='pytest_runtest_logreport pytest_collectreport'):
+        return [rep for rep in self.getreports(names) if rep.failed]
+
+    def getfailedcollections(self):
+        return self.getfailures('pytest_collectreport')
+
+    def listoutcomes(self):
+        passed = []
+        skipped = []
+        failed = []
+        for rep in self.getreports("pytest_runtest_logreport"):
+            if rep.passed:
+                if rep.when == "call":
+                    passed.append(rep)
+            elif rep.skipped:
+                skipped.append(rep)
+            elif rep.failed:
+                failed.append(rep)
+        return passed, skipped, failed
+
+    def countoutcomes(self):
+        return [len(x) for x in self.listoutcomes()]
+
+    def assertoutcome(self, passed=0, skipped=0, failed=0):
+        realpassed, realskipped, realfailed = self.listoutcomes()
+        assert passed == len(realpassed)
+        assert skipped == len(realskipped)
+        assert failed == len(realfailed)
+
+    def clear(self):
+        self.hookrecorder.calls[:] = []
+
+    def unregister(self):
+        self.pluginmanager.unregister(self)
+        self.hookrecorder.finish_recording()
+
+class LineComp:
+    def __init__(self):
+        self.stringio = py.io.TextIO()
+
+    def assert_contains_lines(self, lines2):
+        """ assert that lines2 are contained (linearly) in lines1.
+            return a list of extralines found.
+        """
+        __tracebackhide__ = True
+        val = self.stringio.getvalue()
+        self.stringio.truncate(0)
+        self.stringio.seek(0)
+        lines1 = val.split("\n")
+        return LineMatcher(lines1).fnmatch_lines(lines2)
+
+class LineMatcher:
+    def __init__(self,  lines):
+        self.lines = lines
+
+    def str(self):
+        return "\n".join(self.lines)
+
+    def _getlines(self, lines2):
+        if isinstance(lines2, str):
+            lines2 = py.code.Source(lines2)
+        if isinstance(lines2, py.code.Source):
+            lines2 = lines2.strip().lines
+        return lines2
+
+    def fnmatch_lines_random(self, lines2):
+        lines2 = self._getlines(lines2)
+        for line in lines2:
+            for x in self.lines:
+                if line == x or fnmatch(x, line):
+                    print_("matched: ", repr(line))
+                    break
+            else:
+                raise ValueError("line %r not found in output" % line)
+
+    def fnmatch_lines(self, lines2):
+        def show(arg1, arg2):
+            py.builtin.print_(arg1, arg2, file=py.std.sys.stderr)
+        lines2 = self._getlines(lines2)
+        lines1 = self.lines[:]
+        nextline = None
+        extralines = []
+        __tracebackhide__ = True
+        for line in lines2:
+            nomatchprinted = False
+            while lines1:
+                nextline = lines1.pop(0)
+                if line == nextline:
+                    show("exact match:", repr(line))
+                    break
+                elif fnmatch(nextline, line):
+                    show("fnmatch:", repr(line))
+                    show("   with:", repr(nextline))
+                    break
+                else:
+                    if not nomatchprinted:
+                        show("nomatch:", repr(line))
+                        nomatchprinted = True
+                    show("    and:", repr(nextline))
+                extralines.append(nextline)
+            else:
+                py.test.fail("remains unmatched: %r, see stderr" % (line,))

_pytest/recwarn.py

@@ -1,68 +1,46 @@
-"""
-helpers for asserting deprecation and other warnings. 
-
-Example usage 
----------------------
-
-You can use the ``recwarn`` funcarg to track 
-warnings within a test function:
-
-.. sourcecode:: python
-
-    def test_hello(recwarn):
-        from warnings import warn
-        warn("hello", DeprecationWarning)
-        w = recwarn.pop(DeprecationWarning)
-        assert issubclass(w.category, DeprecationWarning)
-        assert 'hello' in str(w.message)
-        assert w.filename
-        assert w.lineno
-
-You can also call a global helper for checking
-taht a certain function call yields a Deprecation
-warning:
-
-.. sourcecode:: python
-
-    import py
-            
-    def test_global():
-        py.test.deprecated_call(myfunction, 17)
-        
-        
-"""
+""" recording warnings during test function execution. """
 
 import py
-import os
+import sys, os
 
 def pytest_funcarg__recwarn(request):
     """Return a WarningsRecorder instance that provides these methods:
 
     * ``pop(category=None)``: return last warning matching the category.
-    * ``clear()``: clear list of warnings 
+    * ``clear()``: clear list of warnings
+   
+    See http://docs.python.org/library/warnings.html for information
+    on warning categories.
     """
-    warnings = WarningsRecorder()
-    request.addfinalizer(warnings.finalize)
-    return warnings
+    if sys.version_info >= (2,7):
+        import warnings
+        oldfilters = warnings.filters[:]
+        warnings.simplefilter('default')
+        def reset_filters():
+            warnings.filters[:] = oldfilters
+        request.addfinalizer(reset_filters)
+    wrec = WarningsRecorder()
+    request.addfinalizer(wrec.finalize)
+    return wrec
 
 def pytest_namespace():
     return {'deprecated_call': deprecated_call}
 
 def deprecated_call(func, *args, **kwargs):
-    """ assert that calling func(*args, **kwargs)
-        triggers a DeprecationWarning. 
-    """ 
+    """ assert that calling ``func(*args, **kwargs)``
+    triggers a DeprecationWarning.
+    """
     warningmodule = py.std.warnings
     l = []
     oldwarn_explicit = getattr(warningmodule, 'warn_explicit')
-    def warn_explicit(*args, **kwargs): 
-        l.append(args) 
+    def warn_explicit(*args, **kwargs):
+        l.append(args)
         oldwarn_explicit(*args, **kwargs)
     oldwarn = getattr(warningmodule, 'warn')
-    def warn(*args, **kwargs): 
-        l.append(args) 
+    def warn(*args, **kwargs):
+        l.append(args)
         oldwarn(*args, **kwargs)
-        
+
     warningmodule.warn_explicit = warn_explicit
     warningmodule.warn = warn
     try:
@@ -93,10 +71,10 @@ class WarningsRecorder:
             self.list.append(RecordedWarning(
                 message, category, filename, lineno, line))
             try:
-                self.old_showwarning(message, category, 
+                self.old_showwarning(message, category,
                     filename, lineno, line=line)
             except TypeError:
-                # < python2.6 
+                # < python2.6
                 self.old_showwarning(message, category, filename, lineno)
         self.old_showwarning = warningmodule.showwarning
         warningmodule.showwarning = showwarning
@@ -114,7 +92,7 @@ class WarningsRecorder:
     #    warnings.onceregistry.clear()
     #    warnings.__warningregistry__.clear()
 
-    def clear(self): 
+    def clear(self):
         self.list[:] = []
 
     def finalize(self):

_pytest/resultlog.py

@@ -1,31 +1,26 @@
-"""non-xml machine-readable logging of test results. 
-   Useful for buildbot integration code.  See the `PyPy-test`_ 
-   web page for post-processing. 
-
-.. _`PyPy-test`: http://codespeak.net:8099/summary
- 
-""" 
+""" (disabled by default) create result information in a plain text file. """
 
 import py
-from py.builtin import print_
 
 def pytest_addoption(parser):
-    group = parser.getgroup("resultlog", "resultlog plugin options")
-    group.addoption('--resultlog', action="store", dest="resultlog", metavar="path", default=None,
-           help="path for machine-readable result log.")
+    group = parser.getgroup("terminal reporting", "resultlog plugin options")
+    group.addoption('--resultlog', action="store", dest="resultlog",
+        metavar="path", default=None,
+        help="path for machine-readable result log.")
 
 def pytest_configure(config):
     resultlog = config.option.resultlog
-    if resultlog:
+    # prevent opening resultlog on slave nodes (xdist)
+    if resultlog and not hasattr(config, 'slaveinput'):
         logfile = open(resultlog, 'w', 1) # line buffered
-        config._resultlog = ResultLog(config, logfile) 
+        config._resultlog = ResultLog(config, logfile)
         config.pluginmanager.register(config._resultlog)
 
 def pytest_unconfigure(config):
     resultlog = getattr(config, '_resultlog', None)
     if resultlog:
         resultlog.logfile.close()
-        del config._resultlog 
+        del config._resultlog
         config.pluginmanager.unregister(resultlog)
 
 def generic_path(item):
@@ -40,7 +35,7 @@ def generic_path(item):
                 gpath.append(':')
                 fspart = False
             else:
-                gpath.append('.')            
+                gpath.append('.')
         else:
             gpath.append('/')
             fspart = True
@@ -50,49 +45,54 @@ def generic_path(item):
         gpath.append(name)
         fspath = newfspath
     return ''.join(gpath)
-        
+
 class ResultLog(object):
     def __init__(self, config, logfile):
         self.config = config
         self.logfile = logfile # preferably line buffered
 
-    def write_log_entry(self, testpath, shortrepr, longrepr):
-        print_("%s %s" % (shortrepr, testpath), file=self.logfile)
+    def write_log_entry(self, testpath, lettercode, longrepr):
+        py.builtin.print_("%s %s" % (lettercode, testpath), file=self.logfile)
         for line in longrepr.splitlines():
-            print_(" %s" % line, file=self.logfile)
+            py.builtin.print_(" %s" % line, file=self.logfile)
 
-    def log_outcome(self, node, shortrepr, longrepr):
-        testpath = generic_path(node)
-        self.write_log_entry(testpath, shortrepr, longrepr) 
+    def log_outcome(self, report, lettercode, longrepr):
+        testpath = getattr(report, 'nodeid', None)
+        if testpath is None:
+            testpath = report.fspath
+        self.write_log_entry(testpath, lettercode, longrepr)
 
     def pytest_runtest_logreport(self, report):
+        if report.when != "call" and report.passed:
+            return
         res = self.config.hook.pytest_report_teststatus(report=report)
-        if res is not None:
-            code = res[1]
-        else:
-            code = report.shortrepr
+        code = res[1]
         if code == 'x':
             longrepr = str(report.longrepr)
-        elif code == 'P':
+        elif code == 'X':
             longrepr = ''
         elif report.passed:
             longrepr = ""
         elif report.failed:
-            longrepr = str(report.longrepr) 
+            longrepr = str(report.longrepr)
         elif report.skipped:
-            longrepr = str(report.longrepr.reprcrash.message)
-        self.log_outcome(report.item, code, longrepr) 
+            longrepr = str(report.longrepr[2])
+        self.log_outcome(report, code, longrepr)
 
     def pytest_collectreport(self, report):
         if not report.passed:
-            if report.failed: 
+            if report.failed:
                 code = "F"
+                longrepr = str(report.longrepr.reprcrash)
             else:
                 assert report.skipped
                 code = "S"
-            longrepr = str(report.longrepr.reprcrash)
-            self.log_outcome(report.collector, code, longrepr)    
+                longrepr = "%s:%d: %s" % report.longrepr
+            self.log_outcome(report, code, longrepr)
 
     def pytest_internalerror(self, excrepr):
-        path = excrepr.reprcrash.path 
+        reprcrash = getattr(excrepr, 'reprcrash', None)
+        path = getattr(reprcrash, "path", None)
+        if path is None:
+            path = "cwd:%s" % py.path.local()
         self.write_log_entry(path, '!', str(excrepr))

_pytest/runner.py

@@ -0,0 +1,432 @@
+""" basic collect and runtest protocol implementations """
+
+import py, sys, time
+from py._code.code import TerminalRepr
+
+def pytest_namespace():
+    return {
+        'fail'         : fail,
+        'skip'         : skip,
+        'importorskip' : importorskip,
+        'exit'         : exit,
+    }
+
+#
+# pytest plugin hooks
+
+def pytest_addoption(parser):
+    group = parser.getgroup("terminal reporting", "reporting", after="general")
+    group.addoption('--durations',
+         action="store", type="int", default=None, metavar="N",
+         help="show N slowest setup/test durations (N=0 for all)."),
+
+def pytest_terminal_summary(terminalreporter):
+    durations = terminalreporter.config.option.durations
+    if durations is None:
+        return
+    tr = terminalreporter
+    dlist = []
+    for replist in tr.stats.values():
+        for rep in replist:
+            if hasattr(rep, 'duration'):
+                dlist.append(rep)
+    if not dlist:
+        return
+    dlist.sort(key=lambda x: x.duration)
+    dlist.reverse()
+    if not durations:
+        tr.write_sep("=", "slowest test durations")
+    else:
+        tr.write_sep("=", "slowest %s test durations" % durations)
+        dlist = dlist[:durations]
+
+    for rep in dlist:
+        nodeid = rep.nodeid.replace("::()::", "::")
+        tr.write_line("%02.2fs %-8s %s" %
+            (rep.duration, rep.when, nodeid))
+
+def pytest_sessionstart(session):
+    session._setupstate = SetupState()
+def pytest_sessionfinish(session):
+    session._setupstate.teardown_all()
+
+class NodeInfo:
+    def __init__(self, location):
+        self.location = location
+
+def pytest_runtest_protocol(item, nextitem):
+    item.ihook.pytest_runtest_logstart(
+        nodeid=item.nodeid, location=item.location,
+    )
+    runtestprotocol(item, nextitem=nextitem)
+    return True
+
+def runtestprotocol(item, log=True, nextitem=None):
+    rep = call_and_report(item, "setup", log)
+    reports = [rep]
+    if rep.passed:
+        reports.append(call_and_report(item, "call", log))
+    reports.append(call_and_report(item, "teardown", log,
+        nextitem=nextitem))
+    return reports
+
+def pytest_runtest_setup(item):
+    item.session._setupstate.prepare(item)
+
+def pytest_runtest_call(item):
+    item.runtest()
+
+def pytest_runtest_teardown(item, nextitem):
+    item.session._setupstate.teardown_exact(item, nextitem)
+
+def pytest_report_teststatus(report):
+    if report.when in ("setup", "teardown"):
+        if report.failed:
+            #      category, shortletter, verbose-word
+            return "error", "E", "ERROR"
+        elif report.skipped:
+            return "skipped", "s", "SKIPPED"
+        else:
+            return "", "", ""
+
+
+#
+# Implementation
+
+def call_and_report(item, when, log=True, **kwds):
+    call = call_runtest_hook(item, when, **kwds)
+    hook = item.ihook
+    report = hook.pytest_runtest_makereport(item=item, call=call)
+    if log:
+        hook.pytest_runtest_logreport(report=report)
+    return report
+
+def call_runtest_hook(item, when, **kwds):
+    hookname = "pytest_runtest_" + when
+    ihook = getattr(item.ihook, hookname)
+    return CallInfo(lambda: ihook(item=item, **kwds), when=when)
+
+class CallInfo:
+    """ Result/Exception info a function invocation. """
+    #: None or ExceptionInfo object.
+    excinfo = None
+    def __init__(self, func, when):
+        #: context of invocation: one of "setup", "call",
+        #: "teardown", "memocollect"
+        self.when = when
+        self.start = time.time()
+        try:
+            try:
+                self.result = func()
+            except KeyboardInterrupt:
+                raise
+            except:
+                self.excinfo = py.code.ExceptionInfo()
+        finally:
+            self.stop = time.time()
+
+    def __repr__(self):
+        if self.excinfo:
+            status = "exception: %s" % str(self.excinfo.value)
+        else:
+            status = "result: %r" % (self.result,)
+        return "<CallInfo when=%r %s>" % (self.when, status)
+
+def getslaveinfoline(node):
+    try:
+        return node._slaveinfocache
+    except AttributeError:
+        d = node.slaveinfo
+        ver = "%s.%s.%s" % d['version_info'][:3]
+        node._slaveinfocache = s = "[%s] %s -- Python %s %s" % (
+            d['id'], d['sysplatform'], ver, d['executable'])
+        return s
+
+class BaseReport(object):
+
+    def __init__(self, **kw):
+        self.__dict__.update(kw)
+
+    def toterminal(self, out):
+        longrepr = self.longrepr
+        if hasattr(self, 'node'):
+            out.line(getslaveinfoline(self.node))
+        if hasattr(longrepr, 'toterminal'):
+            longrepr.toterminal(out)
+        else:
+            out.line(str(longrepr))
+
+    passed = property(lambda x: x.outcome == "passed")
+    failed = property(lambda x: x.outcome == "failed")
+    skipped = property(lambda x: x.outcome == "skipped")
+
+    @property
+    def fspath(self):
+        return self.nodeid.split("::")[0]
+
+def pytest_runtest_makereport(item, call):
+    when = call.when
+    duration = call.stop-call.start
+    keywords = dict([(x,1) for x in item.keywords])
+    excinfo = call.excinfo
+    if not call.excinfo:
+        outcome = "passed"
+        longrepr = None
+    else:
+        excinfo = call.excinfo
+        if not isinstance(excinfo, py.code.ExceptionInfo):
+            outcome = "failed"
+            longrepr = excinfo
+        elif excinfo.errisinstance(py.test.skip.Exception):
+            outcome = "skipped"
+            r = excinfo._getreprcrash()
+            longrepr = (str(r.path), r.lineno, r.message)
+        else:
+            outcome = "failed"
+            if call.when == "call":
+                longrepr = item.repr_failure(excinfo)
+            else: # exception in setup or teardown
+                longrepr = item._repr_failure_py(excinfo)
+    return TestReport(item.nodeid, item.location,
+                      keywords, outcome, longrepr, when,
+                      duration=duration)
+
+class TestReport(BaseReport):
+    """ Basic test report object (also used for setup and teardown calls if
+    they fail).
+    """
+    def __init__(self, nodeid, location,
+            keywords, outcome, longrepr, when, sections=(), duration=0, **extra):
+        #: normalized collection node id
+        self.nodeid = nodeid
+
+        #: a (filesystempath, lineno, domaininfo) tuple indicating the
+        #: actual location of a test item - it might be different from the
+        #: collected one e.g. if a method is inherited from a different module.
+        self.location = location
+
+        #: a name -> value dictionary containing all keywords and
+        #: markers associated with a test invocation.
+        self.keywords = keywords
+
+        #: test outcome, always one of "passed", "failed", "skipped".
+        self.outcome = outcome
+
+        #: None or a failure representation.
+        self.longrepr = longrepr
+
+        #: one of 'setup', 'call', 'teardown' to indicate runtest phase.
+        self.when = when
+
+        #: list of (secname, data) extra information which needs to
+        #: marshallable
+        self.sections = list(sections)
+
+        #: time it took to run just the test
+        self.duration = duration
+
+        self.__dict__.update(extra)
+
+    def __repr__(self):
+        return "<TestReport %r when=%r outcome=%r>" % (
+            self.nodeid, self.when, self.outcome)
+
+class TeardownErrorReport(BaseReport):
+    outcome = "failed"
+    when = "teardown"
+    def __init__(self, longrepr, **extra):
+        self.longrepr = longrepr
+        self.sections = []
+        self.__dict__.update(extra)
+
+def pytest_make_collect_report(collector):
+    call = CallInfo(collector._memocollect, "memocollect")
+    longrepr = None
+    if not call.excinfo:
+        outcome = "passed"
+    else:
+        if call.excinfo.errisinstance(py.test.skip.Exception):
+            outcome = "skipped"
+            r = collector._repr_failure_py(call.excinfo, "line").reprcrash
+            longrepr = (str(r.path), r.lineno, r.message)
+        else:
+            outcome = "failed"
+            errorinfo = collector.repr_failure(call.excinfo)
+            if not hasattr(errorinfo, "toterminal"):
+                errorinfo = CollectErrorRepr(errorinfo)
+            longrepr = errorinfo
+    return CollectReport(collector.nodeid, outcome, longrepr,
+        getattr(call, 'result', None))
+
+class CollectReport(BaseReport):
+    def __init__(self, nodeid, outcome, longrepr, result, sections=(), **extra):
+        self.nodeid = nodeid
+        self.outcome = outcome
+        self.longrepr = longrepr
+        self.result = result or []
+        self.sections = list(sections)
+        self.__dict__.update(extra)
+
+    @property
+    def location(self):
+        return (self.fspath, None, self.fspath)
+
+    def __repr__(self):
+        return "<CollectReport %r lenresult=%s outcome=%r>" % (
+                self.nodeid, len(self.result), self.outcome)
+
+class CollectErrorRepr(TerminalRepr):
+    def __init__(self, msg):
+        self.longrepr = msg
+    def toterminal(self, out):
+        out.line(str(self.longrepr), red=True)
+
+class SetupState(object):
+    """ shared state for setting up/tearing down test items or collectors. """
+    def __init__(self):
+        self.stack = []
+        self._finalizers = {}
+
+    def addfinalizer(self, finalizer, colitem):
+        """ attach a finalizer to the given colitem.
+        if colitem is None, this will add a finalizer that
+        is called at the end of teardown_all().
+        """
+        assert hasattr(finalizer, '__call__')
+        #assert colitem in self.stack
+        self._finalizers.setdefault(colitem, []).append(finalizer)
+
+    def _pop_and_teardown(self):
+        colitem = self.stack.pop()
+        self._teardown_with_finalization(colitem)
+
+    def _callfinalizers(self, colitem):
+        finalizers = self._finalizers.pop(colitem, None)
+        while finalizers:
+            fin = finalizers.pop()
+            fin()
+
+    def _teardown_with_finalization(self, colitem):
+        self._callfinalizers(colitem)
+        if colitem:
+            colitem.teardown()
+        for colitem in self._finalizers:
+            assert colitem is None or colitem in self.stack
+
+    def teardown_all(self):
+        while self.stack:
+            self._pop_and_teardown()
+        self._teardown_with_finalization(None)
+        assert not self._finalizers
+
+    def teardown_exact(self, item, nextitem):
+        needed_collectors = nextitem and nextitem.listchain() or []
+        self._teardown_towards(needed_collectors)
+
+    def _teardown_towards(self, needed_collectors):
+        while self.stack:
+            if self.stack == needed_collectors[:len(self.stack)]:
+                break
+            self._pop_and_teardown()
+
+    def prepare(self, colitem):
+        """ setup objects along the collector chain to the test-method
+            and teardown previously setup objects."""
+        needed_collectors = colitem.listchain()
+        self._teardown_towards(needed_collectors)
+
+        # check if the last collection node has raised an error
+        for col in self.stack:
+            if hasattr(col, '_prepare_exc'):
+                py.builtin._reraise(*col._prepare_exc)
+        for col in needed_collectors[len(self.stack):]:
+            self.stack.append(col)
+            try:
+                col.setup()
+            except Exception:
+                col._prepare_exc = sys.exc_info()
+                raise
+
+# =============================================================
+# Test OutcomeExceptions and helpers for creating them.
+
+
+class OutcomeException(Exception):
+    """ OutcomeException and its subclass instances indicate and
+        contain info about test and collection outcomes.
+    """
+    def __init__(self, msg=None, pytrace=True):
+        self.msg = msg
+        self.pytrace = pytrace
+
+    def __repr__(self):
+        if self.msg:
+            return str(self.msg)
+        return "<%s instance>" %(self.__class__.__name__,)
+    __str__ = __repr__
+
+class Skipped(OutcomeException):
+    # XXX hackish: on 3k we fake to live in the builtins
+    # in order to have Skipped exception printing shorter/nicer
+    __module__ = 'builtins'
+
+class Failed(OutcomeException):
+    """ raised from an explicit call to py.test.fail() """
+    __module__ = 'builtins'
+
+class Exit(KeyboardInterrupt):
+    """ raised for immediate program exits (no tracebacks/summaries)"""
+    def __init__(self, msg="unknown reason"):
+        self.msg = msg
+        KeyboardInterrupt.__init__(self, msg)
+
+# exposed helper methods
+
+def exit(msg):
+    """ exit testing process as if KeyboardInterrupt was triggered. """
+    __tracebackhide__ = True
+    raise Exit(msg)
+
+exit.Exception = Exit
+
+def skip(msg=""):
+    """ skip an executing test with the given message.  Note: it's usually
+    better to use the py.test.mark.skipif marker to declare a test to be
+    skipped under certain conditions like mismatching platforms or
+    dependencies.  See the pytest_skipping plugin for details.
+    """
+    __tracebackhide__ = True
+    raise Skipped(msg=msg)
+skip.Exception = Skipped
+
+def fail(msg="", pytrace=True):
+    """ explicitely fail an currently-executing test with the given Message.
+    if @pytrace is not True the msg represents the full failure information.
+    """
+    __tracebackhide__ = True
+    raise Failed(msg=msg, pytrace=pytrace)
+fail.Exception = Failed
+
+
+def importorskip(modname, minversion=None):
+    """ return imported module if it has a higher __version__ than the
+    optionally specified 'minversion' - otherwise call py.test.skip()
+    with a message detailing the mismatch.
+    """
+    __tracebackhide__ = True
+    compile(modname, '', 'eval') # to catch syntaxerrors
+    try:
+        mod = __import__(modname, None, None, ['__doc__'])
+    except ImportError:
+        py.test.skip("could not import %r" %(modname,))
+    if minversion is None:
+        return mod
+    verattr = getattr(mod, '__version__', None)
+    if isinstance(minversion, str):
+        minver = minversion.split(".")
+    else:
+        minver = list(minversion)
+    if verattr is None or verattr.split(".") < minver:
+        py.test.skip("module %r has __version__ %r, required is: %r" %(
+                     modname, verattr, minversion))
+    return mod

_pytest/skipping.py

@@ -0,0 +1,263 @@
+""" support for skip/xfail functions and markers. """
+
+import py, pytest
+import sys
+
+def pytest_addoption(parser):
+    group = parser.getgroup("general")
+    group.addoption('--runxfail',
+           action="store_true", dest="runxfail", default=False,
+           help="run tests even if they are marked xfail")
+
+def pytest_configure(config):
+    config.addinivalue_line("markers",
+        "skipif(*conditions): skip the given test function if evaluation "
+        "of all conditions has a True value.  Evaluation happens within the "
+        "module global context. Example: skipif('sys.platform == \"win32\"') "
+        "skips the test if we are on the win32 platform. "
+    )
+    config.addinivalue_line("markers",
+        "xfail(*conditions, reason=None, run=True): mark the the test function "
+        "as an expected failure. Optionally specify a reason and run=False "
+        "if you don't even want to execute the test function. Any positional "
+        "condition strings will be evaluated (like with skipif) and if one is "
+        "False the marker will not be applied."
+    )
+
+def pytest_namespace():
+    return dict(xfail=xfail)
+
+class XFailed(pytest.fail.Exception):
+    """ raised from an explicit call to py.test.xfail() """
+
+def xfail(reason=""):
+    """ xfail an executing test or setup functions with the given reason."""
+    __tracebackhide__ = True
+    raise XFailed(reason)
+xfail.Exception = XFailed
+
+class MarkEvaluator:
+    def __init__(self, item, name):
+        self.item = item
+        self.name = name
+
+    @property
+    def holder(self):
+        return self.item.keywords.get(self.name, None)
+    def __bool__(self):
+        return bool(self.holder)
+    __nonzero__ = __bool__
+
+    def wasvalid(self):
+        return not hasattr(self, 'exc')
+
+    def istrue(self):
+        try:
+            return self._istrue()
+        except KeyboardInterrupt:
+            raise
+        except:
+            self.exc = sys.exc_info()
+            if isinstance(self.exc[1], SyntaxError):
+                msg = [" " * (self.exc[1].offset + 4) + "^",]
+                msg.append("SyntaxError: invalid syntax")
+            else:
+                msg = py.std.traceback.format_exception_only(*self.exc[:2])
+            pytest.fail("Error evaluating %r expression\n"
+                        "    %s\n"
+                        "%s"
+                        %(self.name, self.expr, "\n".join(msg)),
+                        pytrace=False)
+
+    def _getglobals(self):
+        d = {'os': py.std.os, 'sys': py.std.sys, 'config': self.item.config}
+        func = self.item.obj
+        try:
+            d.update(func.__globals__)
+        except AttributeError:
+            d.update(func.func_globals)
+        return d
+
+    def _istrue(self):
+        if self.holder:
+            d = self._getglobals()
+            if self.holder.args:
+                self.result = False
+                for expr in self.holder.args:
+                    self.expr = expr
+                    if isinstance(expr, str):
+                        result = cached_eval(self.item.config, expr, d)
+                    else:
+                        pytest.fail("expression is not a string")
+                    if result:
+                        self.result = True
+                        self.expr = expr
+                        break
+            else:
+                self.result = True
+        return getattr(self, 'result', False)
+
+    def get(self, attr, default=None):
+        return self.holder.kwargs.get(attr, default)
+
+    def getexplanation(self):
+        expl = self.get('reason', None)
+        if not expl:
+            if not hasattr(self, 'expr'):
+                return ""
+            else:
+                return "condition: " + str(self.expr)
+        return expl
+
+
+def pytest_runtest_setup(item):
+    if not isinstance(item, pytest.Function):
+        return
+    evalskip = MarkEvaluator(item, 'skipif')
+    if evalskip.istrue():
+        py.test.skip(evalskip.getexplanation())
+    item._evalxfail = MarkEvaluator(item, 'xfail')
+    check_xfail_no_run(item)
+
+def pytest_pyfunc_call(pyfuncitem):
+    check_xfail_no_run(pyfuncitem)
+
+def check_xfail_no_run(item):
+    if not item.config.option.runxfail:
+        evalxfail = item._evalxfail
+        if evalxfail.istrue():
+            if not evalxfail.get('run', True):
+                py.test.xfail("[NOTRUN] " + evalxfail.getexplanation())
+
+def pytest_runtest_makereport(__multicall__, item, call):
+    if not isinstance(item, pytest.Function):
+        return
+    if not (call.excinfo and
+        call.excinfo.errisinstance(py.test.xfail.Exception)):
+        evalxfail = getattr(item, '_evalxfail', None)
+        if not evalxfail:
+            return
+    if call.excinfo and call.excinfo.errisinstance(py.test.xfail.Exception):
+        if not item.config.getvalue("runxfail"):
+            rep = __multicall__.execute()
+            rep.keywords['xfail'] = "reason: " + call.excinfo.value.msg
+            rep.outcome = "skipped"
+            return rep
+    rep = __multicall__.execute()
+    evalxfail = item._evalxfail
+    if not item.config.option.runxfail:
+        if evalxfail.wasvalid() and evalxfail.istrue():
+            if call.excinfo:
+                rep.outcome = "skipped"
+                rep.keywords['xfail'] = evalxfail.getexplanation()
+            elif call.when == "call":
+                rep.outcome = "failed"
+                rep.keywords['xfail'] = evalxfail.getexplanation()
+            return rep
+    if 'xfail' in rep.keywords:
+        del rep.keywords['xfail']
+    return rep
+
+# called by terminalreporter progress reporting
+def pytest_report_teststatus(report):
+    if 'xfail' in report.keywords:
+        if report.skipped:
+            return "xfailed", "x", "xfail"
+        elif report.failed:
+            return "xpassed", "X", "XPASS"
+
+# called by the terminalreporter instance/plugin
+def pytest_terminal_summary(terminalreporter):
+    tr = terminalreporter
+    if not tr.reportchars:
+        #for name in "xfailed skipped failed xpassed":
+        #    if not tr.stats.get(name, 0):
+        #        tr.write_line("HINT: use '-r' option to see extra "
+        #              "summary info about tests")
+        #        break
+        return
+
+    lines = []
+    for char in tr.reportchars:
+        if char == "x":
+            show_xfailed(terminalreporter, lines)
+        elif char == "X":
+            show_xpassed(terminalreporter, lines)
+        elif char in "fF":
+            show_simple(terminalreporter, lines, 'failed', "FAIL %s")
+        elif char in "sS":
+            show_skipped(terminalreporter, lines)
+        elif char == "E":
+            show_simple(terminalreporter, lines, 'error', "ERROR %s")
+    if lines:
+        tr._tw.sep("=", "short test summary info")
+        for line in lines:
+            tr._tw.line(line)
+
+def show_simple(terminalreporter, lines, stat, format):
+    tw = terminalreporter._tw
+    failed = terminalreporter.stats.get(stat)
+    if failed:
+        for rep in failed:
+            pos = rep.nodeid
+            lines.append(format %(pos, ))
+
+def show_xfailed(terminalreporter, lines):
+    xfailed = terminalreporter.stats.get("xfailed")
+    if xfailed:
+        for rep in xfailed:
+            pos = rep.nodeid
+            reason = rep.keywords['xfail']
+            lines.append("XFAIL %s" % (pos,))
+            if reason:
+                lines.append("  " + str(reason))
+
+def show_xpassed(terminalreporter, lines):
+    xpassed = terminalreporter.stats.get("xpassed")
+    if xpassed:
+        for rep in xpassed:
+            pos = rep.nodeid
+            reason = rep.keywords['xfail']
+            lines.append("XPASS %s %s" %(pos, reason))
+
+def cached_eval(config, expr, d):
+    if not hasattr(config, '_evalcache'):
+        config._evalcache = {}
+    try:
+        return config._evalcache[expr]
+    except KeyError:
+        #import sys
+        #print >>sys.stderr, ("cache-miss: %r" % expr)
+        exprcode = py.code.compile(expr, mode="eval")
+        config._evalcache[expr] = x = eval(exprcode, d)
+        return x
+
+
+def folded_skips(skipped):
+    d = {}
+    for event in skipped:
+        key = event.longrepr
+        assert len(key) == 3, (event, key)
+        d.setdefault(key, []).append(event)
+    l = []
+    for key, events in d.items():
+        l.append((len(events),) + key)
+    return l
+
+def show_skipped(terminalreporter, lines):
+    tr = terminalreporter
+    skipped = tr.stats.get('skipped', [])
+    if skipped:
+        #if not tr.hasopt('skipped'):
+        #    tr.write_line(
+        #        "%d skipped tests, specify -rs for more info" %
+        #        len(skipped))
+        #    return
+        fskips = folded_skips(skipped)
+        if fskips:
+            #tr.write_sep("_", "skipped test summary")
+            for num, fspath, lineno, reason in fskips:
+                if reason.startswith("Skipped: "):
+                    reason = reason[9:]
+                lines.append("SKIP [%d] %s:%d: %s" %
+                    (num, fspath, lineno, reason))

_pytest/standalonetemplate.py

@@ -15,7 +15,7 @@ class DictImporter(object):
     def find_module(self, fullname, path=None):
         if fullname in self.sources:
             return self
-        if fullname+'.__init__' in self.sources:
+        if fullname + '.__init__' in self.sources:
             return self
         return None
 
@@ -26,30 +26,30 @@ class DictImporter(object):
             s = self.sources[fullname]
             is_pkg = False
         except KeyError:
-            s = self.sources[fullname+'.__init__']
+            s = self.sources[fullname + '.__init__']
             is_pkg = True
-        
+
         co = compile(s, fullname, 'exec')
         module = sys.modules.setdefault(fullname, ModuleType(fullname))
         module.__file__ = "%s/%s" % (__file__, fullname)
         module.__loader__ = self
         if is_pkg:
             module.__path__ = [fullname]
-            
+
         do_exec(co, module.__dict__)
         return sys.modules[fullname]
 
     def get_source(self, name):
         res = self.sources.get(name)
         if res is None:
-            res = self.sources.get(name+'.__init__')
+            res = self.sources.get(name + '.__init__')
         return res
 
 if __name__ == "__main__":
-    if sys.version_info >= (3,0):
+    if sys.version_info >= (3, 0):
         exec("def do_exec(co, loc): exec(co, loc)\n")
         import pickle
-        sources = sources.encode("ascii") # ensure bytes 
+        sources = sources.encode("ascii") # ensure bytes
         sources = pickle.loads(zlib.decompress(base64.decodebytes(sources)))
     else:
         import cPickle as pickle
@@ -59,5 +59,5 @@ if __name__ == "__main__":
     importer = DictImporter(sources)
     sys.meta_path.append(importer)
 
-    import py
-    py.cmdline.pytest()
+    entry = "@ENTRY@"
+    do_exec(entry, locals())

_pytest/terminal.py

@@ -0,0 +1,473 @@
+""" terminal reporting of the full testing process.
+
+This is a good source for looking at the various reporting hooks.
+"""
+import pytest, py
+import sys
+import os
+
+def pytest_addoption(parser):
+    group = parser.getgroup("terminal reporting", "reporting", after="general")
+    group._addoption('-v', '--verbose', action="count",
+               dest="verbose", default=0, help="increase verbosity."),
+    group._addoption('-q', '--quiet', action="count",
+               dest="quiet", default=0, help="decreate verbosity."),
+    group._addoption('-r',
+         action="store", dest="reportchars", default=None, metavar="chars",
+         help="show extra test summary info as specified by chars (f)ailed, "
+              "(E)error, (s)skipped, (x)failed, (X)passed.")
+    group._addoption('-l', '--showlocals',
+         action="store_true", dest="showlocals", default=False,
+         help="show locals in tracebacks (disabled by default).")
+    group._addoption('--report',
+         action="store", dest="report", default=None, metavar="opts",
+         help="(deprecated, use -r)")
+    group._addoption('--tb', metavar="style",
+               action="store", dest="tbstyle", default='long',
+               type="choice", choices=['long', 'short', 'no', 'line', 'native'],
+               help="traceback print mode (long/short/line/native/no).")
+    group._addoption('--fulltrace',
+               action="store_true", dest="fulltrace", default=False,
+               help="don't cut any tracebacks (default is to cut).")
+
+def pytest_configure(config):
+    config.option.verbose -= config.option.quiet
+    # we try hard to make printing resilient against
+    # later changes on FD level.
+    stdout = py.std.sys.stdout
+    if hasattr(os, 'dup') and hasattr(stdout, 'fileno'):
+        try:
+            newfd = os.dup(stdout.fileno())
+            #print "got newfd", newfd
+        except ValueError:
+            pass
+        else:
+            stdout = os.fdopen(newfd, stdout.mode, 1)
+            config._cleanup.append(lambda: stdout.close())
+
+    reporter = TerminalReporter(config, stdout)
+    config.pluginmanager.register(reporter, 'terminalreporter')
+    if config.option.debug or config.option.traceconfig:
+        def mywriter(tags, args):
+            msg = " ".join(map(str, args))
+            reporter.write_line("[traceconfig] " + msg)
+        config.trace.root.setprocessor("pytest:config", mywriter)
+
+def getreportopt(config):
+    reportopts = ""
+    optvalue = config.option.report
+    if optvalue:
+        py.builtin.print_("DEPRECATED: use -r instead of --report option.",
+            file=py.std.sys.stderr)
+        if optvalue:
+            for setting in optvalue.split(","):
+                setting = setting.strip()
+                if setting == "skipped":
+                    reportopts += "s"
+                elif setting == "xfailed":
+                    reportopts += "x"
+    reportchars = config.option.reportchars
+    if reportchars:
+        for char in reportchars:
+            if char not in reportopts:
+                reportopts += char
+    return reportopts
+
+def pytest_report_teststatus(report):
+    if report.passed:
+        letter = "."
+    elif report.skipped:
+        letter = "s"
+    elif report.failed:
+        letter = "F"
+        if report.when != "call":
+            letter = "f"
+    return report.outcome, letter, report.outcome.upper()
+
+class TerminalReporter:
+    def __init__(self, config, file=None):
+        self.config = config
+        self.verbosity = self.config.option.verbose
+        self.showheader = self.verbosity >= 0
+        self.showfspath = self.verbosity >= 0
+        self.showlongtestinfo = self.verbosity > 0
+        self._numcollected = 0
+
+        self.stats = {}
+        self.curdir = py.path.local()
+        if file is None:
+            file = py.std.sys.stdout
+        self._tw = py.io.TerminalWriter(file)
+        self.currentfspath = None
+        self.reportchars = getreportopt(config)
+        self.hasmarkup = self._tw.hasmarkup
+
+    def hasopt(self, char):
+        char = {'xfailed': 'x', 'skipped': 's'}.get(char,char)
+        return char in self.reportchars
+
+    def write_fspath_result(self, fspath, res):
+        if fspath != self.currentfspath:
+            self.currentfspath = fspath
+            #fspath = self.curdir.bestrelpath(fspath)
+            self._tw.line()
+            #relpath = self.curdir.bestrelpath(fspath)
+            self._tw.write(fspath + " ")
+        self._tw.write(res)
+
+    def write_ensure_prefix(self, prefix, extra="", **kwargs):
+        if self.currentfspath != prefix:
+            self._tw.line()
+            self.currentfspath = prefix
+            self._tw.write(prefix)
+        if extra:
+            self._tw.write(extra, **kwargs)
+            self.currentfspath = -2
+
+    def ensure_newline(self):
+        if self.currentfspath:
+            self._tw.line()
+            self.currentfspath = None
+
+    def write(self, content, **markup):
+        self._tw.write(content, **markup)
+
+    def write_line(self, line, **markup):
+        line = str(line)
+        self.ensure_newline()
+        self._tw.line(line, **markup)
+
+    def rewrite(self, line, **markup):
+        line = str(line)
+        self._tw.write("\r" + line, **markup)
+
+    def write_sep(self, sep, title=None, **markup):
+        self.ensure_newline()
+        self._tw.sep(sep, title, **markup)
+
+    def pytest_internalerror(self, excrepr):
+        for line in str(excrepr).split("\n"):
+            self.write_line("INTERNALERROR> " + line)
+        return 1
+
+    def pytest_plugin_registered(self, plugin):
+        if self.config.option.traceconfig:
+            msg = "PLUGIN registered: %s" %(plugin,)
+            # XXX this event may happen during setup/teardown time
+            #     which unfortunately captures our output here
+            #     which garbles our output if we use self.write_line
+            self.write_line(msg)
+
+    def pytest_deselected(self, items):
+        self.stats.setdefault('deselected', []).extend(items)
+
+    def pytest_runtest_logstart(self, nodeid, location):
+        # ensure that the path is printed before the
+        # 1st test of a module starts running
+        fspath = nodeid.split("::")[0]
+        if self.showlongtestinfo:
+            line = self._locationline(fspath, *location)
+            self.write_ensure_prefix(line, "")
+        elif self.showfspath:
+            self.write_fspath_result(fspath, "")
+
+    def pytest_runtest_logreport(self, report):
+        rep = report
+        res = self.config.hook.pytest_report_teststatus(report=rep)
+        cat, letter, word = res
+        self.stats.setdefault(cat, []).append(rep)
+        if not letter and not word:
+            # probably passed setup/teardown
+            return
+        if self.verbosity <= 0:
+            if not hasattr(rep, 'node') and self.showfspath:
+                self.write_fspath_result(rep.fspath, letter)
+            else:
+                self._tw.write(letter)
+        else:
+            if isinstance(word, tuple):
+                word, markup = word
+            else:
+                if rep.passed:
+                    markup = {'green':True}
+                elif rep.failed:
+                    markup = {'red':True}
+                elif rep.skipped:
+                    markup = {'yellow':True}
+            line = self._locationline(str(rep.fspath), *rep.location)
+            if not hasattr(rep, 'node'):
+                self.write_ensure_prefix(line, word, **markup)
+                #self._tw.write(word, **markup)
+            else:
+                self.ensure_newline()
+                if hasattr(rep, 'node'):
+                    self._tw.write("[%s] " % rep.node.gateway.id)
+                self._tw.write(word, **markup)
+                self._tw.write(" " + line)
+                self.currentfspath = -2
+
+    def pytest_collection(self):
+        if not self.hasmarkup:
+            self.write("collecting ... ", bold=True)
+
+    def pytest_collectreport(self, report):
+        if report.failed:
+            self.stats.setdefault("error", []).append(report)
+        elif report.skipped:
+            self.stats.setdefault("skipped", []).append(report)
+        items = [x for x in report.result if isinstance(x, pytest.Item)]
+        self._numcollected += len(items)
+        if self.hasmarkup:
+            #self.write_fspath_result(report.fspath, 'E')
+            self.report_collect()
+
+    def report_collect(self, final=False):
+        errors = len(self.stats.get('error', []))
+        skipped = len(self.stats.get('skipped', []))
+        if final:
+            line = "collected "
+        else:
+            line = "collecting "
+        line += str(self._numcollected) + " items"
+        if errors:
+            line += " / %d errors" % errors
+        if skipped:
+            line += " / %d skipped" % skipped
+        if self.hasmarkup:
+            if final:
+                line += " \n"
+            self.rewrite(line, bold=True)
+        else:
+            self.write_line(line)
+
+    def pytest_collection_modifyitems(self):
+        self.report_collect(True)
+
+    def pytest_sessionstart(self, session):
+        self._sessionstarttime = py.std.time.time()
+        if not self.showheader:
+            return
+        self.write_sep("=", "test session starts", bold=True)
+        verinfo = ".".join(map(str, sys.version_info[:3]))
+        msg = "platform %s -- Python %s" % (sys.platform, verinfo)
+        if hasattr(sys, 'pypy_version_info'):
+            verinfo = ".".join(map(str, sys.pypy_version_info[:3]))
+            msg += "[pypy-%s-%s]" % (verinfo, sys.pypy_version_info[3])
+        msg += " -- pytest-%s" % (py.test.__version__)
+        if self.verbosity > 0 or self.config.option.debug or \
+           getattr(self.config.option, 'pastebin', None):
+            msg += " -- " + str(sys.executable)
+        self.write_line(msg)
+        lines = self.config.hook.pytest_report_header(config=self.config)
+        lines.reverse()
+        for line in flatten(lines):
+            self.write_line(line)
+
+    def pytest_collection_finish(self, session):
+        if self.config.option.collectonly:
+            self._printcollecteditems(session.items)
+            if self.stats.get('failed'):
+                self._tw.sep("!", "collection failures")
+                for rep in self.stats.get('failed'):
+                    rep.toterminal(self._tw)
+                return 1
+            return 0
+        if not self.showheader:
+            return
+        #for i, testarg in enumerate(self.config.args):
+        #    self.write_line("test path %d: %s" %(i+1, testarg))
+
+    def _printcollecteditems(self, items):
+        # to print out items and their parent collectors
+        # we take care to leave out Instances aka ()
+        # because later versions are going to get rid of them anyway
+        if self.config.option.verbose < 0:
+            if self.config.option.verbose < -1:
+                counts = {}
+                for item in items:
+                    name = item.nodeid.split('::', 1)[0]
+                    counts[name] = counts.get(name, 0) + 1
+                for name, count in sorted(counts.items()):
+                    self._tw.line("%s: %d" % (name, count))
+            else:
+                for item in items:
+                    nodeid = item.nodeid
+                    nodeid = nodeid.replace("::()::", "::")
+                    self._tw.line(nodeid)
+            return
+        stack = []
+        indent = ""
+        for item in items:
+            needed_collectors = item.listchain()[1:] # strip root node
+            while stack:
+                if stack == needed_collectors[:len(stack)]:
+                    break
+                stack.pop()
+            for col in needed_collectors[len(stack):]:
+                stack.append(col)
+                #if col.name == "()":
+                #    continue
+                indent = (len(stack)-1) * "  "
+                self._tw.line("%s%s" %(indent, col))
+
+    def pytest_sessionfinish(self, exitstatus, __multicall__):
+        __multicall__.execute()
+        self._tw.line("")
+        if exitstatus in (0, 1, 2):
+            self.summary_errors()
+            self.summary_failures()
+            self.config.hook.pytest_terminal_summary(terminalreporter=self)
+        if exitstatus == 2:
+            self._report_keyboardinterrupt()
+            del self._keyboardinterrupt_memo
+        self.summary_deselected()
+        self.summary_stats()
+
+    def pytest_keyboard_interrupt(self, excinfo):
+        self._keyboardinterrupt_memo = excinfo.getrepr(funcargs=True)
+
+    def pytest_unconfigure(self):
+        if hasattr(self, '_keyboardinterrupt_memo'):
+            self._report_keyboardinterrupt()
+
+    def _report_keyboardinterrupt(self):
+        excrepr = self._keyboardinterrupt_memo
+        msg = excrepr.reprcrash.message
+        self.write_sep("!", msg)
+        if "KeyboardInterrupt" in msg:
+            if self.config.option.fulltrace:
+                excrepr.toterminal(self._tw)
+            else:
+                excrepr.reprcrash.toterminal(self._tw)
+
+    def _locationline(self, collect_fspath, fspath, lineno, domain):
+        # collect_fspath comes from testid which has a "/"-normalized path
+        if fspath and fspath.replace("\\", "/") != collect_fspath:
+            fspath = "%s <- %s" % (collect_fspath, fspath)
+        if fspath:
+            line = str(fspath)
+            if lineno is not None:
+                lineno += 1
+                line += ":" + str(lineno)
+            if domain:
+                line += ": " + str(domain)
+        else:
+            line = "[location]"
+        return line + " "
+
+    def _getfailureheadline(self, rep):
+        if hasattr(rep, 'location'):
+            fspath, lineno, domain = rep.location
+            return domain
+        else:
+            return "test session" # XXX?
+
+    def _getcrashline(self, rep):
+        try:
+            return str(rep.longrepr.reprcrash)
+        except AttributeError:
+            try:
+                return str(rep.longrepr)[:50]
+            except AttributeError:
+                return ""
+
+    #
+    # summaries for sessionfinish
+    #
+    def getreports(self, name):
+        l = []
+        for x in self.stats.get(name, []):
+            if not hasattr(x, '_pdbshown'):
+                l.append(x)
+        return l
+
+    def summary_failures(self):
+        if self.config.option.tbstyle != "no":
+            reports = self.getreports('failed')
+            if not reports:
+                return
+            self.write_sep("=", "FAILURES")
+            for rep in reports:
+                if self.config.option.tbstyle == "line":
+                    line = self._getcrashline(rep)
+                    self.write_line(line)
+                else:
+                    msg = self._getfailureheadline(rep)
+                    self.write_sep("_", msg)
+                    self._outrep_summary(rep)
+
+    def summary_errors(self):
+        if self.config.option.tbstyle != "no":
+            reports = self.getreports('error')
+            if not reports:
+                return
+            self.write_sep("=", "ERRORS")
+            for rep in self.stats['error']:
+                msg = self._getfailureheadline(rep)
+                if not hasattr(rep, 'when'):
+                    # collect
+                    msg = "ERROR collecting " + msg
+                elif rep.when == "setup":
+                    msg = "ERROR at setup of " + msg
+                elif rep.when == "teardown":
+                    msg = "ERROR at teardown of " + msg
+                self.write_sep("_", msg)
+                self._outrep_summary(rep)
+
+    def _outrep_summary(self, rep):
+        rep.toterminal(self._tw)
+        for secname, content in rep.sections:
+            self._tw.sep("-", secname)
+            if content[-1:] == "\n":
+                content = content[:-1]
+            self._tw.line(content)
+
+    def summary_stats(self):
+        session_duration = py.std.time.time() - self._sessionstarttime
+
+        keys = "failed passed skipped deselected".split()
+        for key in self.stats.keys():
+            if key not in keys:
+                keys.append(key)
+        parts = []
+        for key in keys:
+            if key: # setup/teardown reports have an empty key, ignore them
+                val = self.stats.get(key, None)
+                if val:
+                    parts.append("%d %s" %(len(val), key))
+        line = ", ".join(parts)
+        # XXX coloring
+        msg = "%s in %.2f seconds" %(line, session_duration)
+        if self.verbosity >= 0:
+            self.write_sep("=", msg, bold=True)
+        else:
+            self.write_line(msg, bold=True)
+
+    def summary_deselected(self):
+        if 'deselected' in self.stats:
+            l = []
+            k = self.config.option.keyword
+            if k:
+                l.append("-k%s" % k)
+            m = self.config.option.markexpr
+            if m:
+                l.append("-m %r" % m)
+            self.write_sep("=", "%d tests deselected by %r" %(
+                len(self.stats['deselected']), " ".join(l)), bold=True)
+
+def repr_pythonversion(v=None):
+    if v is None:
+        v = sys.version_info
+    try:
+        return "%s.%s.%s-%s-%s" % v
+    except (TypeError, ValueError):
+        return str(v)
+
+def flatten(l):
+    for x in l:
+        if isinstance(x, (list, tuple)):
+            for y in flatten(x):
+                yield y
+        else:
+            yield x
+

_pytest/tmpdir.py

@@ -0,0 +1,68 @@
+""" support for providing temporary directories to test functions.  """
+import pytest, py
+from _pytest.monkeypatch import monkeypatch
+
+class TempdirHandler:
+    def __init__(self, config):
+        self.config = config
+        self.trace = config.trace.get("tmpdir")
+
+    def ensuretemp(self, string, dir=1):
+        """ (deprecated) return temporary directory path with
+            the given string as the trailing part.  It is usually
+            better to use the 'tmpdir' function argument which
+            provides an empty unique-per-test-invocation directory
+            and is guaranteed to be empty.
+        """
+        #py.log._apiwarn(">1.1", "use tmpdir function argument")
+        return self.getbasetemp().ensure(string, dir=dir)
+
+    def mktemp(self, basename, numbered=True):
+        basetemp = self.getbasetemp()
+        if not numbered:
+            p = basetemp.mkdir(basename)
+        else:
+            p = py.path.local.make_numbered_dir(prefix=basename,
+                keep=0, rootdir=basetemp, lock_timeout=None)
+        self.trace("mktemp", p)
+        return p
+
+    def getbasetemp(self):
+        """ return base temporary directory. """
+        try:
+            return self._basetemp
+        except AttributeError:
+            basetemp = self.config.option.basetemp
+            if basetemp:
+                basetemp = py.path.local(basetemp)
+                if basetemp.check():
+                    basetemp.remove()
+                basetemp.mkdir()
+            else:
+                basetemp = py.path.local.make_numbered_dir(prefix='pytest-')
+            self._basetemp = t = basetemp
+            self.trace("new basetemp", t)
+            return t
+
+    def finish(self):
+        self.trace("finish")
+
+def pytest_configure(config):
+    mp = monkeypatch()
+    t = TempdirHandler(config)
+    config._cleanup.extend([mp.undo, t.finish])
+    mp.setattr(config, '_tmpdirhandler', t, raising=False)
+    mp.setattr(pytest, 'ensuretemp', t.ensuretemp, raising=False)
+
+def pytest_funcarg__tmpdir(request):
+    """return a temporary directory path object
+    which is unique to each test function invocation,
+    created as a sub directory of the base temporary
+    directory.  The returned object is a `py.path.local`_
+    path object.
+    """
+    name = request._pyfuncitem.name
+    name = py.std.re.sub("[\W]", "_", name)
+    x = request.config._tmpdirhandler.mktemp(name, numbered=True)
+    return x
+

_pytest/unittest.py

@@ -0,0 +1,159 @@
+""" discovery and running of std-library "unittest" style tests. """
+import pytest, py
+import sys, pdb
+
+# for transfering markers
+from _pytest.python import transfer_markers
+
+def pytest_pycollect_makeitem(collector, name, obj):
+    unittest = sys.modules.get('unittest')
+    if unittest is None:
+        return # nobody can have derived unittest.TestCase
+    try:
+        isunit = issubclass(obj, unittest.TestCase)
+    except KeyboardInterrupt:
+        raise
+    except Exception:
+        pass
+    else:
+        if isunit:
+            return UnitTestCase(name, parent=collector)
+
+class UnitTestCase(pytest.Class):
+    def collect(self):
+        loader = py.std.unittest.TestLoader()
+        module = self.getparent(pytest.Module).obj
+        cls = self.obj
+        for name in loader.getTestCaseNames(self.obj):
+            x = getattr(self.obj, name)
+            funcobj = getattr(x, 'im_func', x)
+            transfer_markers(funcobj, cls, module)
+            if hasattr(funcobj, 'todo'):
+                pytest.mark.xfail(reason=str(funcobj.todo))(funcobj)
+            yield TestCaseFunction(name, parent=self)
+
+    def setup(self):
+        meth = getattr(self.obj, 'setUpClass', None)
+        if meth is not None:
+            meth()
+        super(UnitTestCase, self).setup()
+
+    def teardown(self):
+        meth = getattr(self.obj, 'tearDownClass', None)
+        if meth is not None:
+            meth()
+        super(UnitTestCase, self).teardown()
+
+class TestCaseFunction(pytest.Function):
+    _excinfo = None
+
+    def setup(self):
+        self._testcase = self.parent.obj(self.name)
+        self._obj = getattr(self._testcase, self.name)
+        if hasattr(self._testcase, 'skip'):
+            pytest.skip(self._testcase.skip)
+        if hasattr(self._obj, 'skip'):
+            pytest.skip(self._obj.skip)
+        if hasattr(self._testcase, 'setup_method'):
+            self._testcase.setup_method(self._obj)
+
+    def teardown(self):
+        if hasattr(self._testcase, 'teardown_method'):
+            self._testcase.teardown_method(self._obj)
+
+    def startTest(self, testcase):
+        pass
+
+    def _addexcinfo(self, rawexcinfo):
+        # unwrap potential exception info (see twisted trial support below)
+        rawexcinfo = getattr(rawexcinfo, '_rawexcinfo', rawexcinfo)
+        try:
+            excinfo = py.code.ExceptionInfo(rawexcinfo)
+        except TypeError:
+            try:
+                try:
+                    l = py.std.traceback.format_exception(*rawexcinfo)
+                    l.insert(0, "NOTE: Incompatible Exception Representation, "
+                        "displaying natively:\n\n")
+                    pytest.fail("".join(l), pytrace=False)
+                except (pytest.fail.Exception, KeyboardInterrupt):
+                    raise
+                except:
+                    pytest.fail("ERROR: Unknown Incompatible Exception "
+                        "representation:\n%r" %(rawexcinfo,), pytrace=False)
+            except KeyboardInterrupt:
+                raise
+            except pytest.fail.Exception:
+                excinfo = py.code.ExceptionInfo()
+        self.__dict__.setdefault('_excinfo', []).append(excinfo)
+
+    def addError(self, testcase, rawexcinfo):
+        self._addexcinfo(rawexcinfo)
+    def addFailure(self, testcase, rawexcinfo):
+        self._addexcinfo(rawexcinfo)
+    def addSkip(self, testcase, reason):
+        try:
+            pytest.skip(reason)
+        except pytest.skip.Exception:
+            self._addexcinfo(sys.exc_info())
+    def addExpectedFailure(self, testcase, rawexcinfo, reason):
+        try:
+            pytest.xfail(str(reason))
+        except pytest.xfail.Exception:
+            self._addexcinfo(sys.exc_info())
+    def addUnexpectedSuccess(self, testcase, reason):
+        pass
+    def addSuccess(self, testcase):
+        pass
+    def stopTest(self, testcase):
+        pass
+    def runtest(self):
+        self._testcase(result=self)
+
+    def _prunetraceback(self, excinfo):
+        pytest.Function._prunetraceback(self, excinfo)
+        traceback = excinfo.traceback.filter(
+            lambda x:not x.frame.f_globals.get('__unittest'))
+        if traceback:
+            excinfo.traceback = traceback
+
+@pytest.mark.tryfirst
+def pytest_runtest_makereport(item, call):
+    if isinstance(item, TestCaseFunction):
+        if item._excinfo:
+            call.excinfo = item._excinfo.pop(0)
+            del call.result
+
+# twisted trial support
+def pytest_runtest_protocol(item, __multicall__):
+    if isinstance(item, TestCaseFunction):
+        if 'twisted.trial.unittest' in sys.modules:
+            ut = sys.modules['twisted.python.failure']
+            Failure__init__ = ut.Failure.__init__.im_func
+            check_testcase_implements_trial_reporter()
+            def excstore(self, exc_value=None, exc_type=None, exc_tb=None,
+                captureVars=None):
+                if exc_value is None:
+                    self._rawexcinfo = sys.exc_info()
+                else:
+                    if exc_type is None:
+                        exc_type = type(exc_value)
+                    self._rawexcinfo = (exc_type, exc_value, exc_tb)
+                try:
+                    Failure__init__(self, exc_value, exc_type, exc_tb,
+                        captureVars=captureVars)
+                except TypeError:
+                    Failure__init__(self, exc_value, exc_type, exc_tb)
+            ut.Failure.__init__ = excstore
+            try:
+                return __multicall__.execute()
+            finally:
+                ut.Failure.__init__ = Failure__init__
+
+def check_testcase_implements_trial_reporter(done=[]):
+    if done:
+        return
+    from zope.interface import classImplements
+    from twisted.trial.itrial import IReporter
+    classImplements(TestCaseFunction, IReporter)
+    done.append(1)

bench/bench.py

@@ -0,0 +1,10 @@
+
+if __name__ == '__main__':
+    import cProfile
+    import py
+    import pstats
+    stats = cProfile.run('py.test.cmdline.main(["empty.py", ])', 'prof')
+    p = pstats.Stats("prof")
+    p.strip_dirs()
+    p.sort_stats('cumulative')
+    print(p.print_stats(30))

bench/empty.py

@@ -0,0 +1,3 @@
+import py
+for i in range(1000):
+    py.builtin.exec_("def test_func_%d(): pass" % i)

bin-for-dist/all-plat.sh

@@ -1,6 +0,0 @@
-
-        
-py.test --dist=each $* \
-    --tx 'socket=192.168.1.106:8888'
-    #--tx 'popen//python=python2.6' \
-    #--tx 'ssh=noco//python=/usr/local/bin/python2.4//chdir=/tmp/pytest-python2.4' \

bin-for-dist/findmissingdocstrings.py

@@ -1,76 +0,0 @@
-#!/usr/bin/env python 
-
-import py
-import inspect
-import types
-
-def report_strange_docstring(name, obj):
-    if obj.__doc__ is None:
-        print "%s misses a docstring" % (name, )
-    elif obj.__doc__ == "":
-        print "%s has an empty" % (name, )
-    elif "XXX" in obj.__doc__:
-        print "%s has an 'XXX' in its docstring" % (name, )
-
-def find_code(method):
-    return getattr(getattr(method, "im_func", None), "func_code", None)
-
-def report_different_parameter_names(name, cls):
-    bases = cls.__mro__
-    for base in bases:
-        for attr in dir(base):
-            meth1 = getattr(base, attr)
-            code1 = find_code(meth1)
-            if code1 is None:
-                continue
-            if not callable(meth1):
-                continue
-            if not hasattr(cls, attr):
-                continue
-            meth2 = getattr(cls, attr)
-            code2 = find_code(meth2)
-            if not callable(meth2):
-                continue
-            if code2 is None:
-                continue
-            args1 = inspect.getargs(code1)[0]
-            args2 = inspect.getargs(code2)[0]
-            for a1, a2 in zip(args1, args2):
-                if a1 != a2:
-                    print "%s.%s have different argument names %s, %s than the version in %s" % (name, attr, a1, a2, base)
-
-
-def find_all_exported():
-    stack = [(name, getattr(py, name)) for name in dir(py)[::-1]
-             if not name.startswith("_") and name != "compat"]
-    seen = {}
-    exported = []
-    while stack:
-        name, obj = stack.pop()
-        if id(obj) in seen:
-            continue
-        else:
-            seen[id(obj)] = True
-        exported.append((name, obj))
-        if isinstance(obj, type) or isinstance(obj, type(py)):
-            stack.extend([("%s.%s" % (name, s), getattr(obj, s)) for s in dir(obj)
-                           if len(s) <= 1 or not (s[0] == '_' and s[1] != '_')])
-    return exported
-
-
-
-if __name__ == '__main__':
-    all_exported = find_all_exported()
-    print "strange docstrings"
-    print "=================="
-    print
-    for name, obj in all_exported:
-        if callable(obj):
-            report_strange_docstring(name, obj)
-    print "\n\ndifferent parameters"
-    print     "===================="
-    print
-    for name, obj in all_exported:
-        if isinstance(obj, type):
-            report_different_parameter_names(name, obj)
- 

bin-for-dist/gendoc.py

@@ -1,25 +0,0 @@
-#!/usr/bin/env python
-
-XXX
-
-import sys
-import os
-from _findpy import py
-try:
-    import apigen
-except ImportError:
-    print 'Can not find apigen - make sure PYTHONPATH is set correctly!'
-    py.std.sys.exit()
-else:
-    args = list(sys.argv[1:])
-    args.extend(['-p', 'apigen'])
-    argkeys = [a.split('=')[0] for a in args]
-    if '--apigen' not in argkeys:
-        args.append('--apigen')
-    if '--apigenscript' not in argkeys:
-        fpath = os.path.join(
-            os.path.dirname(apigen.__file__), 'tool', 'py_build', 'build.py')
-        args.append('--apigenscript=%s' % (fpath,))
-    if '--apigenpath' not in argkeys:
-        args.append('--apigenpath=api')
-    py.test.cmdline.main(args)

bin-for-dist/genscripts.py

@@ -1,33 +0,0 @@
-import py
-
-bindir = py.path.local(__file__).dirpath().dirpath("bin")
-assert bindir.check(), bindir
-
-def getbasename(name):
-    assert name[:2] == "py"
-    return "py." + name[2:]
-
-def genscript_unix(name):
-    basename = getbasename(name)
-    path = bindir.join(basename)
-    path.write(py.code.Source("""
-        #!/usr/bin/env python
-        from _findpy import py
-        py.cmdline.%s()
-    """ % name).strip())
-    path.chmod(0755)
-
-def genscript_windows(name):
-    basename = getbasename(name)
-    winbasename = basename + ".cmd"
-    path = bindir.join("win32").join(winbasename)
-    path.write(py.code.Source("""
-         @echo off
-         python "%%~dp0\..\%s" %%*
-    """ % (basename)).strip())
-
-if __name__ == "__main__":
-    for name in dir(py.cmdline):
-        if name[0] != "_":
-            genscript_unix(name)
-            genscript_windows(name)

bin-for-dist/gensetup.py

@@ -1,315 +0,0 @@
-import sys
-
-sys.path.insert(0, sys.argv[1])
-import py
-
-toolpath = py.path.local(__file__)
-binpath = py.path.local(py.__file__).dirpath('bin')
-
-def error(msg):
-    print >>sys.stderr, msg
-    raise SystemExit, 1
-
-def reformat(text):
-    return " ".join(text.split())
-
-class SetupWriter(object):
-    EXCLUDES = ("MANIFEST.in", "contrib")
-
-    def __init__(self, basedir, pkg, setuptools=False):
-        self.basedir = basedir
-        self.setuptools = setuptools
-        assert self.basedir.check()
-        self.pkg = pkg
-        self.meta = pkg.__pkg__
-        self.lines = []
-        self.allpaths = self.getallpath(self.basedir)
-
-    def getallpath(self, basedir):
-        contrib = self.basedir.join("contrib")
-        allpath = []
-        lines = py.process.cmdexec("hg st -mcan").split("\n")
-        for path in lines:
-            p = basedir.join(path)
-            assert p.check(), p
-            if not p.relto(contrib) and p != contrib and not self.isexcluded(p):
-                allpath.append(p)
-        return allpath
-
-    def append(self, string):
-        lines = string.split("\n")
-        while lines:
-            if not lines[0].strip():
-                lines.pop(0)
-                continue
-            break
-        if not lines:
-            self.lines.append("")
-            return
-        line = lines[0]
-        indent = len(line) - len(line.lstrip())
-        for line in lines:
-            if line.strip():
-                assert not line[:indent].strip(), line
-                line = line[indent:]
-            self.lines.append(line)
-
-    def write_winfuncs(self):
-        self.append('''
-        ''')
-
-    def tip_info(self, indent=8):
-        old = self.basedir.chdir()
-        indent = " " * indent
-        try:
-            info = []
-            output = py.process.cmdexec(
-                "hg tip --template '" # tags: {tags}\n"
-                #"branch: {branches}\n"
-                "revision: {rev}:{node}\n'"
-            )
-            for line in output.split("\n"):
-                info.append("%s %s" %(indent, line.strip()))
-            return "\n".join(info)
-        finally:
-            old.chdir()
-
-    def setup_header(self):
-        #tooltime = "%s %s" %(py.std.time.asctime(), py.std.time.tzname[0])
-        toolname = toolpath.basename
-        #toolrevision = py.path.svnwc(toolpath).info().rev
-
-        pkgname = self.pkg.__name__
-        self.append('"""py lib / py.test setup.py file"""')
-        self.append('import os, sys')
-        self.append("from setuptools import setup")
-
-    def setup_trailer(self):
-        self.append('''
-            if __name__ == '__main__':
-                main()
-        ''')
-
-    def setup_function(self):
-        params = self.__dict__.copy()
-        params.update(self.meta.__dict__)
-        self.append('long_description = """')
-        for line in params['long_description'].split('\n'):
-            self.append(line)
-        self.append('"""')
-        trunk = None
-        if params['version'] == 'trunk':
-            trunk = 'trunk'
-        self.append('trunk = %r' % trunk)
-        self.append('''
-            def main():
-                setup(
-                    name=%(name)r,
-                    description=%(description)r,
-                    long_description = long_description,
-                    version= trunk or %(version)r,
-                    url=%(url)r,
-                    license=%(license)r,
-                    platforms=%(platforms)r,
-                    author=%(author)r,
-                    author_email=%(author_email)r,
-        ''' % params)
-        indent = " " * 8
-        self.append_pprint(indent, entry_points={'console_scripts':self.getconsolescripts()})
-        self.append_pprint(indent, classifiers=self.meta.classifiers)
-        self.append_pprint(indent, packages=self.getpackages())
-        self.append_pprint(indent, package_data=self.getpackagedata())
-        self.append_pprint(indent, zip_safe=True)
-        self.append_pprint(indent, install_requires=['apipkg'])
-        self.lines.append(indent[4:] + ")\n")
-
-    def setup_scripts(self):
-        # XXX this was used for a different approach
-        not used
-        self.append("""
-            def getscripts():
-                if sys.platform == "win32":
-                    base = "py/bin/win32/"
-                    ext = ".cmd"
-                else:
-                    base = "py/bin/"
-                    ext = ""
-                l = []
-                for name in %r:
-                    l.append(base + name + ext)
-                return l
-        """ % ([script.basename for script in binpath.listdir("py.*")]))
-
-    def append_pprint(self, indent, append=",", **kw):
-        for name, value in kw.items():
-            stringio = py.std.StringIO.StringIO()
-            value = py.std.pprint.pprint(value, stream=stringio)
-            stringio.seek(0)
-            lines =  stringio.readlines()
-            line = lines.pop(0).rstrip()
-            self.lines.append(indent + "%s=%s" %(name, line))
-            indent = indent + " " * (len(name)+1)
-            for line in lines:
-                self.lines.append(indent + line.rstrip())
-            self.lines[-1] = self.lines[-1] + append
-
-    def getconsolescripts(self):
-        bindir = self.basedir.join('py', 'bin')
-        scripts = []
-        for p in self.allpaths:
-            if p.dirpath() == bindir:
-                if p.basename.startswith('py.'):
-                    shortname = "py" + p.basename[3:]
-                    scripts.append("%s = py.cmdline:%s" %
-                        (p.basename, shortname))
-        return scripts
-
-    def getscripts(self):
-        bindir = self.basedir.join('py', 'bin')
-        scripts = []
-        for p in self.allpaths:
-            if p.dirpath() == bindir:
-                if p.basename.startswith('py.'):
-                    scripts.append(p.relto(self.basedir))
-        return scripts
-
-    def getpackages(self):
-        packages = []
-        for p in self.allpaths: # contains no directories!
-            #if p.basename == "py":
-            #    continue
-            if p.dirpath('__init__.py').check():
-                modpath = p.dirpath().relto(self.basedir).replace(p.sep, '.')
-                if modpath != "py" and not modpath.startswith("py."):
-                    continue
-                if modpath in packages:
-                    continue
-                for exclude in self.EXCLUDES:
-                    if modpath.startswith(exclude):
-                        print "EXCLUDING", modpath
-                        break
-                else:
-                    packages.append(modpath)
-        packages.sort()
-        return packages
-
-    def getpackagedata(self):
-        datafiles = []
-        pkgbase = self.basedir.join(self.pkg.__name__)
-        for p in self.allpaths:
-            if p.check(file=1) and (not p.dirpath("__init__.py").check()
-               or p.ext != ".py"):
-                if p.dirpath() != self.basedir:
-                    x = p.relto(pkgbase)
-                    if x:
-                        datafiles.append(p.relto(pkgbase))
-        return {'py': datafiles}
-
-    def getdatafiles(self):
-        datafiles = []
-        for p in self.allpaths:
-            if p.check(file=1) and not p.ext == ".py":
-                if p.dirpath() != self.basedir:
-                    datafiles.append(p.relto(self.basedir))
-        return datafiles
-
-    def setup_win32(self):
-        import winpath
-        self.append(py.std.inspect.getsource(winpath))
-        self.append("""
-            from distutils.command.install import install
-            class my_install(install):
-                def finalize_other(self):
-                    install.finalize_other(self)
-                    on_win32_add_to_PATH()
-            cmdclass = {'install': my_install}
-        """)
-
-    def setup_win32(self):
-        self.append(r'''
-        # scripts for windows: turn "py.SCRIPT" into "py_SCRIPT" and create
-        # "py.SCRIPT.cmd" files invoking "py_SCRIPT"
-        from distutils.command.install_scripts import install_scripts
-        class my_install_scripts(install_scripts):
-            def run(self):
-                install_scripts.run(self)
-                #print self.outfiles
-                for fn in self.outfiles:
-                    basename = os.path.basename(fn)
-                    if basename.startswith("py.") and not basename.endswith(".cmd"):
-                        newbasename = basename.replace(".", "_")
-                        newfn = os.path.join(os.path.dirname(fn), newbasename)
-                        if os.path.exists(newfn):
-                            os.remove(newfn)
-                        os.rename(fn, newfn)
-                        fncmd = fn + ".cmd"
-                        if os.path.exists(fncmd):
-                           os.remove(fncmd)
-                        f = open(fncmd, 'w')
-                        f.write("@echo off\n")
-                        f.write('python "%%~dp0\%s" %%*' %(newbasename))
-                        f.close()
-        if sys.platform == "win32":
-            cmdclass = {'install_scripts': my_install_scripts}
-        else:
-            cmdclass = {}
-        ''')
-
-    def write_setup(self):
-        self.setup_header()
-        self.setup_function()
-        #self.setup_scripts()
-        #self.setup_win32()
-        self.setup_trailer()
-        targetfile = self.basedir.join("setup.py")
-        targetfile.write("\n".join(self.lines))
-        print "wrote",  targetfile
-
-    def isexcluded(self, wcpath):
-        return wcpath.basename[0] == "."
-        rel = wcpath.relto(self.basedir)
-        if rel.find("testing") != -1:
-            return True
-
-    def write_manifest(self):
-        lines = []
-        for p in self.allpaths:
-            if p.check(dir=1):
-                continue
-            toadd = p.relto(self.basedir)
-            if toadd:
-                for exclude in self.EXCLUDES:
-                    if toadd.startswith(exclude):
-                        break
-                    assert toadd.find(exclude) == -1, (toadd, exclude)
-                else:
-                    lines.append("%s" %(toadd))
-        lines.sort()
-        targetfile = self.basedir.join("MANIFEST")
-        targetfile.write("\n".join(lines))
-        print "wrote",  targetfile
-
-    def write_all(self):
-        #self.write_manifest()
-        self.write_setup()
-
-def parseargs():
-    basedir = py.path.local(sys.argv[1])
-    if not basedir.check():
-        error("basedir not found: %s" %(basedir,))
-    pydir = basedir.join('py')
-    if not pydir.check():
-        error("no 'py' directory found in: %s" %(pydir,))
-    actualpydir = py.path.local(py.__file__).dirpath()
-    if pydir != actualpydir:
-        error("package dir conflict, %s != %s" %(pydir, actualpydir))
-    return basedir
-
-def main(basedir=None):
-    if basedir is None:
-        basedir = parseargs()
-    writer = SetupWriter(basedir, py, setuptools=True)
-    writer.write_all()
-
-if __name__ == "__main__":
-    main()

bin-for-dist/hudson.py

@@ -1,26 +0,0 @@
-import os, sys, subprocess, urllib
-
-BUILDNAME=os.environ.get('BUILD_NUMBER', "1")
-
-def call(*args):
-    ret = subprocess.call(list(args))
-    assert ret == 0
-
-def bincall(*args):
-    args = list(args)
-    args[0] = os.path.join(BIN, args[0])
-    call(*args)
-
-call("virtualenv", os.path.abspath(BUILDNAME), '--no-site-packages')
-BIN=os.path.abspath(os.path.join(BUILDNAME, 'bin'))
-if not os.path.exists(BIN):
-    BIN=os.path.abspath(os.path.join(BUILDNAME, 'Scripts'))
-    assert os.path.exists(BIN)
-    
-PYTHON=os.path.join(BIN, 'python')
-bincall("python", "setup.py", "develop", "-q")
-bincall("pip", "install", "-r", "testing/pip-reqs1.txt", 
-               "-q", "--download-cache=download")
-bincall("py.test", "--ignore", BUILDNAME, 
-        "--xml=junit.xml", 
-        "--report=skipped", "--runslowtest", *sys.argv[1:])

bin-for-dist/makepluginlist.py

@@ -1,299 +0,0 @@
-
-import os, sys
-WIDTH = 75
-
-plugins = [
-    ('advanced python testing', 
-            'skipping mark pdb figleaf coverage '
-            'monkeypatch capture recwarn tmpdir',),
-    ('distributed testing, CI and deployment',
-        'xdist pastebin junitxml resultlog genscript',),
-    ('testing domains and conventions',
-            'oejskit django unittest nose doctest restdoc'),
-    ('internal, debugging, help functionality', 
-          'helpconfig terminal hooklog')
-    #('internal plugins / core functionality', 
-    #    #'runner execnetcleanup # pytester',
-    #    'runner execnetcleanup' # pytester',
-    #)
-]
-
-externals = {
-    'oejskit': "run javascript tests in real life browsers", 
-    'xdist': None,
-    'figleaf': None,
-    'django': "for testing django applications", 
-    'coverage': "for testing with Ned's coverage module ", 
-    'xmlresult': "for generating xml reports " 
-                 "and CruiseControl integration",
-}
-
-def warn(*args):
-    msg = " ".join(map(str, args))
-    print >>sys.stderr, "WARN:", msg
-
-class RestWriter:
-    _all_links = {}
-
-    def __init__(self, target):
-        self.target = py.path.local(target)
-        self.links = []
-
-    def _getmsg(self, args):
-        return " ".join(map(str, args))
-
-    def Print(self, *args, **kwargs):
-        msg = self._getmsg(args)
-        if 'indent' in kwargs:
-            indent = kwargs['indent'] * " "
-            lines = [(indent + x) for x in msg.split("\n")]
-            msg = "\n".join(lines)
-        self.out.write(msg)
-        if not msg or msg[-1] != "\n":
-            self.out.write("\n")
-        self.out.flush()
-
-    def sourcecode(self, source):
-        lines = str(source).split("\n")
-        self.Print(".. sourcecode:: python")
-        self.Print()
-        for line in lines:
-            self.Print("   ", line)
-
-    def _sep(self, separator, args):
-        msg = self._getmsg(args)
-        sep = len(msg) * separator
-        self.Print()
-        self.Print(msg)
-        self.Print(sep)
-        self.Print()
-
-
-    def h1(self, *args):
-        self._sep('=', args)
-
-    def h2(self, *args):
-        self._sep('-', args)
-
-    def h3(self, *args):
-        self._sep('+', args)
-
-    def li(self, *args):
-        msg = self._getmsg(args)
-        sep = "* %s" %(msg)
-        self.Print(sep)
-
-    def dt(self, term):
-        self.Print("``%s``" % term)
-
-    def dd(self, doc):
-        self.Print(doc, indent=4)
-
-    def para(self, *args):
-        msg = self._getmsg(args)
-        self.Print(msg)
-
-    def add_internal_link(self, name, path):
-        relpath = path.new(ext=".html").relto(self.target.dirpath())
-        self.links.append((name, relpath))
-
-    def write_links(self):
-        self.Print()
-        self.Print(".. include:: links.txt")
-        for link in self.links:
-            key = link[0]
-            if key in self._all_links:
-                assert self._all_links[key] == link[1], (key, link[1])
-            else:
-                self._all_links[key] = link[1]
-      
-    def write_all_links(cls, linkpath):
-        p = linkpath.new(basename="links.txt")
-        p_writer = RestWriter(p)
-        p_writer.out = p_writer.target.open("w")
-        for name, value in cls._all_links.items():
-            p_writer.Print(".. _`%s`: %s" % (name, value))
-        p_writer.out.close()
-        del p_writer.out
-    write_all_links = classmethod(write_all_links)
-
-    def make(self, **kwargs):
-        self.out = self.target.open("w")
-        self.makerest(**kwargs)
-        self.write_links()
-
-        self.out.close()
-        print "wrote", self.target
-        del self.out
-
-class PluginOverview(RestWriter):
-    def makerest(self, config):
-        plugindir = py._pydir.join('plugin')
-        for cat, specs in plugins:
-            pluginlist = specs.split()
-            self.h1(cat)
-            for name in pluginlist:
-                oneliner = externals.get(name, None)
-                docpath = self.target.dirpath(name).new(ext=".txt")
-                if oneliner is not None:
-                    htmlpath = docpath.new(ext='.html')
-                    self.para("%s_ (external) %s" %(name, oneliner))
-                    self.add_internal_link(name, htmlpath)
-                else:
-                    doc = PluginDoc(docpath)
-                    doc.make(config=config, name=name) 
-                    self.add_internal_link(name, doc.target)
-                    if name in externals:
-                        self.para("%s_ (external) %s" %(name, doc.oneliner))
-                    else:
-                        self.para("%s_ %s" %(name, doc.oneliner))
-                self.Print()
-
-class HookSpec(RestWriter):
-    def makerest(self, config):
-        module = config.pluginmanager.hook._hookspecs
-        source = py.code.Source(module)
-        self.h1("hook specification sourcecode")
-        self.sourcecode(source)
-
-class PluginDoc(RestWriter):
-    def makerest(self, config, name):
-        config.pluginmanager.import_plugin(name)
-        plugin = config.pluginmanager.getplugin(name)
-        assert plugin is not None, plugin
-        print plugin
-        doc = plugin.__doc__.strip()
-        i = doc.find("\n")
-        if i == -1:
-            oneliner = doc
-            moduledoc = ""
-        else:
-            oneliner = doc[:i].strip()
-            moduledoc = doc[i+1:].strip()
-
-        self.name = oneliner # plugin.__name__.split(".")[-1]
-        self.oneliner = oneliner 
-        self.moduledoc = moduledoc
-       
-        #self.h1("%s plugin" % self.name) # : %s" %(self.name, self.oneliner))
-        self.h1(oneliner)
-        #self.Print(self.oneliner)
-        self.Print()
-        self.Print(".. contents::")
-        self.Print("  :local:")
-        self.Print()
-
-        self.Print(moduledoc)
-    
-        self.emit_funcargs(plugin)
-        self.emit_options(plugin)
-        self.emit_source(plugin, config.hg_changeset)
-        #self.sourcelink = (purename, 
-        #    "http://bitbucket.org/hpk42/py-trunk/src/tip/py/test/plugin/" + 
-        #    purename + ".py")
-        #
-    def emit_source(self, plugin, hg_changeset):
-        basename = py.path.local(plugin.__file__).basename
-        if basename.endswith("pyc"):
-            basename = basename[:-1]
-        #self.para("`%s`_ source code" % basename)
-        #self.links.append((basename, 
-        #    "http://bitbucket.org/hpk42/py-trunk/src/tip/py/test/plugin/" +
-        #    basename))
-        self.h1("Start improving this plugin in 30 seconds")
-        self.para(py.code.Source("""
-            1. Download `%s`_ plugin source code 
-            2. put it somewhere as ``%s`` into your import path 
-            3. a subsequent ``py.test`` run will use your local version
-
-            Checkout customize_, other plugins_ or `get in contact`_. 
-        """ % (basename, basename)))
-        #    your work appreciated if you offer back your version.  In this case
-        #    it probably makes sense if you `checkout the py.test 
-        #    development version`_ and apply your changes to the plugin
-        #    version in there. 
-        #self.links.append((basename, 
-        #    "http://bitbucket.org/hpk42/py-trunk/raw/%s/" 
-        #    "py/test/plugin/%s" %(hg_changeset, basename)))
-        self.links.append((basename, 
-            "http://bitbucket.org/hpk42/py-trunk/raw/%s/" 
-            "py/_plugin/%s" %(pyversion, basename)))
-        self.links.append(('customize', '../customize.html'))
-        self.links.append(('plugins', 'index.html'))
-        self.links.append(('get in contact', '../../contact.html'))
-        self.links.append(('checkout the py.test development version', 
-            '../../install.html#checkout'))
-       
-        if 0: # this breaks the page layout and makes large doc files
-            #self.h2("plugin source code") 
-            self.Print()
-            self.para("For your convenience here is also an inlined version "
-                      "of ``%s``:" %basename)
-            #self(or copy-paste from below)
-            self.Print()
-            self.sourcecode(py.code.Source(plugin))
-
-    def emit_funcargs(self, plugin):
-        funcargfuncs = []
-        prefix = "pytest_funcarg__"
-        for name in vars(plugin):
-            if name.startswith(prefix):
-                funcargfuncs.append(getattr(plugin, name))
-        if not funcargfuncs:
-            return
-        for func in funcargfuncs:
-            argname = func.__name__[len(prefix):]
-            self.Print()
-            self.Print(".. _`%s funcarg`:" % argname)
-            self.Print()
-            self.h2("the %r test function argument" % argname)
-            if func.__doc__:
-                doclines = func.__doc__.split("\n")
-                source = py.code.Source("\n".join(doclines[1:]))
-                source.lines.insert(0, doclines[0])
-                self.para(str(source))
-            else:
-                self.para("XXX missing docstring")
-                warn("missing docstring", func)
-
-    def emit_options(self, plugin):
-        from py._test.parseopt import Parser
-        options = []
-        parser = Parser(processopt=options.append)
-        if hasattr(plugin, 'pytest_addoption'):
-            plugin.pytest_addoption(parser)
-        if not options:
-            return
-        self.h2("command line options")
-        self.Print()
-        formatter = py.std.optparse.IndentedHelpFormatter()
-        for opt in options:
-            switches = formatter.format_option_strings(opt)
-            self.Print("``%s``" % switches)
-            self.Print(opt.help, indent=4)
-
-if __name__ == "__main__":
-    if os.path.exists("py"):
-        sys.path.insert(0, os.getcwd())
-    import py
-    _config = py.test.config
-    _config.parse([])
-    _config.pluginmanager.do_configure(_config)
-
-    pydir = py.path.local(py.__file__).dirpath()
-    pyversion = py.version
-
-    cmd = "hg tip --template '{node}'" 
-    old = pydir.dirpath().chdir()
-    _config.hg_changeset = py.process.cmdexec(cmd).strip()
-
-    testdir = pydir.dirpath("doc", 'test')
-   
-    ov = PluginOverview(testdir.join("plugin", "index.txt"))
-    ov.make(config=_config)
-    
-    ov = HookSpec(testdir.join("plugin", "hookspec.txt"))
-    ov.make(config=_config)
-
-    RestWriter.write_all_links(testdir.join("plugin", "links.txt"))
-

bin-for-dist/test_install.py

@@ -1,228 +0,0 @@
-import py
-import subprocess
-import os, sys
-
-execnet = py.test.importorskip("execnet")
-
-
-#
-# experimental funcargs for venv/install-tests
-#
-
-pytest_plugins = 'pytest_pytester',
-
-def pytest_funcarg__venv(request):
-    p = request.config.mktemp(request.function.__name__, numbered=True)
-    venv = VirtualEnv(str(p)) 
-    return venv 
-   
-def pytest_funcarg__py_setup(request):
-    testdir = request.getfuncargvalue('testdir')
-    rootdir = py.path.local(py.__file__).dirpath().dirpath()
-    setup = rootdir.join('setup.py')
-    if not setup.check():
-        py.test.skip("not found: %r" % setup)
-    return SetupBuilder(setup, testdir.tmpdir)
-
-class SetupBuilder:
-    def __init__(self, setup_path, tmpdir):
-        self.setup_path = setup_path
-        self.tmpdir = tmpdir
-        assert setup_path.check()
-
-    def make_sdist(self, destdir=None):
-        temp = self.tmpdir.mkdir('dist')
-        args = ['python', 'setup.py', 'sdist', '--dist-dir', str(temp)]
-        old = self.setup_path.dirpath().chdir()
-        try:
-            subcall(args)
-        finally:
-            old.chdir()
-        l = temp.listdir('py-*')
-        assert len(l) == 1
-        sdist = l[0]
-        if destdir is None:
-            destdir = self.setup_path.dirpath('build')
-            assert destdir.check()
-        else:
-            destdir = py.path.local(destdir)
-        target = destdir.join(sdist.basename)
-        sdist.copy(target)
-        return target 
-
-def subcall(args):
-    if hasattr(subprocess, 'check_call'):
-        subprocess.check_call(args)
-    else:
-        subprocess.call(args)
-# code taken from Ronny Pfannenschmidt's virtualenvmanager 
-
-class VirtualEnv(object):
-    def __init__(self, path):
-        #XXX: supply the python executable
-        self.path = path
-
-    def __repr__(self):
-        return "<VirtualEnv at %r>" %(self.path)
-
-    def _cmd(self, name):
-        if sys.platform == "win32":
-            return os.path.join(self.path, 'Scripts', name)
-        else:
-            return os.path.join(self.path, 'bin', name)
-
-    def ensure(self):
-        if not os.path.exists(self._cmd('python')):
-            self.create()
-
-    def create(self, sitepackages=False):
-        args = ['virtualenv', self.path]
-        if not sitepackages:
-            args.append('--no-site-packages')
-        subcall(args)
-
-    def makegateway(self):
-        python = self._cmd('python')
-        return execnet.makegateway("popen//python=%s" %(python,))
-
-    def pcall(self, cmd, *args, **kw):
-        self.ensure()
-        return subprocess.call([
-                self._cmd(cmd)
-            ] + list(args),
-            **kw)
-
-    def pytest_getouterr(self, *args):
-        self.ensure()
-        args = [self._cmd("py.test")] + list(args)
-        popen = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-        out, err = popen.communicate()
-        return out
-
-    def setup_develop(self):
-        self.ensure()
-        return self.pcall("python", "setup.py", "develop")
-
-    def easy_install(self, *packages, **kw):
-        args = []
-        if 'index' in kw:
-            index = kw['index']
-            if isinstance(index, (list, tuple)):
-                for i in index:
-                    args.extend(['-i', i])
-            else:
-                args.extend(['-i', index])
-
-        args.extend(packages)
-        self.pcall('easy_install', *args)
-
-
-def test_make_sdist_and_run_it(py_setup, venv):
-    sdist = py_setup.make_sdist(venv.path)
-    venv.easy_install(str(sdist)) 
-    gw = venv.makegateway()
-    ch = gw.remote_exec("import py ; channel.send(py.__version__)")
-    version = ch.receive()
-    assert version == py.__version__
-
-def test_plugin_setuptools_entry_point_integration(py_setup, venv, tmpdir):
-    sdist = py_setup.make_sdist(venv.path)
-    venv.easy_install(str(sdist)) 
-    # create a sample plugin
-    basedir = tmpdir.mkdir("testplugin")
-    basedir.join("setup.py").write("""if 1:
-        from setuptools import setup
-        setup(name="testplugin",
-            entry_points = {'pytest11': ['testplugin=tp1']},
-            py_modules = ['tp1'],
-        )
-    """)
-    basedir.join("tp1.py").write(py.code.Source("""
-        def pytest_addoption(parser):
-            parser.addoption("--testpluginopt", action="store_true")
-    """))
-    basedir.chdir()
-    print ("created sample plugin in %s" %basedir)
-    venv.setup_develop()
-    out = venv.pytest_getouterr("-h")
-    assert "testpluginopt" in out
-
-def test_cmdline_entrypoints(monkeypatch):
-    monkeypatch.syspath_prepend(py.path.local(__file__).dirpath().dirpath())
-    from setup import cmdline_entrypoints
-    versioned_scripts = ['py.test', 'py.which']
-    unversioned_scripts = versioned_scripts + [ 'py.cleanup', 
-        'py.convert_unittest', 'py.countloc', 'py.lookup', 'py.svnwcrevert']
-    for ver in [(2,4,0), (2,5,0), (2,6,0), (2,7,0), (3,0,1), (3,1,1)]:
-        for platform in ('posix', 'win32'):
-            points = cmdline_entrypoints(ver, "posix", 'python')
-            for script in versioned_scripts:
-                script_ver = script + "-%s.%s" % ver[:2]
-                assert script_ver in points
-            for script in unversioned_scripts:
-                assert script in points
-    points = cmdline_entrypoints((2,5,1), "java1.6.123", 'jython')
-    for script in versioned_scripts:
-        expected = "%s-jython" % script
-        assert expected in points
-    for script in unversioned_scripts:
-        assert script not in points
-
-    points = cmdline_entrypoints((2,5,1), "xyz", 'pypy-c-XYZ')
-    for script in versioned_scripts:
-        expected = "%s-pypy-c-XYZ" % script
-        assert expected in points
-    for script in unversioned_scripts:
-        assert script in points
-
-def test_slave_popen_needs_no_pylib(testdir, venv, pytestconfig):
-    pytestconfig.pluginmanager.skipifmissing("xdist")
-    venv.ensure()
-    #xxx execnet optimizes popen
-    #ch = venv.makegateway().remote_exec("import execnet")
-    #py.test.raises(ch.RemoteError, ch.waitclose)
-    python = venv._cmd("python")
-    p = testdir.makepyfile("""
-        import py
-        def test_func():
-            pass
-     """)
-    result = testdir.runpytest(p, '--rsyncdir=%s' % str(p), 
-            '--dist=each', '--tx=popen//python=%s' % python)
-    result.stdout.fnmatch_lines([
-        "*1 passed*"
-    ])
-
-def test_slave_needs_no_execnet(testdir, sshhost, pytestconfig):
-    pytestconfig.pluginmanager.skipifmissing("xdist")
-    xspec = "ssh=%s" % sshhost
-    gw = execnet.makegateway("ssh=%s" % sshhost)
-    ch = gw.remote_exec("""
-        import os, subprocess
-        subprocess.call(["virtualenv", "--no-site-packages", "subdir"])
-        channel.send(os.path.join(os.path.abspath("subdir"), 'bin', 'python'))
-        channel.send(os.path.join(os.path.abspath("subdir")))
-    """)
-    try:
-        path = ch.receive()
-        chdir = ch.receive()
-    except ch.RemoteError:
-        e = sys.exc_info()[1]
-        py.test.skip("could not prepare ssh slave:%s" % str(e))
-    gw.exit()
-    newspec = "%s//python=%s//chdir=%s" % (xspec, path, chdir)
-    gw = execnet.makegateway(newspec)
-    ch = gw.remote_exec("import execnet")
-    py.test.raises(ch.RemoteError, ch.waitclose)
-    gw.exit()
-    
-    p = testdir.makepyfile("""
-        import py
-        def test_func():
-            pass
-     """)
-    result = testdir.runpytest(p, '--rsyncdir=%s' % str(p), 
-            '--dist=each', '--tx=%s' % newspec)
-    result.stdout.fnmatch_lines([
-        "*1 passed*"
-    ])

bin/_findpy.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python 
-
-#
-# find and import a version of 'py' that exists in a parent dir
-# of the current working directory. fall back to import a 
-# globally available version
-#
-import sys
-import os
-from os.path import dirname as opd, exists, join, basename, abspath
-
-def searchpy(current):
-    while 1:
-        last = current
-        initpy = join(current, '__init__.py')
-        if not exists(initpy):
-            pydir = join(current, 'py')
-            # recognize py-package and ensure it is importable
-            if exists(pydir) and exists(join(pydir, '__init__.py')):
-                #for p in sys.path:
-                #    if p == current:
-                #        return True
-                if current != sys.path[0]:  # if we are already first, then ok
-                    sys.stderr.write("inserting into sys.path: %s\n" % current)
-                    sys.path.insert(0, current)
-                return True
-        current = opd(current)
-        if last == current:
-            return False
-
-if not searchpy(abspath(os.curdir)):
-    if not searchpy(opd(abspath(sys.argv[0]))):
-        if not searchpy(opd(__file__)):
-            pass # let's hope it is just on sys.path 
-
-import py
-
-if __name__ == '__main__': 
-    print ("py lib is at %s" % py.__file__)

bin/env.cmd

@@ -1,2 +0,0 @@
-@echo off
-for /F "usebackq delims=" %%i in (`python "%~dp0\env.py"`) do %%i

bin/env.py

@@ -1,33 +0,0 @@
-#!/usr/bin/env python
-
-import sys, os, os.path
-
-progpath = sys.argv[0]
-packagedir = os.path.dirname(os.path.dirname(os.path.abspath(progpath)))
-packagename = os.path.basename(packagedir)
-bindir = os.path.join(packagedir, 'bin')
-if sys.platform == 'win32':
-    bindir = os.path.join(bindir, 'win32')
-rootdir = os.path.dirname(packagedir)
-
-def prepend_path(name, value):
-    sep = os.path.pathsep
-    curpath = os.environ.get(name, '')
-    newpath = [value] + [ x for x in curpath.split(sep) if x and x != value ]
-    return setenv(name, sep.join(newpath))
-
-def setenv(name, value):
-    shell = os.environ.get('SHELL', '')
-    comspec = os.environ.get('COMSPEC', '')
-    if shell.endswith('csh'):
-        cmd = 'setenv %s "%s"' % (name, value)
-    elif shell.endswith('sh'):
-        cmd = '%s="%s"; export %s' % (name, value, name)
-    elif comspec.endswith('cmd.exe'):
-        cmd = 'set %s=%s' % (name, value)
-    else:
-        assert False, 'Shell not supported.'
-    return cmd
-
-print(prepend_path('PATH', bindir))
-print(prepend_path('PYTHONPATH', rootdir))

bin/py.cleanup

@@ -1,3 +0,0 @@
-#!/usr/bin/env python
-from _findpy import py
-py.cmdline.pycleanup()

bin/py.convert_unittest

@@ -1,3 +0,0 @@
-#!/usr/bin/env python
-from _findpy import py
-py.cmdline.pyconvert_unittest()

bin/py.countloc

@@ -1,3 +0,0 @@
-#!/usr/bin/env python
-from _findpy import py
-py.cmdline.pycountloc()

bin/py.lookup

@@ -1,3 +0,0 @@
-#!/usr/bin/env python
-from _findpy import py
-py.cmdline.pylookup()

bin/py.svnwcrevert

@@ -1,3 +0,0 @@
-#!/usr/bin/env python
-from _findpy import py
-py.cmdline.pysvnwcrevert()

bin/py.test

@@ -1,3 +0,0 @@
-#!/usr/bin/env python
-from _findpy import py
-py.cmdline.pytest()

bin/py.which

@@ -1,3 +0,0 @@
-#!/usr/bin/env python
-from _findpy import py
-py.cmdline.pywhich()

bin/win32/py.cleanup.cmd

@@ -1,2 +0,0 @@
-@echo off
-python "%~dp0\..\py.cleanup" %*

bin/win32/py.convert_unittest.cmd

@@ -1,2 +0,0 @@
-@echo off
-python "%~dp0\..\py.convert_unittest" %*

bin/win32/py.countloc.cmd

@@ -1,2 +0,0 @@
-@echo off
-python "%~dp0\..\py.countloc" %*

bin/win32/py.lookup.cmd

@@ -1,2 +0,0 @@
-@echo off
-python "%~dp0\..\py.lookup" %*

bin/win32/py.svnwcrevert.cmd

@@ -1,2 +0,0 @@
-@echo off
-python "%~dp0\..\py.svnwcrevert" %*

bin/win32/py.test.cmd

@@ -1,2 +0,0 @@
-@echo off
-python "%~dp0\..\py.test" %*

bin/win32/py.which.cmd

@@ -1,2 +0,0 @@
-@echo off
-python "%~dp0\..\py.which" %*

conftest.py

@@ -1,74 +0,0 @@
-import py
-import sys
-
-pytest_plugins = '_pytest doctest pytester'.split()
-
-collect_ignore = ['build', 'doc/_build']
-
-rsyncdirs = ['conftest.py', 'bin', 'py', 'doc', 'testing']
-
-import py
-def pytest_addoption(parser):
-    group = parser.getgroup("pylib", "py lib testing options")
-    group.addoption('--sshhost', 
-           action="store", dest="sshhost", default=None,
-           help=("ssh xspec for ssh functional tests. "))
-    group.addoption('--runslowtests',
-           action="store_true", dest="runslowtests", default=False,
-           help=("run slow tests"))
-
-
-def pytest_funcarg__sshhost(request):
-    val = request.config.getvalue("sshhost")
-    if val:
-        return val
-    py.test.skip("need --sshhost option") 
-def pytest_generate_tests(metafunc):
-    multi = getattr(metafunc.function, 'multi', None)
-    if multi is not None:
-        assert len(multi.kwargs) == 1
-        for name, l in multi.kwargs.items():
-            for val in l:
-                metafunc.addcall(funcargs={name: val})
-    elif 'anypython' in metafunc.funcargnames:
-        for name in ('python2.4', 'python2.5', 'python2.6', 
-                     'python2.7', 'python3.1', 'pypy-c', 'jython'):
-            metafunc.addcall(id=name, param=name)
-
-# XXX copied from execnet's conftest.py - needs to be merged 
-winpymap = {
-    'python2.7': r'C:\Python27\python.exe',
-    'python2.6': r'C:\Python26\python.exe',
-    'python2.5': r'C:\Python25\python.exe',
-    'python2.4': r'C:\Python24\python.exe',
-    'python3.1': r'C:\Python31\python.exe',
-}
-
-def getexecutable(name, cache={}):
-    try:
-        return cache[name]
-    except KeyError:
-        executable = py.path.local.sysfind(name)
-        if executable:
-            if name == "jython":
-                import subprocess
-                popen = subprocess.Popen([str(executable), "--version"], 
-                    universal_newlines=True, stderr=subprocess.PIPE)
-                out, err = popen.communicate()
-                if not err or "2.5" not in err:
-                    executable = None
-        cache[name] = executable
-        return executable
-
-def pytest_funcarg__anypython(request):
-    name = request.param
-    executable = getexecutable(name)
-    if executable is None:
-        if sys.platform == "win32":
-            executable = winpymap.get(name, None)
-            if executable:
-                executable = py.path.local(executable)
-                if executable.check():
-                    return executable
-        py.test.skip("no %s found" % (name,))
-    return executable

contrib/pytest_ignoreout.py

@@ -1,8 +0,0 @@
-import py
-
-def pytest_runtest_call(item, __multicall__):
-    cap = py.io.StdCapture()
-    try:
-        return __multicall__.execute()
-    finally:
-        outerr = cap.reset() 

contrib/pytest_resultdb.py

@@ -1,374 +0,0 @@
-"""XXX in progress: resultdb plugin for database logging of test results. 
-
-Saves test results to a datastore.
-
-XXX this needs to be merged with resultlog plugin
-
-Also mixes in some early ideas about an archive abstraction for test 
-results.
-""" 
-import py
-
-py.test.skip("XXX needs to be merged with resultlog")
-
-from pytest_resultlog import ResultLog
-
-def pytest_addoption(parser):
-    group = parser.addgroup("resultdb", "resultdb plugin options")
-    group.addoption('--resultdb', action="store", dest="resultdb", 
-            metavar="path",
-            help="path to the file to store test results.")
-    group.addoption('--resultdb_format', action="store", 
-            dest="resultdbformat", default='json',
-            help="data format (json, sqlite)")
-
-def pytest_configure(config):
-    # XXX using config.XYZ is not good 
-    if config.getvalue('resultdb'):
-        if config.option.resultdb:
-            # local import so missing module won't crash py.test
-            try:
-                import sqlite3
-            except ImportError:
-                raise config.Error('Could not import sqlite3 module')
-            try:
-                import simplejson
-            except ImportError:
-                raise config.Error('Could not import simplejson module')
-            if config.option.resultdbformat.lower() == 'json':
-                resultdb = ResultDB(JSONResultArchive, 
-                        config.option.resultdb) 
-            elif config.option.resultdbformat.lower() == 'sqlite':
-                resultdb = ResultDB(SQLiteResultArchive, 
-                        config.option.resultdb) 
-            else:
-                raise config.Error('Unknown --resultdb_format: %s' % 
-                        config.option.resultdbformat) 
-
-            config.pluginmanager.register(resultdb)
-
-class JSONResultArchive(object):
-    def __init__(self, archive_path):
-        self.archive_path = archive_path
-        import simplejson
-        self.simplejson = simplejson
-        
-    def init_db(self):
-        if os.path.exists(self.archive_path):
-            data_file = open(self.archive_path)
-            archive = self.simplejson.load(data_file)
-            self.archive = archive
-        else:
-            self.archive = []
-            self._flush()
-
-    def append_data(self, data):
-        runid = py.std.uuid.uuid4()
-        for item in data:
-            item = item.copy()
-            item['runid'] = str(runid)
-            self.archive.append(item)
-            self._flush()
-
-    def get_all_data(self):
-        return self.archive
-
-    def _flush(self):
-        data_file = open(self.archive_path, 'w')
-        self.simplejson.dump(self.archive, data_file)
-        data_file.close()
-
-
-class SQLiteResultArchive(object):
-    def __init__(self, archive_path):
-        self.archive_path = archive_path
-        import sqlite3
-        self.sqlite3 = sqlite3
-        
-    def init_db(self):
-        if not os.path.exists(self.archive_path):
-            conn = self.sqlite3.connect(self.archive_path)
-            cursor = conn.cursor()
-            try:
-                cursor.execute(SQL_CREATE_TABLES)
-                conn.commit()
-            finally:
-                cursor.close()
-                conn.close()
-
-    def append_data(self, data):
-        flat_data = []
-        runid = py.std.uuid.uuid4()
-        for item in data:
-            item = item.copy()
-            item['runid'] = str(runid)
-            flat_data.append(self.flatten(item))
-        conn = self.sqlite3.connect(self.archive_path)
-        cursor = conn.cursor()
-        cursor.executemany(SQL_INSERT_DATA, flat_data)
-        conn.commit()
-        cursor.close()
-        conn.close()
-
-    def get_all_data(self):
-        conn = self.sqlite3.connect(self.archive_path)
-        conn.row_factory = self.sqlite3.Row
-        cursor = conn.cursor()
-        cursor.execute(SQL_SELECT_DATA)
-        data = cursor.fetchall()
-        cursor.close()
-        conn.close()
-        data = [self.unflatten(item) for item in data]
-        return data
-
-    def flatten(self, item):
-        return (item.get('runid', None),
-                item.get('name', None),
-                item.get('passed', False),
-                item.get('skipped', False),
-                item.get('failed', False),
-                item.get('shortrepr', None),
-                item.get('longrepr', None),
-                item.get('fspath', None),
-                item.get('itemname', None),
-                )
-
-    def unflatten(self, item):
-        names = ("runid name passed skipped failed shortrepr "
-                "longrepr fspath itemname").split()
-        d = {}
-        for i, name in enumerate(names):
-            d[name] = item[i]
-        return d
-
-
-class ResultDB(ResultLog):
-    def __init__(self, cls, db_path):
-        self.archive = cls(db_path)
-        self.archive.init_db()
-
-    def write_log_entry(self, testpath, shortrepr, longrepr):
-        data = {}
-        event_excludes = ['colitem', 'longrepr']
-        for item in vars(event).keys():
-            if item not in event_excludes:
-                data[item] = getattr(event, item)
-        # use the locally calculated longrepr & shortrepr        
-        data['longrepr'] = longrepr
-        data['shortrepr'] = shortrepr
-
-        data['testpath'] = unicode(testpath)
-        self.archive.append_data([data])
-
-
-SQL_CREATE_TABLES = """
-create table pytest_results (
-    runid varchar(36),
-    name varchar,
-    passed int,
-    skipped int,
-    failed int,
-    shortrepr varchar,
-    longrepr varchar,
-    fspath varchar,
-    itemname varchar
-    );
-"""
-SQL_INSERT_DATA = """
-insert into pytest_results (
-    runid,
-    name,
-    passed,
-    skipped,
-    failed,
-    shortrepr,
-    longrepr,
-    fspath,
-    itemname)
-values (?, ?, ?, ?, ?, ?, ?, ?, ?);          
-"""
-SQL_SELECT_DATA = """
-select 
-    runid,
-    name,
-    passed,
-    skipped,
-    failed,
-    shortrepr,
-    longrepr,
-    fspath,
-    itemname
-from pytest_results;
-"""
-
-
-# ===============================================================================
-#
-# plugin tests 
-#
-# ===============================================================================
-
-import os, StringIO
-
-class BaseResultArchiveTests(object):
-    cls = None
-
-    def setup_class(cls):
-        # XXX refactor setup into a funcarg? 
-        cls.tempdb = "test_tempdb"
-
-    def test_init_db(self, testdir):
-        tempdb_path = unicode(testdir.tmpdir.join(self.tempdb))
-        archive = self.cls(tempdb_path)
-        archive.init_db()
-        assert os.path.exists(tempdb_path)
-
-    def test_db_insert(self, testdir):
-        tempdb_path = unicode(testdir.tmpdir.join(self.tempdb))
-        archive = self.cls(tempdb_path)
-        archive.init_db()
-        assert len(archive.get_all_data()) == 0
-
-        data = [{'name': 'tmppackage/test_whatever.py:test_hello',
-                    'fspath': '/Users/brian/work/tmppackage/test_whatever.py',
-                    'name': 'test_hello',
-                    'longrepr': '',
-                    'passed': True,
-                    'shortrepr': '.'
-                }]
-        archive.append_data(data)
-        result = archive.get_all_data()
-        print result
-        assert len(result) == 1
-        for key, value in data[0].items():
-            assert value == result[0][key]
-        assert 'runid' in result[0]
-        
-        # make sure the data is persisted
-        tempdb_path = unicode(testdir.tmpdir.join(self.tempdb))
-        archive = self.cls(tempdb_path)
-        archive.init_db()
-        assert len(archive.get_all_data()) == 1
-
-
-class TestJSONResultArchive(BaseResultArchiveTests):
-    cls = JSONResultArchive
-
-    def setup_method(self, method):
-        py.test.importorskip("simplejson")
-
-    
-class TestSQLiteResultArchive(BaseResultArchiveTests):
-    cls = SQLiteResultArchive
-
-    def setup_method(self, method):
-        py.test.importorskip("sqlite3")
-
-    def test_init_db_sql(self, testdir):
-        py.test.importorskip("sqlite3")
-        tempdb_path = unicode(testdir.tmpdir.join(self.tempdb))
-        archive = self.cls(tempdb_path)
-        archive.init_db()
-        assert os.path.exists(tempdb_path)
-        
-        # is table in the database? 
-        import sqlite3
-        conn = sqlite3.connect(tempdb_path)
-        cursor = conn.cursor()
-        cursor.execute("""SELECT name FROM sqlite_master
-                        ORDER BY name;""")
-        tables = cursor.fetchall()
-        cursor.close()
-        conn.close()
-        assert len(tables) == 1
-    
-def verify_archive_item_shape(item):
-    names = ("runid name passed skipped failed shortrepr "
-                "longrepr fspath itemname").split()
-    for name in names:
-        assert name in item
-
-class TestWithFunctionIntegration:
-    def getarchive(self, testdir, arg):
-        py.test.importorskip("sqlite3")
-        py.test.importorskip("simplejson")
-        resultdb = testdir.tmpdir.join("resultdb")
-        args = ["--resultdb=%s" % resultdb, "--resultdb_format=sqlite"] + [arg]
-        testdir.runpytest(*args)
-        assert resultdb.check(file=1)
-        archive = SQLiteResultArchive(unicode(resultdb))
-        archive.init_db()
-        return archive
-        
-    def test_collection_report(self, testdir):
-        py.test.skip("Needs a rewrite for db version.")
-        ok = testdir.makepyfile(test_collection_ok="")
-        skip = testdir.makepyfile(test_collection_skip="import py ; py.test.skip('hello')")
-        fail = testdir.makepyfile(test_collection_fail="XXX")
-
-        lines = self.getresultdb(testdir, ok) 
-        assert not lines
-
-        lines = self.getresultdb(testdir, skip)
-        assert len(lines) == 2
-        assert lines[0].startswith("S ")
-        assert lines[0].endswith("test_collection_skip.py")
-        assert lines[1].startswith(" ")
-        assert lines[1].endswith("test_collection_skip.py:1: Skipped: 'hello'")
-
-        lines = self.getresultdb(testdir, fail)
-        assert lines
-        assert lines[0].startswith("F ")
-        assert lines[0].endswith("test_collection_fail.py"), lines[0]
-        for x in lines[1:]:
-            assert x.startswith(" ")
-        assert "XXX" in "".join(lines[1:])
-
-    def test_log_test_outcomes(self, testdir):
-        mod = testdir.makepyfile(test_mod="""
-            import py 
-            def test_pass(): pass
-            def test_skip(): py.test.skip("hello")
-            def test_fail(): raise ValueError("val")
-        """)
-
-        archive = self.getarchive(testdir, mod)
-        data = archive.get_all_data()
-        for item in data:
-            verify_archive_item_shape(item)
-        assert len(data) == 3
-        assert len([item for item in data if item['passed'] == True]) == 1
-        assert len([item for item in data if item['skipped'] == True]) == 1
-        assert len([item for item in data if item['failed'] == True]) == 1
-
-    def test_internal_exception(self):
-        py.test.skip("Needs a rewrite for db version.")
-        # they are produced for example by a teardown failing
-        # at the end of the run
-        try:
-            raise ValueError
-        except ValueError:
-            excinfo = py.code.ExceptionInfo()
-        reslog = ResultDB(StringIO.StringIO())        
-        reslog.pytest_internalerror(excinfo.getrepr)
-        entry = reslog.logfile.getvalue()
-        entry_lines = entry.splitlines()
-
-        assert entry_lines[0].startswith('! ')
-        assert os.path.basename(__file__)[:-1] in entry_lines[0] #.py/.pyc
-        assert entry_lines[-1][0] == ' '
-        assert 'ValueError' in entry  
-
-def test_generic(testdir):
-    testdir.makepyfile("""
-        import py
-        def test_pass():
-            pass
-        def test_fail():
-            assert 0
-        def test_skip():
-            py.test.skip("")
-    """)
-    testdir.runpytest("--resultdb=result.sqlite")
-    #testdir.tmpdir.join("result.sqlite")
-    

contrib/pytest_twisted/__init__.py

@@ -1,190 +0,0 @@
-"""
-Allows to test twisted applications with pytest.
-
-Notes: twisted's asynchronous behavior may have influence on the order of test-functions
-
-TODO:
-    + credits to Ralf Schmitt See: http://twistedmatrix.com/pipermail/twisted-python/2007-February/014872.html
-    + get test to work
-"""
-
-import sys
-
-try:
-    from twisted.internet import reactor, defer
-    from twisted.python import failure, log
-except ImportError:
-    print "To use the twisted option you have to install twisted."
-    sys.exit(10)
-try:
-    from greenlet import greenlet
-except ImportError:
-    print "Since pylib 1.0 greenlet are removed and separately packaged: " \
-            "http://pypi.python.org/pypi/greenlet" 
-    sys.exit(10)
-
-
-def _start_twisted_logging():
-    """Enables twisted internal logging"""
-
-    class Logger(object):
-        """late-bound sys.stdout"""
-        def write(self, msg):
-            sys.stdout.write(msg)
-
-        def flush(self):
-            sys.stdout.flush()
-            # sys.stdout will be changed by py.test later.
-    log.startLogging(Logger(), setStdout=0)
-
-def _run_twisted(logging=False):
-    """Start twisted mainloop and initialize recursive calling of doit()."""
-
-    # make twisted copy traceback...
-    failure.Failure.cleanFailure = lambda *args: None
-    if logging:
-        _start_twisted_logging()
-        
-    def fix_signal_handling():
-        # see http://twistedmatrix.com/trac/ticket/733
-        import signal
-        if hasattr(signal, "siginterrupt"):
-            signal.siginterrupt(signal.SIGCHLD, False)
-
-    def start():
-        fix_signal_handling()
-        doit(None)
-        
-    # recursively called for each test-function/method due done()
-    def doit(val): # val always None
-        # switch context to wait that wrapper() passes back to test-method
-        res = gr_tests.switch(val)
-        if res is None:
-            reactor.stop()
-            return
-
-        def done(res):
-            reactor.callLater(0.0, doit, None) # recursive call of doit()
-
-        def err(res):
-            reactor.callLater(0.0, doit, res)
-            
-        # the test-function *may* return a deferred
-        # here the test-function will actually been called
-        # done() is finalizing a test-process by assuring recursive invoking
-        # of doit()
-        defer.maybeDeferred(res).addCallback(done).addErrback(err)
-    # initially preparing the calling of doit() and starting the reactor
-    reactor.callLater(0.0, start)
-    reactor.run()
-
-def pytest_addoption(parser):
-    group = parser.addgroup('twisted options')
-    group.addoption('--twisted-logging', action='store_true', default=False,
-            dest='twisted_logging',
-            help="switch on twisted internal logging")
-
-def pytest_configure(config):
-    twisted_logging = config.getvalue("twisted_logging")
-    gr_twisted.switch(twisted_logging)
-
-def pytest_unconfigure(config):
-    gr_twisted.switch(None)
-
-def pytest_pyfunc_call(pyfuncitem):
-    # XXX1 kwargs?  
-    # XXX2 we want to delegate actual call to next plugin
-    #      (which may want to produce test coverage, etc.) 
-    res = gr_twisted.switch(lambda: pyfuncitem.call())
-    if res:
-        res.raiseException()
-    return True # indicates that we performed the function call 
-
-gr_twisted  = greenlet(_run_twisted)
-gr_tests    = greenlet.getcurrent()
-
-# ===============================================================================
-# plugin tests 
-# ===============================================================================
-
-def test_generic(testdir):
-    testdir.makepyfile('''
-        def test_pass():
-            pass
-        from twisted.internet import defer, reactor
-        from twisted.python import failure
-        from twisted.python import log
-
-
-        def test_no_deferred():
-            assert True is True
-
-        def test_deferred():
-            log.msg("test_deferred() called")
-            d = defer.Deferred()
-            def done():
-                log.msg("test_deferred.done() CALLBACK DONE")
-                d.callback(None)
-                
-            reactor.callLater(2.5, done)
-            log.msg("test_deferred() returning deferred: %r" % (d,))
-            return d
-
-        def test_deferred2():
-            log.msg("test_deferred2() called")
-            d = defer.Deferred()
-            def done():
-                log.msg("test_deferred2.done() CALLBACK DONE")
-                d.callback(None)
-                
-            reactor.callLater(2.5, done)
-            log.msg("test_deferred2() returning deferred: %r" % (d,))
-            return d
-
-        def test_deferred4():
-            log.msg("test_deferred4() called")
-            from twisted.web.client import getPage
-            def printContents(contents):
-                assert contents == ""
-
-            deferred = getPage('http://twistedmatrix.com/')
-            deferred.addCallback(printContents)
-            return deferred
-
-        def test_deferred3():
-            log.msg("test_deferred3() called")
-            d = defer.Deferred()
-            def done():
-                log.msg("test_deferred3.done() CALLBACK DONE")
-                d.callback(None)
-                
-            reactor.callLater(2.5, done)
-            log.msg("test_deferred3() returning deferred: %r" % (d,))
-            return d
-
-        class TestTwistedSetupMethod:
-            def setup_method(self, method):
-                log.msg("TestTwistedSetupMethod.setup_method() called")
-
-            def test_deferred(self):
-                log.msg("TestTwistedSetupMethod.test_deferred() called")
-                d = defer.Deferred()
-                def done():
-                    log.msg("TestTwistedSetupMethod.test_deferred() CALLBACK DONE")
-                    d.callback(None)
-                    
-                reactor.callLater(2.5, done)
-                log.msg("TestTwistedSetupMethod.test_deferred() returning deferred: %r" % (d,))
-                return d
-
-
-        def test_defer_fail():
-            def fun():
-                log.msg("provoking NameError")
-                rsdfg
-            return defer.maybeDeferred(fun)
-    ''')
-    testdir.runpytest("-T")
-    # XXX: what to do?
-    # s = testdir.tmpdir.join("event.log").read()
-    # assert s.find("TestrunFinish") != -1

contrib/readme.txt

@@ -1,2 +0,0 @@
-
-pygreen: experimental IO and execnet operations through greenlets 

contrib/runtesthelper.py

@@ -1,17 +0,0 @@
-"""
-this little helper allows to run tests multiple times
-in the same process.  useful for running tests from 
-a console.
-"""
-import py, sys
-
-def pytest(argv=None):
-    if argv is None:
-        argv = []
-    try:
-        sys.argv[1:] = argv
-        py.cmdline.pytest()
-    except SystemExit:
-        pass
-    # we need to reset the global py.test.config object
-    py.test.config = py.test.config.__class__()

distribute_setup.py

@@ -46,19 +46,21 @@ except ImportError:
             args = [quote(arg) for arg in args]
         return os.spawnl(os.P_WAIT, sys.executable, *args) == 0
 
-DEFAULT_VERSION = "0.6.6"
+DEFAULT_VERSION = "0.6.24"
 DEFAULT_URL = "http://pypi.python.org/packages/source/d/distribute/"
+SETUPTOOLS_FAKED_VERSION = "0.6c11"
+
 SETUPTOOLS_PKG_INFO = """\
 Metadata-Version: 1.0
 Name: setuptools
-Version: 0.6c9
+Version: %s
 Summary: xxxx
 Home-page: xxx
 Author: xxx
 Author-email: xxx
 License: xxx
 Description: xxx
-"""
+""" % SETUPTOOLS_FAKED_VERSION
 
 
 def _install(tarball):
@@ -79,12 +81,14 @@ def _install(tarball):
 
         # installing
         log.warn('Installing Distribute')
-        assert _python_cmd('setup.py', 'install')
+        if not _python_cmd('setup.py', 'install'):
+            log.warn('Something went wrong during the installation.')
+            log.warn('See the error message above.')
     finally:
         os.chdir(old_wd)
 
 
-def _build_egg(tarball, to_dir):
+def _build_egg(egg, tarball, to_dir):
     # extracting the tarball
     tmpdir = tempfile.mkdtemp()
     log.warn('Extracting in %s', tmpdir)
@@ -104,27 +108,28 @@ def _build_egg(tarball, to_dir):
         log.warn('Building a Distribute egg in %s', to_dir)
         _python_cmd('setup.py', '-q', 'bdist_egg', '--dist-dir', to_dir)
 
-        # returning the result
-        for file in os.listdir(to_dir):
-            if fnmatch.fnmatch(file, 'distribute-%s*.egg' % DEFAULT_VERSION):
-                return os.path.join(to_dir, file)
-
-        raise IOError('Could not build the egg.')
     finally:
         os.chdir(old_wd)
+    # returning the result
+    log.warn(egg)
+    if not os.path.exists(egg):
+        raise IOError('Could not build the egg.')
 
 
 def _do_download(version, download_base, to_dir, download_delay):
-    tarball = download_setuptools(version, download_base,
-                                  to_dir, download_delay)
-    egg = _build_egg(tarball, to_dir)
+    egg = os.path.join(to_dir, 'distribute-%s-py%d.%d.egg'
+                       % (version, sys.version_info[0], sys.version_info[1]))
+    if not os.path.exists(egg):
+        tarball = download_setuptools(version, download_base,
+                                      to_dir, download_delay)
+        _build_egg(egg, tarball, to_dir)
     sys.path.insert(0, egg)
     import setuptools
     setuptools.bootstrap_install_from = egg
 
 
 def use_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
-                   to_dir=os.curdir, download_delay=15, no_fake=False):
+                   to_dir=os.curdir, download_delay=15, no_fake=True):
     # making sure we use the absolute path
     to_dir = os.path.abspath(to_dir)
     was_imported = 'pkg_resources' in sys.modules or \
@@ -134,7 +139,7 @@ def use_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
             import pkg_resources
             if not hasattr(pkg_resources, '_distribute'):
                 if not no_fake:
-                    fake_setuptools()
+                    _fake_setuptools()
                 raise ImportError
         except ImportError:
             return _do_download(version, download_base, to_dir, download_delay)
@@ -159,7 +164,8 @@ def use_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
             return _do_download(version, download_base, to_dir,
                                 download_delay)
     finally:
-        _create_fake_setuptools_pkg_info(to_dir)
+        if not no_fake:
+            _create_fake_setuptools_pkg_info(to_dir)
 
 def download_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
                         to_dir=os.curdir, delay=15):
@@ -197,6 +203,29 @@ def download_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
                 dst.close()
     return os.path.realpath(saveto)
 
+def _no_sandbox(function):
+    def __no_sandbox(*args, **kw):
+        try:
+            from setuptools.sandbox import DirectorySandbox
+            if not hasattr(DirectorySandbox, '_old'):
+                def violation(*args):
+                    pass
+                DirectorySandbox._old = DirectorySandbox._violation
+                DirectorySandbox._violation = violation
+                patched = True
+            else:
+                patched = False
+        except ImportError:
+            patched = False
+
+        try:
+            return function(*args, **kw)
+        finally:
+            if patched:
+                DirectorySandbox._violation = DirectorySandbox._old
+                del DirectorySandbox._old
+
+    return __no_sandbox
 
 def _patch_file(path, content):
     """Will backup the file then patch it"""
@@ -214,26 +243,17 @@ def _patch_file(path, content):
         f.close()
     return True
 
+_patch_file = _no_sandbox(_patch_file)
 
 def _same_content(path, content):
     return open(path).read() == content
 
-
 def _rename_path(path):
     new_name = path + '.OLD.%s' % time.time()
     log.warn('Renaming %s into %s', path, new_name)
-    try:
-        from setuptools.sandbox import DirectorySandbox
-        def _violation(*args):
-            pass
-        DirectorySandbox._violation = _violation
-    except ImportError:
-        pass
-
     os.rename(path, new_name)
     return new_name
 
-
 def _remove_flat_installation(placeholder):
     if not os.path.isdir(placeholder):
         log.warn('Unkown installation at %s', placeholder)
@@ -267,6 +287,7 @@ def _remove_flat_installation(placeholder):
                      'Setuptools distribution', element)
     return True
 
+_remove_flat_installation = _no_sandbox(_remove_flat_installation)
 
 def _after_install(dist):
     log.warn('After install bootstrap.')
@@ -278,17 +299,20 @@ def _create_fake_setuptools_pkg_info(placeholder):
         log.warn('Could not find the install location')
         return
     pyver = '%s.%s' % (sys.version_info[0], sys.version_info[1])
-    setuptools_file = 'setuptools-0.6c9-py%s.egg-info' % pyver
+    setuptools_file = 'setuptools-%s-py%s.egg-info' % \
+            (SETUPTOOLS_FAKED_VERSION, pyver)
     pkg_info = os.path.join(placeholder, setuptools_file)
     if os.path.exists(pkg_info):
         log.warn('%s already exists', pkg_info)
         return
+
     log.warn('Creating %s', pkg_info)
     f = open(pkg_info, 'w')
     try:
         f.write(SETUPTOOLS_PKG_INFO)
     finally:
         f.close()
+
     pth_file = os.path.join(placeholder, 'setuptools.pth')
     log.warn('Creating %s', pth_file)
     f = open(pth_file, 'w')
@@ -297,6 +321,7 @@ def _create_fake_setuptools_pkg_info(placeholder):
     finally:
         f.close()
 
+_create_fake_setuptools_pkg_info = _no_sandbox(_create_fake_setuptools_pkg_info)
 
 def _patch_egg_dir(path):
     # let's check if it's already patched
@@ -316,10 +341,11 @@ def _patch_egg_dir(path):
         f.close()
     return True
 
+_patch_egg_dir = _no_sandbox(_patch_egg_dir)
 
 def _before_install():
     log.warn('Before install bootstrap.')
-    fake_setuptools()
+    _fake_setuptools()
 
 
 def _under_prefix(location):
@@ -335,12 +361,12 @@ def _under_prefix(location):
                 if len(args) > index:
                     top_dir = args[index+1]
                     return location.startswith(top_dir)
-            elif option == '--user' and USER_SITE is not None:
-                return location.startswith(USER_SITE)
+        if arg == '--user' and USER_SITE is not None:
+            return location.startswith(USER_SITE)
     return True
 
 
-def fake_setuptools():
+def _fake_setuptools():
     log.warn('Scanning installed packages')
     try:
         import pkg_resources
@@ -395,6 +421,9 @@ def fake_setuptools():
 def _relaunch():
     log.warn('Relaunching...')
     # we have to relaunch the process
+    # pip marker to avoid a relaunch bug
+    if sys.argv[:3] == ['-c', 'install', '--single-version-externally-managed']:
+        sys.argv[0] = 'setup.py'
     args = [sys.executable] + sys.argv
     sys.exit(subprocess.call(args))
 

doc/Makefile

@@ -0,0 +1,142 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         =
+BUILDDIR      = _build
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest
+
+regen:
+	PYTHONDONTWRITEBYTECODE=1 COLUMNS=76 regendoc --update *.txt */*.txt
+    
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+
+clean:
+	-rm -rf $(BUILDDIR)/*
+
+install: html
+	 rsync -avz _build/html/ pytest.org:/www/pytest.org/latest
+
+installpdf: latexpdf
+	@scp $(BUILDDIR)/latex/pytest.pdf pytest.org:/www/pytest.org/latest
+
+installall: clean install installpdf
+	@echo "done"
+
+html:
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+dirhtml:
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+singlehtml:
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+pickle:
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/pytest.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/pytest.qhc"
+
+devhelp:
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/pytest"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/pytest"
+	@echo "# devhelp"
+
+epub:
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+latex:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+latexpdf:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	make -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+text:
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+man:
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."

doc/_static/sphinxdoc.css

@@ -0,0 +1,339 @@
+/*
+ * sphinxdoc.css_t
+ * ~~~~~~~~~~~~~~~
+ *
+ * Sphinx stylesheet -- sphinxdoc theme.  Originally created by
+ * Armin Ronacher for Werkzeug.
+ *
+ * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+@import url("basic.css");
+
+/* -- page layout ----------------------------------------------------------- */
+
+body {
+    font-family: 'Lucida Grande', 'Lucida Sans Unicode', 'Geneva',
+                 'Verdana', sans-serif;
+    font-size: 1.1em;
+    letter-spacing: -0.01em;
+    line-height: 150%;
+    text-align: center;
+    background-color: #BFD1D4;
+    color: black;
+    padding: 0;
+    border: 1px solid #aaa;
+
+    margin: 0px 80px 0px 80px;
+    min-width: 740px;
+}
+
+div.document {
+    background-color: white;
+    text-align: left;
+    background-image: url(contents.png);
+    background-repeat: repeat-x;
+}
+
+div.bodywrapper {
+    margin: 0 240px 0 0;
+    border-right: 1px solid #ccc;
+}
+
+div.body {
+    margin: 0;
+    padding: 0.5em 20px 20px 20px;
+}
+
+div.related {
+    font-size: 0.8em;
+}
+
+div.related ul {
+    background-image: url(navigation.png);
+    height: 2em;
+    border-top: 1px solid #ddd;
+    border-bottom: 1px solid #ddd;
+}
+
+div.related ul li {
+    margin: 0;
+    padding: 0;
+    height: 2em;
+    float: left;
+}
+
+div.related ul li.right {
+    float: right;
+    margin-right: 5px;
+}
+
+div.related ul li a {
+    margin: 0;
+    padding: 0 5px 0 5px;
+    line-height: 1.75em;
+    color: #EE9816;
+}
+
+div.related ul li a:hover {
+    color: #3CA8E7;
+}
+
+div.sphinxsidebarwrapper {
+    padding: 0;
+}
+
+div.sphinxsidebar {
+    margin: 0;
+    padding: 0.5em 15px 15px 0;
+    width: 210px;
+    float: right;
+    font-size: 1em;
+    text-align: left;
+}
+
+div.sphinxsidebar h3, div.sphinxsidebar h4 {
+    margin: 1em 0 0.5em 0;
+    font-size: 1em;
+    padding: 0.1em 0 0.1em 0.5em;
+    color: white;
+    border: 1px solid #86989B;
+    background-color: #AFC1C4;
+}
+
+div.sphinxsidebar h3 a {
+    color: white;
+}
+
+div.sphinxsidebar ul {
+    padding-left: 1.5em;
+    margin-top: 7px;
+    padding: 0;
+    line-height: 130%;
+}
+
+div.sphinxsidebar ul ul {
+    margin-left: 20px;
+}
+
+div.footer {
+    background-color: #E3EFF1;
+    color: #86989B;
+    padding: 3px 8px 3px 0;
+    clear: both;
+    font-size: 0.8em;
+    text-align: right;
+}
+
+div.footer a {
+    color: #86989B;
+    text-decoration: underline;
+}
+
+/* -- body styles ----------------------------------------------------------- */
+
+p {    
+    margin: 0.8em 0 0.5em 0;
+}
+
+a {
+    color: #CA7900;
+    text-decoration: none;
+}
+
+a:hover {
+    color: #2491CF;
+}
+
+div.body a {
+    text-decoration: underline;
+}
+
+h1 {
+    margin: 0;
+    padding: 0.7em 0 0.3em 0;
+    font-size: 1.5em;
+    color: #11557C;
+}
+
+h2 {
+    margin: 1.3em 0 0.2em 0;
+    font-size: 1.35em;
+    padding: 0;
+}
+
+h3 {
+    margin: 1em 0 -0.3em 0;
+    font-size: 1.2em;
+}
+
+div.body h1 a, div.body h2 a, div.body h3 a, div.body h4 a, div.body h5 a, div.body h6 a {
+    color: black!important;
+}
+
+h1 a.anchor, h2 a.anchor, h3 a.anchor, h4 a.anchor, h5 a.anchor, h6 a.anchor {
+    display: none;
+    margin: 0 0 0 0.3em;
+    padding: 0 0.2em 0 0.2em;
+    color: #aaa!important;
+}
+
+h1:hover a.anchor, h2:hover a.anchor, h3:hover a.anchor, h4:hover a.anchor,
+h5:hover a.anchor, h6:hover a.anchor {
+    display: inline;
+}
+
+h1 a.anchor:hover, h2 a.anchor:hover, h3 a.anchor:hover, h4 a.anchor:hover,
+h5 a.anchor:hover, h6 a.anchor:hover {
+    color: #777;
+    background-color: #eee;
+}
+
+a.headerlink {
+    color: #c60f0f!important;
+    font-size: 1em;
+    margin-left: 6px;
+    padding: 0 4px 0 4px;
+    text-decoration: none!important;
+}
+
+a.headerlink:hover {
+    background-color: #ccc;
+    color: white!important;
+}
+
+cite, code, tt {
+    font-family: 'Consolas', 'Deja Vu Sans Mono',
+                 'Bitstream Vera Sans Mono', monospace;
+    font-size: 0.95em;
+    letter-spacing: 0.01em;
+}
+
+tt {
+    background-color: #f2f2f2;
+    border-bottom: 1px solid #ddd;
+    color: #333;
+}
+
+tt.descname, tt.descclassname, tt.xref {
+    border: 0;
+}
+
+hr {
+    border: 1px solid #abc;
+    margin: 2em;
+}
+
+a tt {
+    border: 0;
+    color: #CA7900;
+}
+
+a tt:hover {
+    color: #2491CF;
+}
+
+pre {
+    font-family: 'Consolas', 'Deja Vu Sans Mono',
+                 'Bitstream Vera Sans Mono', monospace;
+    font-size: 0.95em;
+    letter-spacing: 0.015em;
+    line-height: 120%;
+    padding: 0.5em;
+    border: 1px solid #ccc;
+    background-color: #f8f8f8;
+}
+
+pre a {
+    color: inherit;
+    text-decoration: underline;
+}
+
+td.linenos pre {
+    padding: 0.5em 0;
+}
+
+div.quotebar {
+    background-color: #f8f8f8;
+    max-width: 250px;
+    float: right;
+    padding: 2px 7px;
+    border: 1px solid #ccc;
+}
+
+div.topic {
+    background-color: #f8f8f8;
+}
+
+table {
+    border-collapse: collapse;
+    margin: 0 -0.5em 0 -0.5em;
+}
+
+table td, table th {
+    padding: 0.2em 0.5em 0.2em 0.5em;
+}
+
+div.admonition, div.warning {
+    font-size: 0.9em;
+    margin: 1em 0 1em 0;
+    border: 1px solid #86989B;
+    background-color: #f7f7f7;
+    padding: 0;
+}
+
+div.admonition p, div.warning p {
+    margin: 0.5em 1em 0.5em 1em;
+    padding: 0;
+}
+
+div.admonition pre, div.warning pre {
+    margin: 0.4em 1em 0.4em 1em;
+}
+
+div.admonition p.admonition-title,
+div.warning p.admonition-title {
+    margin: 0;
+    padding: 0.1em 0 0.1em 0.5em;
+    color: white;
+    border-bottom: 1px solid #86989B;
+    font-weight: bold;
+    background-color: #AFC1C4;
+}
+
+div.warning {
+    border: 1px solid #940000;
+}
+
+div.warning p.admonition-title {
+    background-color: #CF0000;
+    border-bottom-color: #940000;
+}
+
+div.admonition ul, div.admonition ol,
+div.warning ul, div.warning ol {
+    margin: 0.1em 0.5em 0.5em 3em;
+    padding: 0;
+}
+
+div.versioninfo {
+    margin: 1em 0 0 0;
+    border: 1px solid #ccc;
+    background-color: #DDEAF0;
+    padding: 8px;
+    line-height: 1.3em;
+    font-size: 0.9em;
+}
+
+.viewcode-back {
+    font-family: 'Lucida Grande', 'Lucida Sans Unicode', 'Geneva',
+                 'Verdana', sans-serif;
+}
+
+div.viewcode-block:target {
+    background-color: #f4debf;
+    border-top: 1px solid #ac9;
+    border-bottom: 1px solid #ac9;
+}

doc/_templates/indexsidebar.html

@@ -0,0 +1,22 @@
+<h3>Download</h3>
+{% if version.endswith('(hg)') %}
+<p>This documentation is for version <b>{{ version }}</b>, which is
+  not released yet.</p>
+<p>You can use it from the
+  <a href="http://bitbucket.org/hpk42/pytest">Bitbucket Repo</a> or look for
+  released versions in the <a href="http://pypi.python.org/pypi/pytest">Python
+    Package Index</a>.</p>
+{% else %}
+<p><b><a href="{{ pathto('announce/index')}}">{{ release }} release</a></b>
+[<a href="{{ pathto('changelog') }}">Changelog</a>]</p>
+<p>
+<a href="http://pypi.python.org/pypi/pytest">pytest/PyPI</a>
+</p>
+<pre>easy_install pytest</pre>
+<pre>pip install pytest</pre>
+{% endif %}
+
+<h3>Questions? Suggestions?</h3>
+
+<p><a href="{{ pathto('contact') }}">contact channels</a>
+</p>

doc/_templates/layout.html

@@ -0,0 +1,24 @@
+{% extends "!layout.html" %}
+
+{% block relbaritems %}
+{{ super() }}
+<g:plusone></g:plusone>
+{% endblock %}
+
+{% block footer %}
+{{ super() }}
+<script type="text/javascript">
+
+  var _gaq = _gaq || [];
+  _gaq.push(['_setAccount', 'UA-7597274-13']);
+  _gaq.push(['_trackPageview']);
+
+  (function() {
+    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+  })();
+
+</script>
+<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
+{% endblock %}

doc/_templates/localtoc.html

@@ -0,0 +1,37 @@
+
+{%- if pagename != "search" %}
+<div id="searchbox" style="display: none">
+    <form class="search" action="{{ pathto('search') }}" method="get">
+      <input type="text" name="q" size="18" />
+      <input type="submit" value="{{ _('Search') }}" />
+      <input type="hidden" name="check_keywords" value="yes" />
+      <input type="hidden" name="area" value="default" />
+    </form>
+</div>
+<script type="text/javascript">$('#searchbox').show(0);</script>
+{%- endif %}
+
+<h3>quicklinks</h3>
+<div style="text-align: left; font-size: 100%; vertical-align: middle;">
+<table>
+<tr>
+<td>
+        <a href="{{ pathto('index') }}">home</a>
+</td><td>
+        <a href="{{ pathto('contents') }}">TOC/contents</a>
+</td></tr><tr><td>
+        <a href="{{ pathto('getting-started') }}">install</a>
+</td><td>
+        <a href="{{ pathto('changelog') }}">changelog</a>
+</td></tr><tr><td>
+        <a href="{{ pathto('example/index') }}">examples</a>
+</td><td>
+        <a href="{{ pathto('customize') }}">customize</a>
+</td></tr><tr><td>
+        <a href="https://bitbucket.org/hpk42/pytest/issues?status=new&status=open">issues[bb]</a>
+</td><td>
+        <a href="{{ pathto('contact') }}">contact</a>
+</td></tr></table>
+</div>
+{% extends "basic/localtoc.html" %}
+

doc/announce/index.txt

@@ -0,0 +1,19 @@
+
+Release announcements
+===========================================
+
+.. toctree::
+   :maxdepth: 2
+
+   release-2.2.2
+   release-2.2.1
+   release-2.2.0
+   release-2.1.3
+   release-2.1.2
+   release-2.1.1
+   release-2.1.0
+   release-2.0.3
+   release-2.0.2
+   release-2.0.1
+   release-2.0.0
+

doc/announce/release-0.9.0.txt

@@ -1,7 +0,0 @@
-py lib 1.0.0: XXX
-======================================================================
-
-Welcome to the 1.0.0 py lib release - a library aiming to 
-support agile and test-driven python development on various levels. 
-
-XXX

doc/announce/release-0.9.2.txt

@@ -1,27 +0,0 @@
-py lib 0.9.2: bugfix release
-=============================
-
-Welcome to the 0.9.2 py lib and py.test release - 
-mainly fixing Windows issues, providing better
-packaging and integration with setuptools.
-
-Here is a quick summary of what the py lib provides: 
-
-* py.test: cross-project testing tool with many advanced features
-* py.execnet: ad-hoc code distribution to SSH, Socket and local sub processes
-* py.magic.greenlet: micro-threads on standard CPython ("stackless-light")
-* py.path: path abstractions over local and subversion files 
-* rich documentation of py's exported API 
-* tested against Linux, Win32, OSX, works on python 2.3-2.6
-
-See here for more information:
-
-Pypi pages: http://pypi.python.org/pypi/py/
-
-Download/Install:   http://codespeak.net/py/0.9.2/download.html
-
-Documentation/API:  http://codespeak.net/py/0.9.2/index.html
-
-best and have fun,
-
-holger krekel

doc/announce/release-1.0.0.txt

@@ -1,63 +0,0 @@
-
-pylib 1.0.0 released: testing-with-python innovations continue
---------------------------------------------------------------------
-
-Took a few betas but finally i uploaded a `1.0.0 py lib release`_,
-featuring the mature and powerful py.test tool and "execnet-style"
-*elastic* distributed programming.  With the new release, there are
-many new advanced automated testing features - here is a quick summary:
-
-* funcargs_ - pythonic zero-boilerplate fixtures for Python test functions :
-
-  - totally separates test code, test configuration and test setup 
-  - ideal for integration and functional tests
-  - allows for flexible and natural test parametrization schemes
-
-* new `plugin architecture`_, allowing easy-to-write project-specific and cross-project single-file plugins.   The most notable new external plugin is `oejskit`_ which naturally enables **running and reporting of javascript-unittests in real-life browsers**. 
-
-* many new features done in easy-to-improve `default plugins`_, highlights:
-
-  * xfail: mark tests as "expected to fail" and report separately.
-  * pastebin: automatically send tracebacks to pocoo paste service 
-  * capture: flexibly capture stdout/stderr of subprocesses, per-test ...
-  * monkeypatch: safely monkeypatch modules/classes from within tests
-  * unittest: run and integrate traditional unittest.py tests 
-  * figleaf: generate html coverage reports with the figleaf module
-  * resultlog: generate buildbot-friendly reporting output 
-  * ...
-
-* `distributed testing`_ and `elastic distributed execution`_: 
-
-  - new unified "TX" URL scheme for specifying remote processes 
-  - new distribution modes "--dist=each" and "--dist=load" 
-  - new sync/async ways to handle 1:N communication 
-  - improved documentation 
-
-The py lib continues to offer most of the functionality used by
-the testing tool in `independent namespaces`_.  
-
-Some non-test related code, notably greenlets/co-routines and
-api-generation now live as their own projects which simplifies the
-installation procedure because no C-Extensions are required anymore. 
-
-The whole package should work well with Linux, Win32 and OSX, on Python
-2.3, 2.4, 2.5 and 2.6.  (Expect Python3 compatibility soon!) 
-
-For more info, see the py.test and py lib documentation: 
-
-    http://pytest.org
-
-    http://pylib.org
-
-have fun, 
-holger
-
-.. _`independent namespaces`: http://pylib.org
-.. _`funcargs`: http://codespeak.net/py/dist/test/funcargs.html
-.. _`plugin architecture`: http://codespeak.net/py/dist/test/extend.html
-.. _`default plugins`: http://codespeak.net/py/dist/test/plugin/index.html
-.. _`distributed testing`: http://codespeak.net/py/dist/test/dist.html
-.. _`elastic distributed execution`: http://codespeak.net/py/dist/execnet.html
-.. _`1.0.0 py lib release`: http://pypi.python.org/pypi/py 
-.. _`oejskit`: http://codespeak.net/py/dist/test/plugin/oejskit.html
-

doc/announce/release-1.0.1.txt

@@ -1,48 +0,0 @@
-1.0.1: improved reporting, nose/unittest.py support, bug fixes
------------------------------------------------------------------------
-
-This is a bugfix release of pylib/py.test also coming with: 
-
-* improved documentation, improved navigation 
-* test failure reporting improvements
-* support for directly running existing nose/unittest.py style tests
-
-visit here for more info, including quickstart and tutorials: 
-
-    http://pytest.org and http://pylib.org
-
-
-Changelog 1.0.0 to 1.0.1 
-------------------------
-
-* added a default 'pytest_nose' plugin which handles nose.SkipTest, 
-  nose-style function/method/generator setup/teardown and 
-  tries to report functions correctly.  
-
-* improved documentation, better navigation: see http://pytest.org 
-
-* added a "--help-config" option to show conftest.py / ENV-var names for
-  all longopt cmdline options, and some special conftest.py variables. 
-  renamed 'conf_capture' conftest setting to 'option_capture' accordingly. 
-
-* unicode fixes: capturing and unicode writes to sys.stdout 
-  (through e.g a print statement) now work within tests, 
-  they are encoded as "utf8" by default, also terminalwriting 
-  was adapted and somewhat unified between windows and linux 
-
-* fix issue #27: better reporting on non-collectable items given on commandline 
-  (e.g. pyc files)
-
-* fix issue #33: added --version flag (thanks Benjamin Peterson) 
-
-* fix issue #32: adding support for "incomplete" paths to wcpath.status()
-
-* "Test" prefixed classes are *not* collected by default anymore if they 
-  have an __init__ method 
-
-* monkeypatch setenv() now accepts a "prepend" parameter
-
-* improved reporting of collection error tracebacks
-
-* simplified multicall mechanism and plugin architecture, 
-  renamed some internal methods and argnames 

doc/announce/release-1.0.2.txt

@@ -1,5 +0,0 @@
-1.0.2: packaging fixes 
------------------------------------------------------------------------
-
-this release is purely a release for fixing packaging issues.
-

doc/announce/release-1.1.0.txt

@@ -1,115 +0,0 @@
-py.test/pylib 1.1.0: Python3, Jython, advanced skipping, cleanups ... 
---------------------------------------------------------------------------------
-
-Features:
-
-* compatible to Python3 (single py2/py3 source), `easy to install`_
-* conditional skipping_: skip/xfail based on platform/dependencies
-* generalized marking_: mark tests one a whole-class or whole-module basis
-
-Fixes:
-
-* code reduction and "de-magification" (e.g. 23 KLoc -> 11 KLOC)
-* distribute testing requires the now separately released execnet_ package 
-* funcarg-setup/caching, "same-name" test modules now cause an exlicit error
-* de-cluttered reporting options, --report for skipped/xfail details 
-
-Compatibilities
-
-1.1.0 should allow running test code that already worked well with 1.0.2 
-plus some more due to improved unittest/nose compatibility.  
-
-More information: http://pytest.org 
-
-thanks and have fun,
-
-holger (http://twitter.com/hpk42)
-
-.. _execnet: http://codespeak.net/execnet
-.. _`easy to install`: ../install.html
-.. _marking: ../test/plugin/mark.html
-.. _skipping: ../test/plugin/skipping.html
-
-
-Changelog 1.0.2 -> 1.1.0
------------------------------------------------------------------------
-
-* remove py.rest tool and internal namespace - it was
-  never really advertised and can still be used with
-  the old release if needed.  If there is interest 
-  it could be revived into its own tool i guess.
-
-* fix issue48 and issue59: raise an Error if the module
-  from an imported test file does not seem to come from 
-  the filepath - avoids "same-name" confusion that has
-  been reported repeatedly
-
-* merged Ronny's nose-compatibility hacks: now
-  nose-style setup_module() and setup() functions are 
-  supported
-
-* introduce generalized py.test.mark function marking
-
-* reshuffle / refine command line grouping
-
-* deprecate parser.addgroup in favour of getgroup which creates option group
-
-* add --report command line option that allows to control showing of skipped/xfailed sections 
-
-* generalized skipping: a new way to mark python functions with skipif or xfail 
-  at function, class and modules level based on platform or sys-module attributes. 
-
-* extend py.test.mark decorator to allow for positional args
-
-* introduce and test "py.cleanup -d" to remove empty directories 
-
-* fix issue #59 - robustify unittest test collection
-
-* make bpython/help interaction work by adding an __all__ attribute 
-  to ApiModule, cleanup initpkg
-
-* use MIT license for pylib, add some contributors
-
-* remove py.execnet code and substitute all usages with 'execnet' proper
-
-* fix issue50 - cached_setup now caches more to expectations 
-  for test functions with multiple arguments. 
-
-* merge Jarko's fixes, issue #45 and #46
-
-* add the ability to specify a path for py.lookup to search in
-
-* fix a funcarg cached_setup bug probably only occuring 
-  in distributed testing and "module" scope with teardown. 
-
-* many fixes and changes for making the code base python3 compatible,
-  many thanks to Benjamin Peterson for helping with this. 
-
-* consolidate builtins implementation to be compatible with >=2.3, 
-  add helpers to ease keeping 2 and 3k compatible code
-
-* deprecate py.compat.doctest|subprocess|textwrap|optparse
-
-* deprecate py.magic.autopath, remove py/magic directory 
-
-* move pytest assertion handling to py/code and a pytest_assertion
-  plugin, add "--no-assert" option, deprecate py.magic namespaces 
-  in favour of (less) py.code ones. 
-
-* consolidate and cleanup py/code classes and files 
-
-* cleanup py/misc, move tests to bin-for-dist 
-
-* introduce delattr/delitem/delenv methods to py.test's monkeypatch funcarg 
-
-* consolidate py.log implementation, remove old approach. 
-
-* introduce py.io.TextIO and py.io.BytesIO for distinguishing between
-  text/unicode and byte-streams (uses underlying standard lib io.* 
-  if available) 
-
-* make py.unittest_convert helper script available which converts "unittest.py" 
-  style files into the simpler assert/direct-test-classes py.test/nosetests
-  style.  The script was written by Laura Creighton. 
- 
-* simplified internal localpath implementation 

doc/announce/release-1.1.1.txt

@@ -1,48 +0,0 @@
-py.test/pylib 1.1.1: bugfix release, setuptools plugin registration
---------------------------------------------------------------------------------
-
-This is a compatibility fixing release of pylib/py.test to work
-better with previous 1.0.x test code bases.  It also contains fixes
-and changes to work with `execnet>=1.0.0`_ to provide distributed
-testing and looponfailing testing modes.  py-1.1.1 also introduces
-a new mechanism for registering plugins via setuptools. 
-
-What is pylib/py.test? 
------------------------
-
-py.test is an advanced automated testing tool working with
-Python2, Python3 and Jython versions on all major operating
-systems. It has an extensive plugin architecture and can run many 
-existing common Python test suites without modification.  Moreover,
-it offers some unique features not found in other
-testing tools.  See http://pytest.org for more info.
-
-The pylib also contains a localpath and svnpath implementation 
-and some developer-oriented command line tools. See
-http://pylib.org for more info.
-
-thanks to all who helped and gave feedback,
-have fun,
-
-holger (http://twitter.com/hpk42)
-
-.. _`execnet>=1.0.0`: http://codespeak.net/execnet
-
-Changes between 1.1.1 and 1.1.0
-=====================================
-
-- introduce automatic plugin registration via 'pytest11' 
-  entrypoints via setuptools' pkg_resources.iter_entry_points
-
-- fix py.test dist-testing to work with execnet >= 1.0.0b4 
-
-- re-introduce py.test.cmdline.main() for better backward compatibility 
-
-- svn paths: fix a bug with path.check(versioned=True) for svn paths,
-  allow '%' in svn paths, make svnwc.update() default to interactive mode 
-  like in 1.0.x and add svnwc.update(interactive=False) to inhibit interaction.
-
-- refine distributed tarball to contain test and no pyc files
-
-- try harder to have deprecation warnings for py.compat.* accesses
-  report a correct location

doc/announce/release-1.2.0.txt

@@ -1,116 +0,0 @@
-py.test/pylib 1.2.0: junitxml, standalone test scripts, pluginization
---------------------------------------------------------------------------------
-
-py.test is an advanced automated testing tool working with
-Python2, Python3 and Jython versions on all major operating
-systems.  It has a simple plugin architecture and can run many 
-existing common Python test suites without modification.  It offers 
-some unique features not found in other testing tools.  
-See http://pytest.org for more info.
-
-py.test 1.2.0 brings many bug fixes and interesting new abilities:
-
-* --junitxml=path will create an XML file for use with CI processing 
-* --genscript=path creates a standalone py.test-equivalent test-script 
-* --ignore=path prevents collection of anything below that path
-* --confcutdir=path only lookup conftest.py test configs below that path
-* a 'pytest_report_header' hook to add info to the terminal report header 
-* a 'pytestconfig' function argument gives direct access to option values
-* 'pytest_generate_tests' can now be put into a class as well 
-* on CPython py.test additionally installs as "py.test-VERSION", on
-  Jython as py.test-jython and on PyPy as py.test-pypy-XYZ
-
-Apart from many bug fixes 1.2.0 also has better pluginization: 
-Distributed testing and looponfailing testing now live in the
-separately installable 'pytest-xdist' plugin.  The same is true for
-'pytest-figleaf' for doing coverage reporting.  Those two plugins
-can serve well now as blue prints for doing your own.  
-
-thanks to all who helped and gave feedback,
-have fun,
-
-holger krekel, January 2010
-
-Changes between 1.2.0 and 1.1.1
-=====================================
-
-- moved dist/looponfailing from py.test core into a new 
-  separately released pytest-xdist plugin.
-
-- new junitxml plugin: --junitxml=path will generate a junit style xml file
-  which is processable e.g. by the Hudson CI system. 
-
-- new option: --genscript=path will generate a standalone py.test script
-  which will not need any libraries installed.  thanks to Ralf Schmitt. 
-
-- new option: --ignore will prevent specified path from collection. 
-  Can be specified multiple times. 
-
-- new option: --confcutdir=dir will make py.test only consider conftest 
-  files that are relative to the specified dir.  
-
-- new funcarg: "pytestconfig" is the pytest config object for access
-  to command line args and can now be easily used in a test. 
-
-- install 'py.test' and `py.which` with a ``-$VERSION`` suffix to
-  disambiguate between Python3, python2.X, Jython and PyPy installed versions. 
-
-- new "pytestconfig" funcarg allows access to test config object
-
-- new "pytest_report_header" hook can return additional lines 
-  to be displayed at the header of a test run. 
-
-- (experimental) allow "py.test path::name1::name2::..." for pointing
-  to a test within a test collection directly.  This might eventually
-  evolve as a full substitute to "-k" specifications. 
-
-- streamlined plugin loading: order is now as documented in
-  customize.html: setuptools, ENV, commandline, conftest. 
-  also setuptools entry point names are turned to canonical namees ("pytest_*")
-
-- automatically skip tests that need 'capfd' but have no os.dup 
-
-- allow pytest_generate_tests to be defined in classes as well 
-
-- deprecate usage of 'disabled' attribute in favour of pytestmark 
-- deprecate definition of Directory, Module, Class and Function nodes
-  in conftest.py files.  Use pytest collect hooks instead.
-
-- collection/item node specific runtest/collect hooks are only called exactly
-  on matching conftest.py files, i.e. ones which are exactly below
-  the filesystem path of an item
-
-- change: the first pytest_collect_directory hook to return something
-  will now prevent further hooks to be called.
-
-- change: figleaf plugin now requires --figleaf to run.  Also
-  change its long command line options to be a bit shorter (see py.test -h).
-
-- change: pytest doctest plugin is now enabled by default and has a
-  new option --doctest-glob to set a pattern for file matches. 
-
-- change: remove internal py._* helper vars, only keep py._pydir 
-
-- robustify capturing to survive if custom pytest_runtest_setup 
-  code failed and prevented the capturing setup code from running. 
-
-- make py.test.* helpers provided by default plugins visible early -
-  works transparently both for pydoc and for interactive sessions
-  which will regularly see e.g. py.test.mark and py.test.importorskip. 
-
-- simplify internal plugin manager machinery 
-- simplify internal collection tree by introducing a RootCollector node
-
-- fix assert reinterpreation that sees a call containing "keyword=..."
-
-- fix issue66: invoke pytest_sessionstart and pytest_sessionfinish 
-  hooks on slaves during dist-testing, report module/session teardown 
-  hooks correctly.
-
-- fix issue65: properly handle dist-testing if no 
-  execnet/py lib installed remotely. 
-
-- skip some install-tests if no execnet is available
-
-- fix docs, fix internal bin/ script generation
-

doc/announce/release-1.2.1.txt

@@ -1,66 +0,0 @@
-py.test/pylib 1.2.1: little fixes and improvements 
---------------------------------------------------------------------------------
-
-py.test is an advanced automated testing tool working with
-Python2, Python3 and Jython versions on all major operating
-systems.  It has a simple plugin architecture and can run many 
-existing common Python test suites without modification.  It offers 
-some unique features not found in other testing tools.  
-See http://pytest.org for more info.
-
-py.test 1.2.1 brings bug fixes and some new options and abilities triggered 
-by user feedback:
-
-* --funcargs [testpath]  will show available builtin- and project funcargs.
-* display a short and concise traceback if funcarg lookup fails.
-* early-load "conftest.py" files in non-dot first-level sub directories. 
-* --tb=line will print a single line for each failing test (issue67)
-* py.cleanup has a number of new options, cleanups up setup.py related files
-* fix issue78: always call python-level teardown functions even if the
-  according setup failed.  
-
-For more detailed information see the changelog below. 
-
-cheers and have fun,
-
-holger 
-
-
-Changes between 1.2.1 and 1.2.0
-=====================================
-
-- refined usage and options for "py.cleanup"::
-
-    py.cleanup     # remove "*.pyc" and "*$py.class" (jython) files
-    py.cleanup -e .swp -e .cache # also remove files with these extensions
-    py.cleanup -s  # remove "build" and "dist" directory next to setup.py files
-    py.cleanup -d  # also remove empty directories 
-    py.cleanup -a  # synonym for "-s -d -e 'pip-log.txt'"
-    py.cleanup -n  # dry run, only show what would be removed
-
-- add a new option "py.test --funcargs" which shows available funcargs 
-  and their help strings (docstrings on their respective factory function) 
-  for a given test path
-
-- display a short and concise traceback if a funcarg lookup fails 
-
-- early-load "conftest.py" files in non-dot first-level sub directories. 
-  allows to conveniently keep and access test-related options in a ``test`` 
-  subdir and still add command line options. 
-
-- fix issue67: new super-short traceback-printing option: "--tb=line" will print a single line for each failing (python) test indicating its filename, lineno and the failure value
-
-- fix issue78: always call python-level teardown functions even if the
-  according setup failed.  This includes refinements for calling setup_module/class functions 
-  which will now only be called once instead of the previous behaviour where they'd be called
-  multiple times if they raise an exception (including a Skipped exception).  Any exception
-  will be re-corded and associated with all tests in the according module/class scope.
-
-- fix issue63: assume <40 columns to be a bogus terminal width, default to 80
-
-- fix pdb debugging to be in the correct frame on raises-related errors 
-
-- update apipkg.py to fix an issue where recursive imports might
-  unnecessarily break importing 
-
-- fix plugin links 

doc/announce/release-2.0.0.txt

@@ -0,0 +1,129 @@
+py.test 2.0.0: asserts++, unittest++, reporting++, config++, docs++
+===========================================================================
+
+Welcome to pytest-2.0.0, a major new release of "py.test", the rapid
+easy Python testing tool.  There are many new features and enhancements,
+see below for summary and detailed lists.  A lot of long-deprecated code
+has been removed, resulting in a much smaller and cleaner
+implementation.  See the new docs with examples here:
+
+    http://pytest.org/2.0.0/index.html
+
+A note on packaging: pytest used to part of the "py" distribution up
+until version py-1.3.4 but this has changed now:  pytest-2.0.0 only
+contains py.test related code and is expected to be backward-compatible
+to existing test code. If you want to install pytest, just type one of::
+
+    pip install -U pytest
+    easy_install -U pytest
+
+Many thanks to all issue reporters and people asking questions or
+complaining.  Particular thanks to Floris Bruynooghe and Ronny Pfannschmidt
+for their great coding contributions and many others for feedback and help.
+
+best,
+holger krekel
+
+
+New Features
+-----------------------
+
+- new invocations through Python interpreter and from Python::
+
+    python -m pytest      # on all pythons >= 2.5
+
+  or from a python program::
+
+    import pytest ; pytest.main(arglist, pluginlist)
+
+  see http://pytest.org/2.0.0/usage.html for details.
+
+- new and better reporting information in assert expressions
+  if comparing lists, sequences or strings.
+
+  see http://pytest.org/2.0.0/assert.html#newreport
+
+- new configuration through ini-files (setup.cfg or tox.ini recognized),
+  for example::
+
+    [pytest]
+    norecursedirs = .hg data*  # don't ever recurse in such dirs
+    addopts = -x --pyargs      # add these command line options by default
+
+  see http://pytest.org/2.0.0/customize.html
+
+- improved standard unittest support.  In general py.test should now
+  better be able to run custom unittest.TestCases like twisted trial
+  or Django based TestCases.  Also you can now run the tests of an
+  installed 'unittest' package with py.test::
+
+    py.test --pyargs unittest
+
+- new "-q" option which decreases verbosity and prints a more
+  nose/unittest-style "dot" output.
+
+- many many more detailed improvements details
+
+Fixes
+-----------------------
+
+- fix issue126 - introduce py.test.set_trace() to trace execution via
+  PDB during the running of tests even if capturing is ongoing.
+- fix issue124 - make reporting more resilient against tests opening
+  files on filedescriptor 1 (stdout).
+- fix issue109 - sibling conftest.py files will not be loaded.
+  (and Directory collectors cannot be customized anymore from a Directory's
+  conftest.py - this needs to happen at least one level up).
+- fix issue88 (finding custom test nodes from command line arg)
+- fix issue93 stdout/stderr is captured while importing conftest.py
+- fix bug: unittest collected functions now also can have "pytestmark"
+  applied at class/module level
+
+Important Notes
+--------------------
+
+* The usual way in pre-2.0 times to use py.test in python code was
+  to import "py" and then e.g. use "py.test.raises" for the helper.
+  This remains valid and is not planned to be deprecated.  However,
+  in most examples and internal code you'll find "import pytest"
+  and "pytest.raises" used as the recommended default way.
+
+* pytest now first performs collection of the complete test suite
+  before running any test. This changes for example the semantics of when
+  pytest_collectstart/pytest_collectreport are called.  Some plugins may
+  need upgrading.
+
+* The pytest package consists of a 400 LOC core.py and about 20 builtin plugins,
+  summing up to roughly 5000 LOCs, including docstrings. To be fair, it also
+  uses generic code from the "pylib", and the new "py" package to help
+  with filesystem and introspection/code manipulation.
+
+(Incompatible) Removals
+-----------------------------
+
+- py.test.config is now only available if you are in a test run.
+
+- the following (mostly already deprecated) functionality was removed:
+
+  - removed support for Module/Class/... collection node definitions
+    in conftest.py files.  They will cause nothing special.
+  - removed support for calling the pre-1.0 collection API of "run()" and "join"
+  - removed reading option values from conftest.py files or env variables.
+    This can now be done much much better and easier through the ini-file
+    mechanism and the "addopts" entry in particular.
+  - removed the "disabled" attribute in test classes.  Use the skipping
+    and pytestmark mechanism to skip or xfail a test class.
+
+- py.test.collect.Directory does not exist anymore and it
+  is not possible to provide an own "Directory" object.
+  If you have used this and don't know what to do, get
+  in contact.  We'll figure something out.
+
+  Note that pytest_collect_directory() is still called but
+  any return value will be ignored.  This allows to keep
+  old code working that performed for example "py.test.skip()"
+  in collect() to prevent recursion into directory trees
+  if a certain dependency or command line option is missing.
+
+
+see :ref:`changelog` for more detailed changes.

doc/announce/release-2.0.1.txt

@@ -0,0 +1,67 @@
+py.test 2.0.1: bug fixes
+===========================================================================
+
+Welcome to pytest-2.0.1, a maintenance and bug fix release of pytest,
+a mature testing tool for Python, supporting CPython 2.4-3.2, Jython
+and latest PyPy interpreters.  See extensive docs with tested examples here:
+
+    http://pytest.org/
+
+If you want to install or upgrade pytest, just type one of::
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+Many thanks to all issue reporters and people asking questions or
+complaining.  Particular thanks to Floris Bruynooghe and Ronny Pfannschmidt
+for their great coding contributions and many others for feedback and help.
+
+best,
+holger krekel
+
+Changes between 2.0.0 and 2.0.1
+----------------------------------------------
+
+- refine and unify initial capturing so that it works nicely
+  even if the logging module is used on an early-loaded conftest.py
+  file or plugin.
+- fix issue12 - show plugin versions with "--version" and
+  "--traceconfig" and also document how to add extra information
+  to reporting test header
+- fix issue17 (import-* reporting issue on python3) by
+  requiring py>1.4.0 (1.4.1 is going to include it)
+- fix issue10 (numpy arrays truth checking) by refining
+  assertion interpretation in py lib
+- fix issue15: make nose compatibility tests compatible
+  with python3 (now that nose-1.0 supports python3)
+- remove somewhat surprising "same-conftest" detection because
+  it ignores conftest.py when they appear in several subdirs.
+- improve assertions ("not in"), thanks Floris Bruynooghe
+- improve behaviour/warnings when running on top of "python -OO"
+  (assertions and docstrings are turned off, leading to potential
+  false positives)
+- introduce a pytest_cmdline_processargs(args) hook
+  to allow dynamic computation of command line arguments.
+  This fixes a regression because py.test prior to 2.0
+  allowed to set command line options from conftest.py
+  files which so far pytest-2.0 only allowed from ini-files now.
+- fix issue7: assert failures in doctest modules.
+  unexpected failures in doctests will not generally
+  show nicer, i.e. within the doctest failing context.
+- fix issue9: setup/teardown functions for an xfail-marked
+  test will report as xfail if they fail but report as normally
+  passing (not xpassing) if they succeed.  This only is true
+  for "direct" setup/teardown invocations because teardown_class/
+  teardown_module cannot closely relate to a single test.
+- fix issue14: no logging errors at process exit
+- refinements to "collecting" output on non-ttys
+- refine internal plugin registration and --traceconfig output
+- introduce a mechanism to prevent/unregister plugins from the
+  command line, see http://pytest.org/plugins.html#cmdunregister
+- activate resultlog plugin by default
+- fix regression wrt yielded tests which due to the
+  collection-before-running semantics were not
+  setup as with pytest 1.3.4.  Note, however, that
+  the recommended and much cleaner way to do test
+  parametrization remains the "pytest_generate_tests"
+  mechanism, see the docs.

doc/announce/release-2.0.2.txt

@@ -0,0 +1,73 @@
+py.test 2.0.2: bug fixes, improved xfail/skip expressions, speed ups
+===========================================================================
+
+Welcome to pytest-2.0.2, a maintenance and bug fix release of pytest,
+a mature testing tool for Python, supporting CPython 2.4-3.2, Jython
+and latest PyPy interpreters.  See the extensive docs with tested examples here:
+
+    http://pytest.org/
+
+If you want to install or upgrade pytest, just type one of::
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+Many thanks to all issue reporters and people asking questions
+or complaining, particularly Jurko for his insistence,
+Laura, Victor and Brianna for helping with improving
+and Ronny for his general advise.
+
+best,
+holger krekel
+
+Changes between 2.0.1 and 2.0.2
+----------------------------------------------
+
+- tackle issue32 - speed up test runs of very quick test functions
+  by reducing the relative overhead
+
+- fix issue30 - extended xfail/skipif handling and improved reporting.
+  If you have a syntax error in your skip/xfail
+  expressions you now get nice error reports.
+
+  Also you can now access module globals from xfail/skipif
+  expressions so that this for example works now::
+
+    import pytest
+    import mymodule
+    @pytest.mark.skipif("mymodule.__version__[0] == "1")
+    def test_function():
+        pass
+
+  This will not run the test function if the module's version string
+  does not start with a "1".  Note that specifying a string instead
+  of a boolean expressions allows py.test to report meaningful information
+  when summarizing a test run as to what conditions lead to skipping
+  (or xfail-ing) tests.
+
+- fix issue28 - setup_method and pytest_generate_tests work together
+  The setup_method fixture method now gets called also for
+  test function invocations generated from the pytest_generate_tests
+  hook.
+
+- fix issue27 - collectonly and keyword-selection (-k) now work together
+  Also, if you do "py.test --collectonly -q" you now get a flat list
+  of test ids that you can use to paste to the py.test commandline
+  in order to execute a particular test.
+
+- fix issue25 avoid reported problems with --pdb and python3.2/encodings output
+
+- fix issue23 - tmpdir argument now works on Python3.2 and WindowsXP
+  Starting with Python3.2 os.symlink may be supported. By requiring
+  a newer py lib version the py.path.local() implementation acknowledges
+  this.
+
+- fixed typos in the docs (thanks Victor Garcia, Brianna Laugher) and particular
+  thanks to Laura Creighton who also revieved parts of the documentation.
+
+- fix slighly wrong output of verbose progress reporting for classes
+  (thanks Amaury)
+
+- more precise (avoiding of) deprecation warnings for node.Class|Function accesses
+
+- avoid std unittest assertion helper code in tracebacks (thanks Ronny)

doc/announce/release-2.0.3.txt

@@ -0,0 +1,40 @@
+py.test 2.0.3: bug fixes and speed ups 
+===========================================================================
+
+Welcome to pytest-2.0.3, a maintenance and bug fix release of pytest,
+a mature testing tool for Python, supporting CPython 2.4-3.2, Jython
+and latest PyPy interpreters.  See the extensive docs with tested examples here:
+
+    http://pytest.org/
+
+If you want to install or upgrade pytest, just type one of::
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+There also is a bugfix release 1.6 of pytest-xdist, the plugin
+that enables seemless distributed and "looponfail" testing for Python.
+
+best,
+holger krekel
+
+Changes between 2.0.2 and 2.0.3
+----------------------------------------------
+
+- fix issue38: nicer tracebacks on calls to hooks, particularly early
+  configure/sessionstart ones
+
+- fix missing skip reason/meta information in junitxml files, reported
+  via http://lists.idyll.org/pipermail/testing-in-python/2011-March/003928.html
+
+- fix issue34: avoid collection failure with "test" prefixed classes
+  deriving from object.
+
+- don't require zlib (and other libs) for genscript plugin without
+  --genscript actually being used.
+
+- speed up skips (by not doing a full traceback represenation
+  internally)
+
+- fix issue37: avoid invalid characters in junitxml's output
+

doc/announce/release-2.1.0.txt

@@ -0,0 +1,47 @@
+py.test 2.1.0: perfected assertions and bug fixes
+===========================================================================
+
+Welcome to the release of pytest-2.1, a mature testing tool for Python,
+supporting CPython 2.4-3.2, Jython and latest PyPy interpreters.  See
+the improved extensive docs (now also as PDF!) with tested examples here:
+
+     http://pytest.org/
+
+The single biggest news about this release are **perfected assertions**
+courtesy of Benjamin Peterson.  You can now safely use ``assert``
+statements in test modules without having to worry about side effects
+or python optimization ("-OO") options.  This is achieved by rewriting
+assert statements in test modules upon import, using a PEP302 hook.
+See http://pytest.org/assert.html#advanced-assertion-introspection for
+detailed information.  The work has been partly sponsored by my company,
+merlinux GmbH.
+
+For further details on bug fixes and smaller enhancements see below.
+
+If you want to install or upgrade pytest, just type one of::
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+best,
+holger krekel / http://merlinux.eu
+
+Changes between 2.0.3 and 2.1.0
+----------------------------------------------
+
+- fix issue53 call nosestyle setup functions with correct ordering
+- fix issue58 and issue59: new assertion code fixes
+- merge Benjamin's assertionrewrite branch: now assertions
+  for test modules on python 2.6 and above are done by rewriting
+  the AST and saving the pyc file before the test module is imported.
+  see doc/assert.txt for more info.
+- fix issue43: improve doctests with better traceback reporting on
+  unexpected exceptions
+- fix issue47: timing output in junitxml for test cases is now correct
+- fix issue48: typo in MarkInfo repr leading to exception
+- fix issue49: avoid confusing error when initialization partially fails
+- fix issue44: env/username expansion for junitxml file path
+- show releaselevel information in test runs for pypy
+- reworked doc pages for better navigation and PDF generation
+- report KeyboardInterrupt even if interrupted during session startup
+- fix issue 35 - provide PDF doc version and download link from index page

doc/announce/release-2.1.1.txt

@@ -0,0 +1,37 @@
+py.test 2.1.1: assertion fixes and improved junitxml output
+===========================================================================
+
+pytest-2.1.1 is a backward compatible maintenance release of the
+popular py.test testing tool.  See extensive docs with examples here:
+
+     http://pytest.org/
+
+Most bug fixes address remaining issues with the perfected assertions
+introduced with 2.1.0 - many thanks to the bug reporters and to Benjamin
+Peterson for helping to fix them.  Also, junitxml output now produces
+system-out/err tags which lead to better displays of tracebacks with Jenkins.
+
+Also a quick note to package maintainers and others interested: there now
+is a "pytest" man page which can be generated with "make man" in doc/.
+
+If you want to install or upgrade pytest, just type one of::
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+best,
+holger krekel / http://merlinux.eu
+
+Changes between 2.1.0 and 2.1.1
+----------------------------------------------
+
+- fix issue64 / pytest.set_trace now works within pytest_generate_tests hooks
+- fix issue60 / fix error conditions involving the creation of __pycache__
+- fix issue63 / assertion rewriting on inserts involving strings containing '%'
+- fix assertion rewriting on calls with a ** arg
+- don't cache rewritten modules if bytecode generation is disabled
+- fix assertion rewriting in read-only directories
+- fix issue59: provide system-out/err tags for junitxml output
+- fix issue61: assertion rewriting on boolean operations with 3 or more operands
+- you can now build a man page with "cd doc ; make man"
+

doc/announce/release-2.1.2.txt

@@ -0,0 +1,33 @@
+py.test 2.1.2: bug fixes and fixes for jython
+===========================================================================
+
+pytest-2.1.2 is a minor backward compatible maintenance release of the
+popular py.test testing tool.  pytest is commonly used for unit,
+functional- and integration testing.  See extensive docs with examples
+here:
+
+     http://pytest.org/
+
+Most bug fixes address remaining issues with the perfected assertions
+introduced in the 2.1 series - many thanks to the bug reporters and to Benjamin
+Peterson for helping to fix them.  pytest should also work better with
+Jython-2.5.1 (and Jython trunk).
+
+If you want to install or upgrade pytest, just type one of::
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+best,
+holger krekel / http://merlinux.eu
+
+Changes between 2.1.1 and 2.1.2
+----------------------------------------
+
+- fix assertion rewriting on files with windows newlines on some Python versions
+- refine test discovery by package/module name (--pyargs), thanks Florian Mayer
+- fix issue69 / assertion rewriting fixed on some boolean operations
+- fix issue68 / packages now work with assertion rewriting
+- fix issue66: use different assertion rewriting caches when the -O option is passed
+- don't try assertion rewriting on Jython, use reinterp
+

doc/announce/release-2.1.3.txt

@@ -0,0 +1,32 @@
+py.test 2.1.3: just some more fixes
+===========================================================================
+
+pytest-2.1.3 is a minor backward compatible maintenance release of the
+popular py.test testing tool.  It is commonly used for unit, functional-
+and integration testing.  See extensive docs with examples here:
+
+     http://pytest.org/
+
+The release contains another fix to the perfected assertions introduced
+with the 2.1 series as well as the new possibility to customize reporting
+for assertion expressions on a per-directory level.  
+
+If you want to install or upgrade pytest, just type one of::
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+Thanks to the bug reporters and to Ronny Pfannschmidt, Benjamin Peterson
+and Floris Bruynooghe who implemented the fixes.
+
+best,
+holger krekel
+
+Changes between 2.1.2 and 2.1.3
+----------------------------------------
+
+- fix issue79: assertion rewriting failed on some comparisons in boolops,
+- correctly handle zero length arguments (a la pytest '')
+- fix issue67 / junitxml now contains correct test durations
+- fix issue75 / skipping test failure on jython
+- fix issue77 / Allow assertrepr_compare hook to apply to a subset of tests

doc/announce/release-2.2.0.txt

@@ -0,0 +1,95 @@
+py.test 2.2.0: test marking++, parametrization++ and duration profiling
+===========================================================================
+
+pytest-2.2.0 is a test-suite compatible release of the popular
+py.test testing tool.  Plugins might need upgrades. It comes
+with these improvements:
+
+* easier and more powerful parametrization of tests:
+
+  - new @pytest.mark.parametrize decorator to run tests with different arguments
+  - new metafunc.parametrize() API for parametrizing arguments independently
+  - see examples at http://pytest.org/latest/example/parametrize.html
+  - NOTE that parametrize() related APIs are still a bit experimental
+    and might change in future releases.
+
+* improved handling of test markers and refined marking mechanism:
+
+  - "-m markexpr" option for selecting tests according to their mark
+  - a new "markers" ini-variable for registering test markers for your project
+  - the new "--strict" bails out with an error if using unregistered markers.
+  - see examples at http://pytest.org/latest/example/markers.html
+
+* duration profiling: new "--duration=N" option showing the N slowest test
+  execution or setup/teardown calls. This is most useful if you want to
+  find out where your slowest test code is.
+
+* also 2.2.0 performs more eager calling of teardown/finalizers functions
+  resulting in better and more accurate reporting when they fail
+
+Besides there is the usual set of bug fixes along with a cleanup of
+pytest's own test suite allowing it to run on a wider range of environments.
+
+For general information, see extensive docs with examples here:
+
+     http://pytest.org/
+
+If you want to install or upgrade pytest you might just type::
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+Thanks to Ronny Pfannschmidt, David Burns, Jeff Donner, Daniel Nouri, Alfredo Deza and all who gave feedback or sent bug reports.
+
+best,
+holger krekel
+
+
+notes on incompatibility
+------------------------------
+
+While test suites should work unchanged you might need to upgrade plugins:
+
+* You need a new version of the pytest-xdist plugin (1.7) for distributing
+  test runs.
+
+* Other plugins might need an upgrade if they implement
+  the ``pytest_runtest_logreport`` hook which now is called unconditionally
+  for the setup/teardown fixture phases of a test. You may choose to
+  ignore setup/teardown failures by inserting "if rep.when != 'call': return"
+  or something similar. Note that most code probably "just" works because
+  the hook was already called for failing setup/teardown phases of a test
+  so a plugin should have been ready to grok such reports already.
+
+
+Changes between 2.1.3 and 2.2.0
+----------------------------------------
+
+- fix issue90: introduce eager tearing down of test items so that
+  teardown function are called earlier.
+- add an all-powerful metafunc.parametrize function which allows to
+  parametrize test function arguments in multiple steps and therefore
+  from independent plugins and places.
+- add a @pytest.mark.parametrize helper which allows to easily
+  call a test function with different argument values.
+- Add examples to the "parametrize" example page, including a quick port
+  of Test scenarios and the new parametrize function and decorator.
+- introduce registration for "pytest.mark.*" helpers via ini-files
+  or through plugin hooks.  Also introduce a "--strict" option which
+  will treat unregistered markers as errors
+  allowing to avoid typos and maintain a well described set of markers
+  for your test suite.  See examples at http://pytest.org/latest/mark.html
+  and its links.
+- issue50: introduce "-m marker" option to select tests based on markers
+  (this is a stricter and more predictable version of "-k" in that "-m"
+  only matches complete markers and has more obvious rules for and/or
+  semantics.
+- new feature to help optimizing the speed of your tests:
+  --durations=N option for displaying N slowest test calls
+  and setup/teardown methods.
+- fix issue87: --pastebin now works with python3
+- fix issue89: --pdb with unexpected exceptions in doctest work more sensibly
+- fix and cleanup pytest's own test suite to not leak FDs
+- fix issue83: link to generated funcarg list
+- fix issue74: pyarg module names are now checked against imp.find_module false positives
+- fix compatibility with twisted/trial-11.1.0 use cases

doc/announce/release-2.2.1.txt

@@ -0,0 +1,41 @@
+pytest-2.2.1: bug fixes, perfect teardowns
+===========================================================================
+
+
+pytest-2.2.1 is a minor backward-compatible release of the the py.test
+testing tool.   It contains bug fixes and little improvements, including
+documentation fixes.  If you are using the distributed testing
+pluginmake sure to upgrade it to pytest-xdist-1.8.
+
+For general information see here:
+
+     http://pytest.org/
+
+To install or upgrade pytest:
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+Special thanks for helping on this release to Ronny Pfannschmidt, Jurko
+Gospodnetic and Ralf Schmitt.
+
+best,
+holger krekel
+
+
+Changes between 2.2.0 and 2.2.1
+----------------------------------------
+
+- fix issue99 (in pytest and py) internallerrors with resultlog now
+  produce better output - fixed by normalizing pytest_internalerror 
+  input arguments.
+- fix issue97 / traceback issues (in pytest and py) improve traceback output
+  in conjunction with jinja2 and cython which hack tracebacks
+- fix issue93 (in pytest and pytest-xdist) avoid "delayed teardowns":
+  the final test in a test node will now run its teardown directly
+  instead of waiting for the end of the session. Thanks Dave Hunt for
+  the good reporting and feedback.  The pytest_runtest_protocol as well
+  as the pytest_runtest_teardown hooks now have "nextitem" available 
+  which will be None indicating the end of the test run.
+- fix collection crash due to unknown-source collected items, thanks
+  to Ralf Schmitt (fixed by depending on a more recent pylib)

doc/announce/release-2.2.2.txt

@@ -0,0 +1,42 @@
+pytest-2.2.2: bug fixes
+===========================================================================
+
+pytest-2.2.2 is a minor backward-compatible release of the versatile py.test
+testing tool.   It contains bug fixes and a few refinements particularly
+to reporting with "--collectonly", see below for betails.  
+
+For general information see here:
+
+     http://pytest.org/
+
+To install or upgrade pytest:
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+Special thanks for helping on this release to Ronny Pfannschmidt
+and Ralf Schmitt and the contributors of issues.
+
+best,
+holger krekel
+
+
+Changes between 2.2.1 and 2.2.2
+----------------------------------------
+
+- fix issue101: wrong args to unittest.TestCase test function now
+  produce better output
+- fix issue102: report more useful errors and hints for when a 
+  test directory was renamed and some pyc/__pycache__ remain
+- fix issue106: allow parametrize to be applied multiple times
+  e.g. from module, class and at function level.
+- fix issue107: actually perform session scope finalization
+- don't check in parametrize if indirect parameters are funcarg names
+- add chdir method to monkeypatch funcarg
+- fix crash resulting from calling monkeypatch undo a second time
+- fix issue115: make --collectonly robust against early failure
+  (missing files/directories)
+- "-qq --collectonly" now shows only files and the number of tests in them
+- "-q --collectonly" now shows test ids 
+- allow adding of attributes to test reports such that it also works
+  with distributed testing (no upgrade of pytest-xdist needed)

doc/announce/releases.txt

@@ -1,16 +0,0 @@
-=============
-Release notes
-=============
-
-Contents:
-
-.. toctree::
-   :maxdepth: 2
-
-.. include: release-1.1.0
-.. include: release-1.0.2
-
-   release-1.0.1
-   release-1.0.0
-   release-0.9.2
-   release-0.9.0