regen docs / examples for 2.2.2

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

.hgtags

@@ -44,3 +44,5 @@ c777dcad166548b7499564cb49ae5c8b4b07f935 2.0.3
 e5e1746a197f0398356a43fbe2eebac9690f795d 2.1.0
 5864412c6f3c903384243bd315639d101d7ebc67 2.1.2
 12a05d59249f80276e25fd8b96e8e545b1332b7a 2.1.3
+1522710369337d96bf9568569d5f0ca9b38a74e0 2.2.0
+3da8cec6c5326ed27c144c9b6d7a64a648370005 2.2.1

CHANGELOG

@@ -1,3 +1,40 @@
+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)
+
+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)
+
 Changes between 2.1.3 and 2.2.0
 ----------------------------------------
 
@@ -29,6 +66,9 @@ Changes between 2.1.3 and 2.2.0
 - 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
+- simplify Node.listchain
+- simplify junitxml output code by relying on py.xml
+- add support for skip properties on unittest classes and functions
 
 Changes between 2.1.2 and 2.1.3
 ----------------------------------------

ISSUES.txt

@@ -1,3 +1,24 @@
+refine parametrize API in 2.2 series
+-------------------------------------------------------------
+tags: critical feature 2.2
+
+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
@@ -27,7 +48,7 @@ teardown.
 
 do early-teardown of test modules
 -----------------------------------------
-tags: feature 2.2
+tags: feature 2.3
 
 currently teardowns are called when the next tests is setup
 except for the function/method level where interally
@@ -39,7 +60,7 @@ prints of teardown-code appear in the setup of the next test.
 
 consider and document __init__ file usage in test directories
 ---------------------------------------------------------------
-tags: bug 2.2 core
+tags: bug 2.3 core
 
 Currently, a test module is imported with its fully qualified
 package path, determined by checking __init__ files upwards.
@@ -54,7 +75,7 @@ certain scenarios makes sense.
 
 relax requirement to have tests/testing contain an __init__
 ----------------------------------------------------------------
-tags: feature 2.2
+tags: feature 2.3
 bb: http://bitbucket.org/hpk42/py-trunk/issue/64
 
 A local test run of a "tests" directory may work
@@ -65,7 +86,7 @@ i.e. port the nose-logic of unloading a test module.
 
 customize test function collection
 -------------------------------------------------------
-tags: feature 2.2
+tags: feature 2.3
 
 - introduce py.test.mark.nocollect for not considering a function for
   test collection at all.  maybe also introduce a py.test.mark.test to
@@ -74,7 +95,7 @@ tags: feature 2.2
 
 introduce pytest.mark.importorskip
 -------------------------------------------------------
-tags: feature 2.2
+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.
@@ -82,7 +103,7 @@ a pytest.mark.importorskip so that the test count is more correct.
 
 introduce py.test.mark.platform
 -------------------------------------------------------
-tags: feature 2.2
+tags: feature 2.3
 
 Introduce nice-to-spell platform-skipping, examples:
 
@@ -99,17 +120,17 @@ interpreter versions.
 
 pytest.mark.xfail signature change
 -------------------------------------------------------
-tags: feature 2.2
+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? Maybe rename to "pytest.mark.xfail"?
+Compatibility? how to introduce a new name/keep compat?
 
 introduce py.test.mark registration
 -----------------------------------------
-tags: feature 2.2
+tags: feature 2.3
 
 introduce a hook that allows to register a named mark decorator
 with documentation and add "py.test --marks" to get
@@ -118,7 +139,7 @@ definitions.
 
 allow to non-intrusively apply skipfs/xfail/marks
 ---------------------------------------------------
-tags: feature 2.2
+tags: feature 2.3
 
 use case: mark a module or directory structures
 to be skipped on certain platforms (i.e. no import
@@ -129,14 +150,14 @@ from conftests or plugins.
 
 explicit referencing of conftest.py files
 -----------------------------------------
-tags: feature 2.2
+tags: feature 2.3
 
 allow to name conftest.py files (in sub directories) that should
 be imported early, as to include command line options.
 
 improve central py.test ini file
 ----------------------------------
-tags: feature 2.2
+tags: feature 2.3
 
 introduce more declarative configuration options:
 - (to-be-collected test directories)
@@ -147,33 +168,16 @@ introduce more declarative configuration options:
 
 new documentation
 ----------------------------------
-tags: feature 2.2
+tags: feature 2.3
 
 - logo py.test
 - examples for unittest or functional testing
 - resource management for functional testing
 - patterns: page object
-- parametrized testing
-- better / more integrated plugin docs
-
-generalize parametrized testing to generate combinations
--------------------------------------------------------------
-tags: feature 2.2
-
-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
------------------------------------------
-tags: feature 1.3
-
-introduce py.test.mark.multi to specify a number
-of values for a given function argument.
 
 have imported module mismatch honour relative paths
 --------------------------------------------------------
-tags: bug 2.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
@@ -181,7 +185,7 @@ path. Normalize.
 
 call termination with small timeout
 -------------------------------------------------
-tags: feature 2.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.
@@ -189,7 +193,7 @@ Should make dist-testing less likely to leave lost processes.
 
 consider globals: py.test.ensuretemp and config
 --------------------------------------------------------------
-tags: experimental-wish 2.2
+tags: experimental-wish 2.3
 
 consider deprecating py.test.ensuretemp and py.test.config
 to further reduce py.test globality.  Also consider
@@ -198,7 +202,7 @@ a plugin rather than being there from the start.
 
 consider allowing funcargs for setup methods
 --------------------------------------------------------------
-tags: experimental-wish 2.2
+tags: experimental-wish 2.3
 
 Users have expressed the wish to have funcargs available to setup
 functions.  Experiment with allowing funcargs there - it might
@@ -208,13 +212,20 @@ factories with a request object that not have a cls/function
 attributes.  However, how to handle parametrized test functions
 and funcargs?
 
-setup_function -> request can be like it is now
-setup_class -> request has no request.function
-setup_module -> request has no request.cls
+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: 2.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
@@ -226,7 +237,7 @@ and pytest_configure.
 
 show plugin information in test header
 ----------------------------------------------------------------
-tags: feature 2.2
+tags: feature 2.3
 
 Now that external plugins are becoming more numerous
 it would be useful to have external plugins along with
@@ -234,7 +245,7 @@ their versions displayed as a header line.
 
 deprecate global py.test.config usage
 ----------------------------------------------------------------
-tags: feature 2.2
+tags: feature 2.3
 
 py.test.ensuretemp and py.test.config are probably the last
 objects containing global state.  Often using them is not
@@ -244,9 +255,32 @@ as others.
 
 remove deprecated bits in collect.py
 -------------------------------------------------------------------
-tags: feature 2.2
+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
+
+

_pytest/__init__.py

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

_pytest/hookspec.py

@@ -121,16 +121,23 @@ def pytest_generate_tests(metafunc):
 def pytest_itemstart(item, node=None):
     """ (deprecated, use pytest_runtest_logstart). """
 
-def pytest_runtest_protocol(item):
-    """ implements the standard runtest_setup/call/teardown protocol including
-    capturing exceptions and calling reporting hooks on the results accordingly.
+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 a test run. """
+    """ signal the start of running a single test item. """
 
 def pytest_runtest_setup(item):
     """ called before ``pytest_runtest_call(item)``. """
@@ -138,8 +145,14 @@ def pytest_runtest_setup(item):
 def pytest_runtest_call(item):
     """ called to execute the test ``item``. """
 
-def pytest_runtest_teardown(item):
-    """ called after ``pytest_runtest_call``. """
+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
@@ -152,14 +165,6 @@ def pytest_runtest_logreport(report):
     """ process a test setup/call/teardown report relating to
     the respective phase of executing a test. """
 
-# special handling for final teardown - somewhat internal for now
-def pytest__teardown_final(session):
-    """ called before test session finishes. """
-pytest__teardown_final.firstresult = True
-
-def pytest__teardown_final_logerror(report, session):
-    """ called if runtest_teardown_final failed. """
-
 # -------------------------------------------------------------------------
 # test session related hooks
 # -------------------------------------------------------------------------

_pytest/junitxml.py

@@ -25,6 +25,10 @@ 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
@@ -40,6 +44,14 @@ illegal_xml_re = re.compile(unicode('[%s]') %
 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")
@@ -68,116 +80,97 @@ class LogXML(object):
         logfile = os.path.expanduser(os.path.expandvars(logfile))
         self.logfile = os.path.normpath(logfile)
         self.prefix = prefix
-        self.test_logs = []
+        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 = tuple(names)
-        d = {'time': getattr(report, 'duration', 0)}
         names = [x.replace(".py", "") for x in names if x != "()"]
         classnames = names[:-1]
         if self.prefix:
             classnames.insert(0, self.prefix)
-        d['classname'] = ".".join(classnames)
-        d['name'] = py.xml.escape(names[-1])
-        attrs = ['%s="%s"' % item for item in sorted(d.items())]
-        self.test_logs.append("\n<testcase %s>" % " ".join(attrs))
+        self.tests.append(Junit.testcase(
+            classname=".".join(classnames),
+            name=names[-1],
+            time=getattr(report, 'duration', 0)
+        ))
 
-    def _closetestcase(self):
-        self.test_logs.append("</testcase>")
-
-    def appendlog(self, fmt, *args):
-        def repl(matchobj):
-            i = ord(matchobj.group())
-            if i <= 0xFF:
-                return unicode('#x%02X') % i
-            else:
-                return unicode('#x%04X') % i
-        args = tuple([illegal_xml_re.sub(repl, py.xml.escape(arg))
-                      for arg in args])
-        self.test_logs.append(fmt % args)
+    def append(self, obj):
+        self.tests[-1].append(obj)
 
     def append_pass(self, report):
         self.passed += 1
-        self._opentestcase(report)
-        self._closetestcase()
 
     def append_failure(self, report):
-        self._opentestcase(report)
         #msg = str(report.longrepr.reprtraceback.extraline)
         if "xfail" in report.keywords:
-            self.appendlog(
-                '<skipped message="xfail-marked test passes unexpectedly"/>')
+            self.append(
+                Junit.skipped(message="xfail-marked test passes unexpectedly"))
             self.skipped += 1
         else:
             sec = dict(report.sections)
-            self.appendlog('<failure message="test failure">%s</failure>',
-                report.longrepr)
+            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:
-                    self.appendlog(
-                        "<system-%s>%%s</system-%s>" % (name, name), content)
+                    tag = getattr(Junit, 'system-'+name)
+                    self.append(tag(bin_xml_escape(content)))
             self.failed += 1
-        self._closetestcase()
 
     def append_collect_failure(self, report):
-        self._opentestcase(report)
         #msg = str(report.longrepr.reprtraceback.extraline)
-        self.appendlog('<failure message="collection failure">%s</failure>',
-            report.longrepr)
-        self._closetestcase()
+        self.append(Junit.failure(str(report.longrepr),
+                                  message="collection failure"))
         self.errors += 1
 
     def append_collect_skipped(self, report):
-        self._opentestcase(report)
         #msg = str(report.longrepr.reprtraceback.extraline)
-        self.appendlog('<skipped message="collection skipped">%s</skipped>',
-            report.longrepr)
-        self._closetestcase()
+        self.append(Junit.skipped(str(report.longrepr),
+                                  message="collection skipped"))
         self.skipped += 1
 
     def append_error(self, report):
-        self._opentestcase(report)
-        self.appendlog('<error message="test setup failure">%s</error>',
-            report.longrepr)
-        self._closetestcase()
+        self.append(Junit.error(str(report.longrepr),
+                                message="test setup failure"))
         self.errors += 1
 
     def append_skipped(self, report):
-        self._opentestcase(report)
         if "xfail" in report.keywords:
-            self.appendlog(
-                '<skipped message="expected test failure">%s</skipped>',
-                report.keywords['xfail'])
+            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.appendlog('<skipped type="pytest.skip" '
-                           'message="%s">%s</skipped>',
-                skipreason, "%s:%s: %s" % report.longrepr,
-                )
-        self._closetestcase()
+            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:
@@ -186,10 +179,11 @@ class LogXML(object):
     def pytest_internalerror(self, excrepr):
         self.errors += 1
         data = py.xml.escape(excrepr)
-        self.test_logs.append(
-            '\n<testcase classname="pytest" name="internal">'
-            '    <error message="internal error">'
-            '%s</error></testcase>' % data)
+        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()
@@ -203,17 +197,17 @@ class LogXML(object):
         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('<testsuite ')
-        logfile.write('name="" ')
-        logfile.write('errors="%i" ' % self.errors)
-        logfile.write('failures="%i" ' % self.failed)
-        logfile.write('skips="%i" ' % self.skipped)
-        logfile.write('tests="%i" ' % numtests)
-        logfile.write('time="%.3f"' % suite_time_delta)
-        logfile.write(' >')
-        logfile.writelines(self.test_logs)
-        logfile.write('</testsuite>')
+        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):

_pytest/main.py

@@ -106,8 +106,12 @@ def pytest_collection(session):
 def pytest_runtestloop(session):
     if session.config.option.collectonly:
         return True
-    for item in session.items:
-        item.config.hook.pytest_runtest_protocol(item=item)
+    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
@@ -229,13 +233,13 @@ class Node(object):
     def listchain(self):
         """ return list of all parent collectors up to self,
             starting from root of collection tree. """
-        l = [self]
-        while 1:
-            x = l[0]
-            if x.parent is not None: # and x.parent.parent is not None:
-                l.insert(0, x.parent)
-            else:
-                return l
+        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()]
@@ -406,6 +410,7 @@ class Session(FSCollector):
         self._notfound = []
         self._initialpaths = set()
         self._initialparts = []
+        self.items = items = []
         for arg in args:
             parts = self._parsearg(arg)
             self._initialparts.append(parts)
@@ -421,7 +426,6 @@ class Session(FSCollector):
         if not genitems:
             return rep.result
         else:
-            self.items = items = []
             if rep.passed:
                 for node in rep.result:
                     self.items.extend(self.genitems(node))

_pytest/mark.py

@@ -191,8 +191,7 @@ class MarkDecorator:
                         holder = MarkInfo(self.markname, self.args, self.kwargs)
                         setattr(func, self.markname, holder)
                     else:
-                        holder.kwargs.update(self.kwargs)
-                        holder.args += self.args
+                        holder.add(self.args, self.kwargs)
                 return func
         kw = self.kwargs.copy()
         kw.update(kwargs)
@@ -208,27 +207,20 @@ class MarkInfo:
         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 pytest_itemcollected(item):
-    if not isinstance(item, pytest.Function):
-        return
-    try:
-        func = item.obj.__func__
-    except AttributeError:
-        func = getattr(item.obj, 'im_func', item.obj)
-    pyclasses = (pytest.Class, pytest.Module)
-    for node in item.listchain():
-        if isinstance(node, pyclasses):
-            marker = getattr(node.obj, 'pytestmark', None)
-            if marker is not None:
-                if isinstance(marker, list):
-                    for mark in marker:
-                        mark(func)
-                else:
-                    marker(func)
-        node = node.parent
-    item.keywords.update(py.builtin._getfuncdict(func))
+    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

@@ -13,6 +13,7 @@ def pytest_funcarg__monkeypatch(request):
         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``
@@ -30,6 +31,7 @@ class monkeypatch:
     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
@@ -83,6 +85,17 @@ class monkeypatch:
             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
@@ -95,9 +108,17 @@ class monkeypatch:
         self._setattr[:] = []
         for dictionary, name, value in self._setitem:
             if value is notset:
-                del dictionary[name]
+                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/python.py

@@ -33,7 +33,8 @@ def pytest_generate_tests(metafunc):
         param = metafunc.function.parametrize
     except AttributeError:
         return
-    metafunc.parametrize(*param.args, **param.kwargs)
+    for p in param:
+        metafunc.parametrize(*p.args, **p.kwargs)
 
 def pytest_configure(config):
     config.addinivalue_line("markers",
@@ -156,6 +157,7 @@ class PyobjMixin(object):
             obj = obj.place_as
 
         self._fslineno = py.code.getfslineno(obj)
+        assert isinstance(self._fslineno[1], int), obj
         return self._fslineno
 
     def reportinfo(self):
@@ -173,6 +175,7 @@ class PyobjMixin(object):
         else:
             fspath, lineno = self._getfslineno()
             modpath = self.getmodpath()
+        assert isinstance(lineno, int)
         return fspath, lineno, modpath
 
 class PyCollectorMixin(PyobjMixin, pytest.Collector):
@@ -218,6 +221,7 @@ class PyCollectorMixin(PyobjMixin, pytest.Collector):
         module = self.getparent(Module).obj
         clscol = self.getparent(Class)
         cls = clscol and clscol.obj or None
+        transfer_markers(funcobj, cls, module)
         metafunc = Metafunc(funcobj, config=self.config,
             cls=cls, module=module)
         gentesthook = self.config.hook.pytest_generate_tests
@@ -237,6 +241,19 @@ class PyCollectorMixin(PyobjMixin, pytest.Collector):
             l.append(function)
         return l
 
+def transfer_markers(funcobj, cls, mod):
+    # XXX this should rather be code in the mark plugin or the mark
+    # plugin should merge with the python plugin.
+    for holder in (cls, mod):
+        try:
+            pytestmark = holder.pytestmark
+        except AttributeError:
+            continue
+        if isinstance(pytestmark, list):
+            for mark in pytestmark:
+                mark(funcobj)
+        else:
+            pytestmark(funcobj)
 
 class Module(pytest.File, PyCollectorMixin):
     def _getobj(self):
@@ -257,7 +274,8 @@ class Module(pytest.File, PyCollectorMixin):
                 "  %s\n"
                 "which is not the same as the test file we want to collect:\n"
                 "  %s\n"
-                "HINT: use a unique basename for your test file modules"
+                "HINT: remove __pycache__ / .pyc files and/or use a "
+                "unique basename for your test file modules"
                  % e.args
             )
         #print "imported test module", mod
@@ -556,7 +574,7 @@ class CallSpec2(object):
 
     @property
     def id(self):
-        return "-".join(filter(None, self._idlist))
+        return "-".join(map(str, filter(None, self._idlist)))
 
     def setmulti(self, valtype, argnames, valset, id):
         for arg,val in zip(argnames, valset):
@@ -588,31 +606,34 @@ class Metafunc:
         self._ids = py.builtin.set()
 
     def parametrize(self, argnames, argvalues, indirect=False, ids=None):
-        """ parametrize calls to the underlying test function during
-        the collection phase of a test run.  parametrize may be called
-        multiple times for disjunct argnames sets.
+        """ Add new invocations to the underlying test function using the list
+        of argvalues for the given argnames.  Parametrization is performed
+        during the collection phase.  If you need to setup expensive resources
+        you may pass indirect=True and implement a funcarg factory which can
+        perform the expensive setup just before a test is actually run.
 
         :arg argnames: an argument name or a list of argument names
 
-        :arg argvalues: a list of values for a single argument if argnames
-            specified a single argument only or a list of tuples which specify
-            values for the multiple argument names.
+        :arg argvalues: a list of values for the argname or a list of tuples of
+            values for the list of argument names.
 
-        :arg indirect: if True each argvalue corresponding to an argument will be
-            passed as request.param to the respective funcarg factory so that
-            it can perform more expensive setups during the setup phase of
-            a test rather than at collection time (which is the default).
+        :arg indirect: if True each argvalue corresponding to an argument will
+            be passed as request.param to its respective funcarg factory so
+            that it can perform more expensive setups during the setup phase of
+            a test rather than at collection time.
 
-        :arg ids: list of string ids corresponding to the (list of) argvalues
-            so that they are part of the test id. If no ids are provided
-            they will be generated automatically from the argvalues.
+        :arg ids: list of string ids each corresponding to the argvalues so
+            that they are part of the test id. If no ids are provided they will
+            be generated automatically from the argvalues.
         """
         if not isinstance(argnames, (tuple, list)):
             argnames = (argnames,)
             argvalues = [(val,) for val in argvalues]
-        for arg in argnames:
-            if arg not in self.funcargnames:
-                raise ValueError("%r has no argument %r" %(self.function, arg))
+        if not indirect:
+            #XXX should we also check for the opposite case?
+            for arg in argnames:
+                if arg not in self.funcargnames:
+                    raise ValueError("%r has no argument %r" %(self.function, arg))
         valtype = indirect and "params" or "funcargs"
         if not ids:
             idmaker = IDMaker()
@@ -627,12 +648,11 @@ class Metafunc:
         self._calls = newcalls
 
     def addcall(self, funcargs=None, id=_notexists, param=_notexists):
-        """ (deprecated, use parametrize) add a new call to the underlying
-        test function during
-        the collection phase of a test run.  Note that request.addcall() is
-        called during the test collection phase prior and independently
-        to actual test execution.  You should only use addcall()
-        if you need to specify multiple arguments of a test function
+        """ (deprecated, use parametrize) Add a new call to the underlying
+        test function during the collection phase of a test run.  Note that
+        request.addcall() is called during the test collection phase prior and
+        independently to actual test execution.  You should only use addcall()
+        if you need to specify multiple arguments of a test function.
 
         :arg funcargs: argument keyword dictionary used when invoking
             the test function.
@@ -749,7 +769,7 @@ class FuncargRequest:
 
 
     def applymarker(self, marker):
-        """ apply a marker to a single test function invocation.
+        """ Apply a marker to a single test function invocation.
         This method is useful if you don't want to have a keyword/marker
         on all function invocations.
 
@@ -761,7 +781,7 @@ class FuncargRequest:
         self._pyfuncitem.keywords[marker.markname] = marker
 
     def cached_setup(self, setup, teardown=None, scope="module", extrakey=None):
-        """ return a testing resource managed by ``setup`` &
+        """ Return a testing resource managed by ``setup`` &
         ``teardown`` calls.  ``scope`` and ``extrakey`` determine when the
         ``teardown`` function will be called so that subsequent calls to
         ``setup`` would recreate the resource.
@@ -936,8 +956,7 @@ def raises(ExpectedException, *args, **kwargs):
         >>> raises(ZeroDivisionError, f, x=0)
         <ExceptionInfo ...>
 
-    A third possibility is to use a string which which will
-    be executed::
+    A third possibility is to use a string to be executed::
 
         >>> raises(ZeroDivisionError, "f(0)")
         <ExceptionInfo ...>

_pytest/resultlog.py

@@ -91,5 +91,8 @@ class ResultLog(object):
             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

@@ -47,45 +47,27 @@ def pytest_terminal_summary(terminalreporter):
 
 def pytest_sessionstart(session):
     session._setupstate = SetupState()
-
-def pytest_sessionfinish(session, exitstatus):
-    hook = session.config.hook
-    rep = hook.pytest__teardown_final(session=session)
-    if rep:
-        hook.pytest__teardown_final_logerror(session=session, report=rep)
-        session.exitstatus = 1
+def pytest_sessionfinish(session):
+    session._setupstate.teardown_all()
 
 class NodeInfo:
     def __init__(self, location):
         self.location = location
 
-def perform_pending_teardown(config, nextitem):
-    try:
-        olditem, log = config._pendingteardown
-    except AttributeError:
-        pass
-    else:
-        del config._pendingteardown
-        olditem.nextitem = nextitem
-        call_and_report(olditem, "teardown", log)
-
-def pytest_runtest_protocol(item):
-    perform_pending_teardown(item.config, item)
+def pytest_runtest_protocol(item, nextitem):
     item.ihook.pytest_runtest_logstart(
         nodeid=item.nodeid, location=item.location,
     )
-    runtestprotocol(item, teardowndelayed=True)
+    runtestprotocol(item, nextitem=nextitem)
     return True
 
-def runtestprotocol(item, log=True, teardowndelayed=False):
+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))
-    if teardowndelayed:
-        item.config._pendingteardown = item, log
-    else:
-        reports.append(call_and_report(item, "teardown", log))
+    reports.append(call_and_report(item, "teardown", log,
+        nextitem=nextitem))
     return reports
 
 def pytest_runtest_setup(item):
@@ -94,17 +76,8 @@ def pytest_runtest_setup(item):
 def pytest_runtest_call(item):
     item.runtest()
 
-def pytest_runtest_teardown(item):
-    item.session._setupstate.teardown_exact(item)
-
-def pytest__teardown_final(session):
-    perform_pending_teardown(session.config, None)
-    #call = CallInfo(session._setupstate.teardown_all, when="teardown")
-    #if call.excinfo:
-    #    ntraceback = call.excinfo.traceback .cut(excludepath=py._pydir)
-    #    call.excinfo.traceback = ntraceback.filter()
-    #    longrepr = call.excinfo.getrepr(funcargs=True)
-    #    return TeardownErrorReport(longrepr)
+def pytest_runtest_teardown(item, nextitem):
+    item.session._setupstate.teardown_exact(item, nextitem)
 
 def pytest_report_teststatus(report):
     if report.when in ("setup", "teardown"):
@@ -120,18 +93,18 @@ def pytest_report_teststatus(report):
 #
 # Implementation
 
-def call_and_report(item, when, log=True):
-    call = call_runtest_hook(item, when)
+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):
+def call_runtest_hook(item, when, **kwds):
     hookname = "pytest_runtest_" + when
     ihook = getattr(item.ihook, hookname)
-    return CallInfo(lambda: ihook(item=item), when=when)
+    return CallInfo(lambda: ihook(item=item, **kwds), when=when)
 
 class CallInfo:
     """ Result/Exception info a function invocation. """
@@ -170,6 +143,10 @@ def getslaveinfoline(node):
         return s
 
 class BaseReport(object):
+
+    def __init__(self, **kw):
+        self.__dict__.update(kw)
+
     def toterminal(self, out):
         longrepr = self.longrepr
         if hasattr(self, 'node'):
@@ -219,7 +196,7 @@ class TestReport(BaseReport):
     they fail).
     """
     def __init__(self, nodeid, location,
-            keywords, outcome, longrepr, when, sections=(), duration=0):
+            keywords, outcome, longrepr, when, sections=(), duration=0, **extra):
         #: normalized collection node id
         self.nodeid = nodeid
 
@@ -248,6 +225,8 @@ class TestReport(BaseReport):
         #: 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)
@@ -255,9 +234,10 @@ class TestReport(BaseReport):
 class TeardownErrorReport(BaseReport):
     outcome = "failed"
     when = "teardown"
-    def __init__(self, longrepr):
+    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")
@@ -279,12 +259,13 @@ def pytest_make_collect_report(collector):
         getattr(call, 'result', None))
 
 class CollectReport(BaseReport):
-    def __init__(self, nodeid, outcome, longrepr, result, sections=()):
+    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):
@@ -338,9 +319,8 @@ class SetupState(object):
         self._teardown_with_finalization(None)
         assert not self._finalizers
 
-    def teardown_exact(self, item):
-        colitem = item.nextitem
-        needed_collectors = colitem and colitem.listchain() or []
+    def teardown_exact(self, item, nextitem):
+        needed_collectors = nextitem and nextitem.listchain() or []
         self._teardown_towards(needed_collectors)
 
     def _teardown_towards(self, needed_collectors):

_pytest/terminal.py

@@ -161,9 +161,6 @@ class TerminalReporter:
     def pytest_deselected(self, items):
         self.stats.setdefault('deselected', []).extend(items)
 
-    def pytest__teardown_final_logerror(self, report):
-        self.stats.setdefault("error", []).append(report)
-
     def pytest_runtest_logstart(self, nodeid, location):
         # ensure that the path is printed before the
         # 1st test of a module starts running
@@ -285,10 +282,18 @@ class TerminalReporter:
         # 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:
-            for item in items:
-                nodeid = item.nodeid
-                nodeid = nodeid.replace("::()::", "::")
-                self._tw.line(nodeid)
+            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 = ""

_pytest/unittest.py

@@ -2,6 +2,9 @@
 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:
@@ -19,7 +22,14 @@ def pytest_pycollect_makeitem(collector, name, obj):
 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):
@@ -37,15 +47,13 @@ class UnitTestCase(pytest.Class):
 class TestCaseFunction(pytest.Function):
     _excinfo = None
 
-    def __init__(self, name, parent):
-        super(TestCaseFunction, self).__init__(name, parent)
-        if hasattr(self._obj, 'todo'):
-            getattr(self._obj, 'im_func', self._obj).xfail = \
-                pytest.mark.xfail(reason=str(self._obj.todo))
-
     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)
 
@@ -104,7 +112,10 @@ class TestCaseFunction(pytest.Function):
 
     def _prunetraceback(self, excinfo):
         pytest.Function._prunetraceback(self, excinfo)
-        excinfo.traceback = excinfo.traceback.filter(lambda x:not x.frame.f_globals.get('__unittest'))
+        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):

distribute_setup.py

@@ -46,7 +46,7 @@ except ImportError:
             args = [quote(arg) for arg in args]
         return os.spawnl(os.P_WAIT, sys.executable, *args) == 0
 
-DEFAULT_VERSION = "0.6.19"
+DEFAULT_VERSION = "0.6.24"
 DEFAULT_URL = "http://pypi.python.org/packages/source/d/distribute/"
 SETUPTOOLS_FAKED_VERSION = "0.6c11"
 

doc/Makefile

@@ -40,7 +40,7 @@ clean:
 	-rm -rf $(BUILDDIR)/*
 
 install: html
-	@rsync -avz _build/html/ pytest.org:/www/pytest.org/2.2.0
+	 rsync -avz _build/html/ pytest.org:/www/pytest.org/latest
 
 installpdf: latexpdf
 	@scp $(BUILDDIR)/latex/pytest.pdf pytest.org:/www/pytest.org/latest

doc/announce/index.txt

@@ -5,6 +5,8 @@ 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

doc/announce/release-2.0.2.txt

@@ -1,4 +1,4 @@
-py.test 2.0.2: bug fixes, improved xfail/skip expressions, speedups
+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,
@@ -32,17 +32,17 @@ Changes between 2.0.1 and 2.0.2
 
   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 
+  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 
+  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
@@ -65,7 +65,7 @@ Changes between 2.0.1 and 2.0.2
 - 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 
+- fix slighly wrong output of verbose progress reporting for classes
   (thanks Amaury)
 
 - more precise (avoiding of) deprecation warnings for node.Class|Function accesses

doc/announce/release-2.1.0.txt

@@ -1,7 +1,7 @@
 py.test 2.1.0: perfected assertions and bug fixes
 ===========================================================================
 
-Welcome to the relase of pytest-2.1, a mature testing tool for Python,
+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:
 
@@ -15,7 +15,7 @@ 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::
@@ -39,10 +39,9 @@ Changes between 2.0.3 and 2.1.0
   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 initizaliation partially fails
+- 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.2.0.txt

@@ -2,7 +2,7 @@ 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 
+py.test testing tool.  Plugins might need upgrades. It comes
 with these improvements:
 
 * easier and more powerful parametrization of tests:
@@ -20,11 +20,11 @@ with these improvements:
   - 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 
+* 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 
+* 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
@@ -39,8 +39,7 @@ 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 Doza and all who gave feedback or sent bug reports.
+Thanks to Ronny Pfannschmidt, David Burns, Jeff Donner, Daniel Nouri, Alfredo Deza and all who gave feedback or sent bug reports.
 
 best,
 holger krekel
@@ -51,14 +50,14 @@ 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.  
+* 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 
+  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.
 
@@ -68,29 +67,29 @@ 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 
+- add an all-powerful metafunc.parametrize function which allows to
   parametrize test function arguments in multiple steps and therefore
-  from indepdenent plugins and palces. 
+  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 
+  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 
+  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 exaples at http://pytest.org/latest/mark.html
+  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"
+  (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 
+- 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 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/assert.txt

@@ -23,7 +23,7 @@ you will see the return value of the function call::
 
     $ py.test test_assert1.py
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 1 items
     
     test_assert1.py F
@@ -73,7 +73,7 @@ and if you need to have access to the actual exception info you may use::
 
     # do checks related to excinfo.type, excinfo.value, excinfo.traceback
 
-If you want to write test code that works on Python2.4 as well,
+If you want to write test code that works on Python 2.4 as well,
 you may also use two other ways to test for an expected exception::
 
     pytest.raises(ExpectedException, func, *args, **kwargs)
@@ -105,7 +105,7 @@ if you run this module::
 
     $ py.test test_assert2.py
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 1 items
     
     test_assert2.py F
@@ -124,7 +124,7 @@ if you run this module::
     E         '5'
     
     test_assert2.py:5: AssertionError
-    ========================= 1 failed in 0.02 seconds =========================
+    ========================= 1 failed in 0.03 seconds =========================
 
 Special comparisons are done for a number of cases:
 

doc/builtin.txt

@@ -28,7 +28,7 @@ You can ask for available builtin or project-custom
 
     $ py.test --funcargs
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collected 0 items
     pytestconfig
         the pytest config object with access to command line opts.
@@ -60,6 +60,7 @@ You can ask for available builtin or project-custom
         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``
@@ -75,5 +76,7 @@ You can ask for available builtin or project-custom
         See http://docs.python.org/library/warnings.html for information
         on warning categories.
         
+    cov
+        A pytest funcarg that provides access to the underlying coverage object.
     
-    =============================  in 0.00 seconds =============================
+    =============================  in 0.01 seconds =============================

doc/capture.txt

@@ -64,7 +64,7 @@ of the failing function and hide the other one::
 
     $ py.test
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 2 items
     
     test_module.py .F
@@ -78,8 +78,8 @@ of the failing function and hide the other one::
     
     test_module.py:9: AssertionError
     ----------------------------- Captured stdout ------------------------------
-    setting up <function test_func2 at 0x101353a28>
-    ==================== 1 failed, 1 passed in 0.02 seconds ====================
+    setting up <function test_func2 at 0x1013230c8>
+    ==================== 1 failed, 1 passed in 0.03 seconds ====================
 
 Accessing captured output from a test function
 ---------------------------------------------------

doc/contents.txt

@@ -1,10 +1,10 @@
 
 .. _toc:
 
-Full pytest documenation
-========================
+Full pytest documentation
+===========================
 
-`Download latest version as PDF <http://media.readthedocs.org/pdf/pytest/latest/pytest.pdf>`_
+`Download latest version as PDF <pytest.pdf>`_
 
 .. `Download latest version as EPUB <http://media.readthedocs.org/epub/pytest/latest/pytest.epub>`_
 

doc/customize.txt

@@ -64,13 +64,13 @@ Builtin configuration file options
 
 .. confval:: minversion
 
-   specifies a minimal pytest version required for running tests.
+   Specifies a minimal pytest version required for running tests.
 
         minversion = 2.1  # will fail if we run with pytest-2.0
 
 .. confval:: addopts
 
-   add the specified ``OPTS`` to the set of command line arguments as if they
+   Add the specified ``OPTS`` to the set of command line arguments as if they
    had been specified by the user. Example: if you have this ini file content::
 
        [pytest]
@@ -94,7 +94,7 @@ Builtin configuration file options
         [seq]   matches any character in seq
         [!seq]  matches any char not in seq
 
-   Default patterns are ``.* _* CVS {args}``. Setting a ``norecurse``
+   Default patterns are ``.* _* CVS {args}``. Setting a ``norecursedir``
    replaces the default.  Here is an example of how to avoid
    certain directories::
 
@@ -121,4 +121,3 @@ Builtin configuration file options
    and methods are considered as test modules.
 
    See :ref:`change naming conventions` for examples.
-

doc/doctest.txt

@@ -44,9 +44,10 @@ then you can just invoke ``py.test`` without command line options::
 
     $ py.test
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 1 items
     
     mymodule.py .
     
-    ========================= 1 passed in 0.05 seconds =========================
+    ========================= 1 passed in 0.51 seconds =========================
+    [?1034h

doc/example/index.txt

@@ -9,7 +9,7 @@ need more examples or have questions. Also take a look at the :ref:`comprehensiv
 
 .. note::
 
-   see :doc:`../getting-started` for basic introductionary examples
+   see :doc:`../getting-started` for basic introductory examples
 
 .. toctree::
    :maxdepth: 2

doc/example/markers.txt

@@ -6,7 +6,7 @@ Working with custom markers
 
 Here are some example using the :ref:`mark` mechanism.
 
-marking test functions and selecting them for a run
+Marking test functions and selecting them for a run
 ----------------------------------------------------
 
 You can "mark" a test function with custom metadata like this::
@@ -26,7 +26,7 @@ You can then restrict a test run to only run tests marked with ``webtest``::
 
     $ py.test -v -m webtest
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0 -- /Users/hpk/venv/1/bin/python
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2 -- /Users/hpk/venv/0/bin/python
     collecting ... collected 2 items
     
     test_server.py:3: test_send_http PASSED
@@ -38,13 +38,13 @@ Or the inverse, running all tests except the webtest ones::
     
     $ py.test -v -m "not webtest"
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0 -- /Users/hpk/venv/1/bin/python
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2 -- /Users/hpk/venv/0/bin/python
     collecting ... collected 2 items
     
     test_server.py:6: test_something_quick PASSED
     
     ================= 1 tests deselected by "-m 'not webtest'" =================
-    ================== 1 passed, 1 deselected in 0.01 seconds ==================
+    ================== 1 passed, 1 deselected in 0.02 seconds ==================
 
 Registering markers
 -------------------------------------
@@ -57,8 +57,8 @@ Registering markers for your test suite is simple::
 
     # content of pytest.ini
     [pytest]
-    markers = 
-        webtest: mark a test as a webtest. 
+    markers =
+        webtest: mark a test as a webtest.
 
 You can ask which markers exist for your test suite - the list includes our just defined ``webtest`` markers::
 
@@ -76,7 +76,7 @@ You can ask which markers exist for your test suite - the list includes our just
     @pytest.mark.trylast: mark a hook implementation function such that the plugin machinery will try to call it last/as late as possible.
     
 
-For an example on how to add and work with markers from a plugin, see 
+For an example on how to add and work with markers from a plugin, see
 :ref:`adding a custom marker from a plugin`.
 
 .. note::
@@ -96,8 +96,8 @@ For an example on how to add and work with markers from a plugin, see
 Marking whole classes or modules
 ----------------------------------------------------
 
-If you are programming with Python2.6 you may use ``pytest.mark`` decorators
-with classes to apply markers to all of its test methods::
+If you are programming with Python 2.6 or later you may use ``pytest.mark``
+decorators with classes to apply markers to all of its test methods::
 
     # content of test_mark_classlevel.py
     import pytest
@@ -111,7 +111,7 @@ with classes to apply markers to all of its test methods::
 This is equivalent to directly applying the decorator to the
 two test functions.
 
-To remain backward-compatible with Python2.4 you can also set a
+To remain backward-compatible with Python 2.4 you can also set a
 ``pytestmark`` attribute on a TestClass like this::
 
     import pytest
@@ -134,14 +134,16 @@ You can also set a module level marker::
 in which case it will be applied to all functions and
 methods defined in the module.
 
+
 Using ``-k TEXT`` to select tests
 ----------------------------------------------------
 
-You can use the ``-k`` command line option to only run tests with names that match the given argument::
+You can use the ``-k`` command line option to only run tests with names matching
+the given argument::
 
     $ py.test -k send_http  # running with the above defined examples
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 4 items
     
     test_server.py .
@@ -153,7 +155,7 @@ And you can also run all tests except the ones that match the keyword::
 
     $ py.test -k-send_http
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 4 items
     
     test_mark_classlevel.py ..
@@ -166,19 +168,21 @@ Or to only select the class::
 
     $ py.test -kTestClass
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 4 items
     
     test_mark_classlevel.py ..
     
     =================== 2 tests deselected by '-kTestClass' ====================
-    ================== 2 passed, 2 deselected in 0.02 seconds ==================
+    ================== 2 passed, 2 deselected in 0.03 seconds ==================
 
 .. _`adding a custom marker from a plugin`:
 
-custom marker and command line option to control test runs
+Custom marker and command line option to control test runs
 ----------------------------------------------------------
 
+.. regendoc:wipe
+
 Plugins can provide custom markers and implement specific behaviour
 based on it. This is a self-contained example which adds a command
 line option and a parametrized test function marker to run tests
@@ -193,7 +197,7 @@ specifies via named environments::
 
     def pytest_configure(config):
         # register an additional marker
-        config.addinivalue_line("markers", 
+        config.addinivalue_line("markers",
             "env(name): mark test to run only on named environment")
 
     def pytest_runtest_setup(item):
@@ -219,33 +223,27 @@ the test needs::
 
     $ py.test -E stage2
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
-    collecting ... collected 5 items
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
+    collecting ... collected 1 items
     
-    test_mark_classlevel.py ..
-    test_server.py ..
     test_someenv.py s
     
-    =================== 4 passed, 1 skipped in 0.04 seconds ====================
+    ======================== 1 skipped in 0.02 seconds =========================
   
 and here is one that specifies exactly the environment needed::
 
     $ py.test -E stage1
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
-    collecting ... collected 5 items
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
+    collecting ... collected 1 items
     
-    test_mark_classlevel.py ..
-    test_server.py ..
     test_someenv.py .
     
-    ========================= 5 passed in 0.04 seconds =========================
+    ========================= 1 passed in 0.02 seconds =========================
 
 The ``--markers`` option always gives you a list of available markers::
 
     $ py.test --markers
-    @pytest.mark.webtest: mark a test as a webtest.
-    
     @pytest.mark.env(name): mark test to run only on named environment
     
     @pytest.mark.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. 
@@ -257,4 +255,43 @@ The ``--markers`` option always gives you a list of available markers::
     @pytest.mark.tryfirst: mark a hook implementation function such that the plugin machinery will try to call it first/as early as possible.
     
     @pytest.mark.trylast: mark a hook implementation function such that the plugin machinery will try to call it last/as late as possible.
+
     
+Reading markers which were set from multiple places
+----------------------------------------------------
+
+.. versionadded: 2.2.2
+
+If you are heavily using markers in your test suite you may encounter the case where a marker is applied several times to a test function.  From plugin
+code you can read over all such settings.  Example::
+
+    # content of test_mark_three_times.py
+    import pytest
+    pytestmark = pytest.mark.glob("module", x=1)
+
+    @pytest.mark.glob("class", x=2)
+    class TestClass:
+        @pytest.mark.glob("function", x=3)
+        def test_something(self):
+            pass
+
+Here we have the marker "glob" applied three times to the same
+test function.  From a conftest file we can read it like this::
+
+    # content of conftest.py
+
+    def pytest_runtest_setup(item):
+        g = getattr(item.obj, 'glob', None)
+        if g is not None:
+            for info in g:
+                print ("glob args=%s kwargs=%s" %(info.args, info.kwargs))
+
+Let's run this without capturing output and see what we get::
+
+    $ py.test -q -s 
+    collecting ... collected 2 items
+    ..
+    2 passed in 0.02 seconds
+    glob args=('function',) kwargs={'x': 3}
+    glob args=('class',) kwargs={'x': 2}
+    glob args=('module',) kwargs={'x': 1}

doc/example/mysetup.txt

@@ -38,7 +38,7 @@ method in a :ref:`local plugin <localplugin>` ::
         def myapp(self):
             return MyApp()
 
-To run the example we stub out a a simple ``MyApp`` application object::
+To run the example we stub out a simple ``MyApp`` application object::
 
     # content of myapp.py
     class MyApp:
@@ -49,7 +49,7 @@ You can now run the test::
 
     $ py.test test_sample.py
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 1 items
     
     test_sample.py F
@@ -57,7 +57,7 @@ You can now run the test::
     ================================= FAILURES =================================
     _______________________________ test_answer ________________________________
     
-    mysetup = <conftest.MySetup instance at 0x1012b2bd8>
+    mysetup = <conftest.MySetup instance at 0x101322fc8>
     
         def test_answer(mysetup):
             app = mysetup.myapp()
@@ -66,7 +66,7 @@ You can now run the test::
     E       assert 54 == 42
     
     test_sample.py:4: AssertionError
-    ========================= 1 failed in 0.02 seconds =========================
+    ========================= 1 failed in 0.72 seconds =========================
 
 This means that our ``mysetup`` object was successfully instantiated
 and ``mysetup.app()`` returned an initialized ``MyApp`` instance.
@@ -122,12 +122,12 @@ Running it yields::
 
     $ py.test test_ssh.py -rs
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 1 items
     
     test_ssh.py s
     ========================= short test summary info ==========================
-    SKIP [1] /Users/hpk/tmp/doc-exec-625/conftest.py:22: specify ssh host with --ssh
+    SKIP [1] /Users/hpk/tmp/doc-exec-153/conftest.py:22: specify ssh host with --ssh
     
     ======================== 1 skipped in 0.02 seconds =========================
 

doc/example/nonpython.txt

@@ -27,7 +27,7 @@ now execute the test specification::
 
     nonpython $ py.test test_simple.yml
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 2 items
     
     test_simple.yml .F
@@ -37,7 +37,7 @@ now execute the test specification::
     usecase execution failed
        spec failed: 'some': 'other'
        no further details known at this point.
-    ==================== 1 failed, 1 passed in 0.10 seconds ====================
+    ==================== 1 failed, 1 passed in 0.48 seconds ====================
 
 You get one dot for the passing ``sub1: sub1`` check and one failure.
 Obviously in the above ``conftest.py`` you'll want to implement a more
@@ -51,12 +51,12 @@ your own domain specific testing language this way.
     representation string of your choice.  It
     will be reported as a (red) string.
 
-``reportinfo()`` is used for representing the test location and is also consulted for
-reporting in ``verbose`` mode::
+``reportinfo()`` is used for representing the test location and is also
+consulted when reporting in ``verbose`` mode::
 
     nonpython $ py.test -v
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0 -- /Users/hpk/venv/1/bin/python
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2 -- /Users/hpk/venv/0/bin/python
     collecting ... collected 2 items
     
     test_simple.yml:1: usecase: ok PASSED
@@ -67,17 +67,17 @@ reporting in ``verbose`` mode::
     usecase execution failed
        spec failed: 'some': 'other'
        no further details known at this point.
-    ==================== 1 failed, 1 passed in 0.09 seconds ====================
+    ==================== 1 failed, 1 passed in 0.10 seconds ====================
 
 While developing your custom test collection and execution it's also
 interesting to just look at the collection tree::
 
     nonpython $ py.test --collectonly
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 2 items
     <YamlFile 'test_simple.yml'>
       <YamlItem 'ok'>
       <YamlItem 'hello'>
     
-    =============================  in 0.08 seconds =============================
+    =============================  in 0.18 seconds =============================

doc/example/parametrize.txt

@@ -12,12 +12,12 @@ the builtin mechanisms.
 
 .. _parametrizemark:
 
-simple "decorator" parametrization of a test function
+Simple "decorator" parametrization of a test function
 ----------------------------------------------------------------------------
 
 .. versionadded:: 2.2
 
-The builtin ``pytest.mark.parametrize`` decorator directly enables 
+The builtin ``pytest.mark.parametrize`` decorator directly enables
 parametrization of arguments for a test function.  Here is an example
 of a test function that wants to compare that processing some input
 results in expected output::
@@ -32,7 +32,7 @@ results in expected output::
     def test_eval(input, expected):
         assert eval(input) == expected
 
-we parametrize two arguments of the test function so that the test 
+we parametrize two arguments of the test function so that the test
 function is called three times.  Let's run it::
 
     $ py.test -q 
@@ -96,7 +96,7 @@ This means that we only run 2 tests if we do not pass ``--all``::
     $ py.test -q test_compute.py
     collecting ... collected 2 items
     ..
-    2 passed in 0.02 seconds
+    2 passed in 0.03 seconds
 
 We run only two computations, so we see two dots.
 let's run the full monty::
@@ -114,17 +114,17 @@ let's run the full monty::
     E       assert 4 < 4
     
     test_compute.py:3: AssertionError
-    1 failed, 4 passed in 0.03 seconds
+    1 failed, 4 passed in 0.05 seconds
 
 As expected when running the full range of ``param1`` values
 we'll get an error on the last one.
 
-a quick port of "testscenarios"
+A quick port of "testscenarios"
 ------------------------------------
 
 .. _`test scenarios`: http://bazaar.launchpad.net/~lifeless/testscenarios/trunk/annotate/head%3A/doc/example.py
 
-Here is a quick port of to run tests configured with `test scenarios`_,
+Here is a quick port to run tests configured with `test scenarios`_,
 an add-on from Robert Collins for the standard unittest framework. We
 only have to work a bit to construct the correct arguments for pytest's
 :py:func:`Metafunc.parametrize`::
@@ -154,7 +154,7 @@ this is a fully self-contained example which you can run with::
 
     $ py.test test_scenarios.py
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 2 items
     
     test_scenarios.py ..
@@ -166,7 +166,7 @@ If you just collect tests you'll also nicely see 'advanced' and 'basic' as varia
 
     $ py.test --collectonly test_scenarios.py
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 2 items
     <Module 'test_scenarios.py'>
       <Class 'TestSampleWithScenarios'>
@@ -174,7 +174,7 @@ If you just collect tests you'll also nicely see 'advanced' and 'basic' as varia
           <Function 'test_demo[basic]'>
           <Function 'test_demo[advanced]'>
     
-    =============================  in 0.01 seconds =============================
+    =============================  in 0.05 seconds =============================
 
 Deferring the setup of parametrized resources
 ---------------------------------------------------
@@ -183,12 +183,12 @@ Deferring the setup of parametrized resources
 
 The parametrization of test functions happens at collection
 time.  It is a good idea to setup expensive resources like DB
-connections or subprocess only when the actual test is run.  
-Here is a simple example how you can achieve that, first 
+connections or subprocess only when the actual test is run.
+Here is a simple example how you can achieve that, first
 the actual test requiring a ``db`` object::
 
     # content of test_backends.py
-    
+
     import pytest
     def test_db_initialized(db):
         # a dummy test
@@ -209,7 +209,7 @@ creates a database object for the actual test invocations::
         "one database object"
     class DB2:
         "alternative database object"
-    
+
     def pytest_funcarg__db(request):
         if request.param == "d1":
             return DB1()
@@ -222,7 +222,7 @@ Let's first see how it looks like at collection time::
 
     $ py.test test_backends.py --collectonly
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 2 items
     <Module 'test_backends.py'>
       <Function 'test_db_initialized[d1]'>
@@ -238,7 +238,7 @@ And then when we run the test::
     ================================= FAILURES =================================
     _________________________ test_db_initialized[d2] __________________________
     
-    db = <conftest.DB2 instance at 0x10150ab90>
+    db = <conftest.DB2 instance at 0x101323710>
     
         def test_db_initialized(db):
             # a dummy test
@@ -247,7 +247,7 @@ And then when we run the test::
     E           Failed: deliberately failing for demo purposes
     
     test_backends.py:6: Failed
-    1 failed, 1 passed in 0.02 seconds
+    1 failed, 1 passed in 0.03 seconds
 
 The first invocation with ``db == "DB1"`` passed while the second with ``db == "DB2"`` failed.  Our ``pytest_funcarg__db`` factory has instantiated each of the DB values during the setup phase while the ``pytest_generate_tests`` generated two according calls to the ``test_db_initialized`` during the collection phase.
 
@@ -260,7 +260,7 @@ Parametrizing test methods through per-class configuration
 
 
 Here is an example ``pytest_generate_function`` function implementing a
-parametrization scheme similar to Michael Foords `unittest
+parametrization scheme similar to Michael Foord's `unittest
 parameterizer`_ but in a lot less code::
 
     # content of ./test_parametrize.py
@@ -270,7 +270,7 @@ parameterizer`_ but in a lot less code::
         # called once per each test function
         funcarglist = metafunc.cls.params[metafunc.function.__name__]
         argnames = list(funcarglist[0])
-        metafunc.parametrize(argnames, [[funcargs[name] for name in argnames] 
+        metafunc.parametrize(argnames, [[funcargs[name] for name in argnames]
                 for funcargs in funcarglist])
 
     class TestClass:
@@ -295,7 +295,7 @@ argument sets to use for each test function.  Let's run it::
     ================================= FAILURES =================================
     ________________________ TestClass.test_equals[1-2] ________________________
     
-    self = <test_parametrize.TestClass instance at 0x101509638>, a = 1, b = 2
+    self = <test_parametrize.TestClass instance at 0x101326368>, a = 1, b = 2
     
         def test_equals(self, a, b):
     >       assert a == b
@@ -313,7 +313,7 @@ We define a ``test_basic_objects`` function which is to be run
 with different sets of arguments for its three arguments:
 
 * ``python1``: first python interpreter, run to pickle-dump an object to a file
-* ``python2``: second interpreter, run to pickle-load an object from a file 
+* ``python2``: second interpreter, run to pickle-load an object from a file
 * ``obj``: object to be dumped/loaded
 
 .. literalinclude:: multipython.py
@@ -326,4 +326,4 @@ Running it results in some skips if we don't have all the python interpreters in
    ========================= short test summary info ==========================
    SKIP [24] /Users/hpk/p/pytest/doc/example/multipython.py:36: 'python2.8' not found
    SKIP [24] /Users/hpk/p/pytest/doc/example/multipython.py:36: 'python2.4' not found
-   27 passed, 48 skipped in 3.03 seconds
+   27 passed, 48 skipped in 7.76 seconds

doc/example/pythoncollection.txt

@@ -43,7 +43,7 @@ then the test collection looks like this::
 
     $ py.test --collectonly
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 2 items
     <Module 'check_myapp.py'>
       <Class 'CheckMyApp'>
@@ -51,7 +51,7 @@ then the test collection looks like this::
           <Function 'check_simple'>
           <Function 'check_complex'>
     
-    =============================  in 0.02 seconds =============================
+    =============================  in 0.01 seconds =============================
 
 Interpreting cmdline arguments as Python packages
 -----------------------------------------------------
@@ -82,7 +82,7 @@ You can always peek at the collection tree without running tests like this::
 
     . $ py.test --collectonly pythoncollection.py
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 3 items
     <Module 'pythoncollection.py'>
       <Function 'test_function'>

doc/example/reportingdemo.txt

@@ -13,7 +13,7 @@ get on the terminal - we are working on that):
 
     assertion $ py.test failure_demo.py
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 39 items
     
     failure_demo.py FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
@@ -30,7 +30,7 @@ get on the terminal - we are working on that):
     failure_demo.py:15: AssertionError
     _________________________ TestFailing.test_simple __________________________
     
-    self = <failure_demo.TestFailing object at 0x1013552d0>
+    self = <failure_demo.TestFailing object at 0x101490690>
     
         def test_simple(self):
             def f():
@@ -40,13 +40,13 @@ get on the terminal - we are working on that):
         
     >       assert f() == g()
     E       assert 42 == 43
-    E        +  where 42 = <function f at 0x101514f50>()
-    E        +  and   43 = <function g at 0x101516050>()
+    E        +  where 42 = <function f at 0x101462b90>()
+    E        +  and   43 = <function g at 0x101462c08>()
     
     failure_demo.py:28: AssertionError
     ____________________ TestFailing.test_simple_multiline _____________________
     
-    self = <failure_demo.TestFailing object at 0x101355950>
+    self = <failure_demo.TestFailing object at 0x101490b10>
     
         def test_simple_multiline(self):
             otherfunc_multi(
@@ -66,19 +66,19 @@ get on the terminal - we are working on that):
     failure_demo.py:11: AssertionError
     ___________________________ TestFailing.test_not ___________________________
     
-    self = <failure_demo.TestFailing object at 0x101355ad0>
+    self = <failure_demo.TestFailing object at 0x101490210>
     
         def test_not(self):
             def f():
                 return 42
     >       assert not f()
     E       assert not 42
-    E        +  where 42 = <function f at 0x101514f50>()
+    E        +  where 42 = <function f at 0x101462aa0>()
     
     failure_demo.py:38: AssertionError
     _________________ TestSpecialisedExplanations.test_eq_text _________________
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x1013559d0>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x101490a10>
     
         def test_eq_text(self):
     >       assert 'spam' == 'eggs'
@@ -89,7 +89,7 @@ get on the terminal - we are working on that):
     failure_demo.py:42: AssertionError
     _____________ TestSpecialisedExplanations.test_eq_similar_text _____________
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x101350dd0>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x10148d9d0>
     
         def test_eq_similar_text(self):
     >       assert 'foo 1 bar' == 'foo 2 bar'
@@ -102,7 +102,7 @@ get on the terminal - we are working on that):
     failure_demo.py:45: AssertionError
     ____________ TestSpecialisedExplanations.test_eq_multiline_text ____________
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x101350d10>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x10148d590>
     
         def test_eq_multiline_text(self):
     >       assert 'foo\nspam\nbar' == 'foo\neggs\nbar'
@@ -115,7 +115,7 @@ get on the terminal - we are working on that):
     failure_demo.py:48: AssertionError
     ______________ TestSpecialisedExplanations.test_eq_long_text _______________
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x101350cd0>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x10148dc90>
     
         def test_eq_long_text(self):
             a = '1'*100 + 'a' + '2'*100
@@ -132,7 +132,7 @@ get on the terminal - we are working on that):
     failure_demo.py:53: AssertionError
     _________ TestSpecialisedExplanations.test_eq_long_text_multiline __________
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x101350f50>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x10148d910>
     
         def test_eq_long_text_multiline(self):
             a = '1\n'*100 + 'a' + '2\n'*100
@@ -156,7 +156,7 @@ get on the terminal - we are working on that):
     failure_demo.py:58: AssertionError
     _________________ TestSpecialisedExplanations.test_eq_list _________________
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x10134f350>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x10148b9d0>
     
         def test_eq_list(self):
     >       assert [0, 1, 2] == [0, 1, 3]
@@ -166,7 +166,7 @@ get on the terminal - we are working on that):
     failure_demo.py:61: AssertionError
     ______________ TestSpecialisedExplanations.test_eq_list_long _______________
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x10134fc10>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x10148b750>
     
         def test_eq_list_long(self):
             a = [0]*100 + [1] + [3]*100
@@ -178,7 +178,7 @@ get on the terminal - we are working on that):
     failure_demo.py:66: AssertionError
     _________________ TestSpecialisedExplanations.test_eq_dict _________________
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x10134f2d0>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x10148bdd0>
     
         def test_eq_dict(self):
     >       assert {'a': 0, 'b': 1} == {'a': 0, 'b': 2}
@@ -191,7 +191,7 @@ get on the terminal - we are working on that):
     failure_demo.py:69: AssertionError
     _________________ TestSpecialisedExplanations.test_eq_set __________________
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x10134f110>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x10148b1d0>
     
         def test_eq_set(self):
     >       assert set([0, 10, 11, 12]) == set([0, 20, 21])
@@ -207,7 +207,7 @@ get on the terminal - we are working on that):
     failure_demo.py:72: AssertionError
     _____________ TestSpecialisedExplanations.test_eq_longer_list ______________
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x10134f510>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x10148bf10>
     
         def test_eq_longer_list(self):
     >       assert [1,2] == [1,2,3]
@@ -217,7 +217,7 @@ get on the terminal - we are working on that):
     failure_demo.py:75: AssertionError
     _________________ TestSpecialisedExplanations.test_in_list _________________
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x10134f6d0>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x10148b390>
     
         def test_in_list(self):
     >       assert 1 in [0, 2, 3, 4, 5]
@@ -226,7 +226,7 @@ get on the terminal - we are working on that):
     failure_demo.py:78: AssertionError
     __________ TestSpecialisedExplanations.test_not_in_text_multiline __________
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x10152c490>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x101483e50>
     
         def test_not_in_text_multiline(self):
             text = 'some multiline\ntext\nwhich\nincludes foo\nand a\ntail'
@@ -244,7 +244,7 @@ get on the terminal - we are working on that):
     failure_demo.py:82: AssertionError
     ___________ TestSpecialisedExplanations.test_not_in_text_single ____________
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x10152cfd0>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x101483c10>
     
         def test_not_in_text_single(self):
             text = 'single foo line'
@@ -257,7 +257,7 @@ get on the terminal - we are working on that):
     failure_demo.py:86: AssertionError
     _________ TestSpecialisedExplanations.test_not_in_text_single_long _________
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x10152c090>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x101483ed0>
     
         def test_not_in_text_single_long(self):
             text = 'head ' * 50 + 'foo ' + 'tail ' * 20
@@ -270,7 +270,7 @@ get on the terminal - we are working on that):
     failure_demo.py:90: AssertionError
     ______ TestSpecialisedExplanations.test_not_in_text_single_long_term _______
     
-    self = <failure_demo.TestSpecialisedExplanations object at 0x10152cb90>
+    self = <failure_demo.TestSpecialisedExplanations object at 0x101483310>
     
         def test_not_in_text_single_long_term(self):
             text = 'head ' * 50 + 'f'*70 + 'tail ' * 20
@@ -289,7 +289,7 @@ get on the terminal - we are working on that):
             i = Foo()
     >       assert i.b == 2
     E       assert 1 == 2
-    E        +  where 1 = <failure_demo.Foo object at 0x10152c350>.b
+    E        +  where 1 = <failure_demo.Foo object at 0x101483f50>.b
     
     failure_demo.py:101: AssertionError
     _________________________ test_attribute_instance __________________________
@@ -299,8 +299,8 @@ get on the terminal - we are working on that):
                 b = 1
     >       assert Foo().b == 2
     E       assert 1 == 2
-    E        +  where 1 = <failure_demo.Foo object at 0x10134fe90>.b
-    E        +    where <failure_demo.Foo object at 0x10134fe90> = <class 'failure_demo.Foo'>()
+    E        +  where 1 = <failure_demo.Foo object at 0x101483210>.b
+    E        +    where <failure_demo.Foo object at 0x101483210> = <class 'failure_demo.Foo'>()
     
     failure_demo.py:107: AssertionError
     __________________________ test_attribute_failure __________________________
@@ -316,7 +316,7 @@ get on the terminal - we are working on that):
     failure_demo.py:116: 
     _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
     
-    self = <failure_demo.Foo object at 0x10152c610>
+    self = <failure_demo.Foo object at 0x101483450>
     
         def _get_b(self):
     >       raise Exception('Failed to get attrib')
@@ -332,15 +332,15 @@ get on the terminal - we are working on that):
                 b = 2
     >       assert Foo().b == Bar().b
     E       assert 1 == 2
-    E        +  where 1 = <failure_demo.Foo object at 0x10152c950>.b
-    E        +    where <failure_demo.Foo object at 0x10152c950> = <class 'failure_demo.Foo'>()
-    E        +  and   2 = <failure_demo.Bar object at 0x10152c250>.b
-    E        +    where <failure_demo.Bar object at 0x10152c250> = <class 'failure_demo.Bar'>()
+    E        +  where 1 = <failure_demo.Foo object at 0x101483150>.b
+    E        +    where <failure_demo.Foo object at 0x101483150> = <class 'failure_demo.Foo'>()
+    E        +  and   2 = <failure_demo.Bar object at 0x101483350>.b
+    E        +    where <failure_demo.Bar object at 0x101483350> = <class 'failure_demo.Bar'>()
     
     failure_demo.py:124: AssertionError
     __________________________ TestRaises.test_raises __________________________
     
-    self = <failure_demo.TestRaises instance at 0x1015219e0>
+    self = <failure_demo.TestRaises instance at 0x1014a6758>
     
         def test_raises(self):
             s = 'qwe'
@@ -352,10 +352,10 @@ get on the terminal - we are working on that):
     >   int(s)
     E   ValueError: invalid literal for int() with base 10: 'qwe'
     
-    <0-codegen /Users/hpk/p/pytest/_pytest/python.py:957>:1: ValueError
+    <0-codegen /Users/hpk/p/pytest/_pytest/python.py:976>:1: ValueError
     ______________________ TestRaises.test_raises_doesnt _______________________
     
-    self = <failure_demo.TestRaises instance at 0x1013794d0>
+    self = <failure_demo.TestRaises instance at 0x1014b03f8>
     
         def test_raises_doesnt(self):
     >       raises(IOError, "int('3')")
@@ -364,7 +364,7 @@ get on the terminal - we are working on that):
     failure_demo.py:136: Failed
     __________________________ TestRaises.test_raise ___________________________
     
-    self = <failure_demo.TestRaises instance at 0x10151f6c8>
+    self = <failure_demo.TestRaises instance at 0x1014a8998>
     
         def test_raise(self):
     >       raise ValueError("demo error")
@@ -373,7 +373,7 @@ get on the terminal - we are working on that):
     failure_demo.py:139: ValueError
     ________________________ TestRaises.test_tupleerror ________________________
     
-    self = <failure_demo.TestRaises instance at 0x1013733f8>
+    self = <failure_demo.TestRaises instance at 0x1014a27a0>
     
         def test_tupleerror(self):
     >       a,b = [1]
@@ -382,7 +382,7 @@ get on the terminal - we are working on that):
     failure_demo.py:142: ValueError
     ______ TestRaises.test_reinterpret_fails_with_print_for_the_fun_of_it ______
     
-    self = <failure_demo.TestRaises instance at 0x10136e170>
+    self = <failure_demo.TestRaises instance at 0x1014a5518>
     
         def test_reinterpret_fails_with_print_for_the_fun_of_it(self):
             l = [1,2,3]
@@ -395,7 +395,7 @@ get on the terminal - we are working on that):
     l is [1, 2, 3]
     ________________________ TestRaises.test_some_error ________________________
     
-    self = <failure_demo.TestRaises instance at 0x10136ef38>
+    self = <failure_demo.TestRaises instance at 0x1014a1320>
     
         def test_some_error(self):
     >       if namenotexi:
@@ -423,7 +423,7 @@ get on the terminal - we are working on that):
     <2-codegen 'abc-123' /Users/hpk/p/pytest/doc/example/assertion/failure_demo.py:162>:2: AssertionError
     ____________________ TestMoreErrors.test_complex_error _____________________
     
-    self = <failure_demo.TestMoreErrors instance at 0x101520638>
+    self = <failure_demo.TestMoreErrors instance at 0x1014a6638>
     
         def test_complex_error(self):
             def f():
@@ -452,7 +452,7 @@ get on the terminal - we are working on that):
     failure_demo.py:5: AssertionError
     ___________________ TestMoreErrors.test_z1_unpack_error ____________________
     
-    self = <failure_demo.TestMoreErrors instance at 0x10136bcb0>
+    self = <failure_demo.TestMoreErrors instance at 0x1014a42d8>
     
         def test_z1_unpack_error(self):
             l = []
@@ -462,7 +462,7 @@ get on the terminal - we are working on that):
     failure_demo.py:179: ValueError
     ____________________ TestMoreErrors.test_z2_type_error _____________________
     
-    self = <failure_demo.TestMoreErrors instance at 0x10136a440>
+    self = <failure_demo.TestMoreErrors instance at 0x1014a0128>
     
         def test_z2_type_error(self):
             l = 3
@@ -472,19 +472,19 @@ get on the terminal - we are working on that):
     failure_demo.py:183: TypeError
     ______________________ TestMoreErrors.test_startswith ______________________
     
-    self = <failure_demo.TestMoreErrors instance at 0x101368290>
+    self = <failure_demo.TestMoreErrors instance at 0x1014a0ef0>
     
         def test_startswith(self):
             s = "123"
             g = "456"
     >       assert s.startswith(g)
-    E       assert <built-in method startswith of str object at 0x101354030>('456')
-    E        +  where <built-in method startswith of str object at 0x101354030> = '123'.startswith
+    E       assert <built-in method startswith of str object at 0x1014951c0>('456')
+    E        +  where <built-in method startswith of str object at 0x1014951c0> = '123'.startswith
     
     failure_demo.py:188: AssertionError
     __________________ TestMoreErrors.test_startswith_nested ___________________
     
-    self = <failure_demo.TestMoreErrors instance at 0x101368f38>
+    self = <failure_demo.TestMoreErrors instance at 0x1014a4170>
     
         def test_startswith_nested(self):
             def f():
@@ -492,15 +492,15 @@ get on the terminal - we are working on that):
             def g():
                 return "456"
     >       assert f().startswith(g())
-    E       assert <built-in method startswith of str object at 0x101354030>('456')
-    E        +  where <built-in method startswith of str object at 0x101354030> = '123'.startswith
-    E        +    where '123' = <function f at 0x10136c578>()
-    E        +  and   '456' = <function g at 0x10136c5f0>()
+    E       assert <built-in method startswith of str object at 0x1014951c0>('456')
+    E        +  where <built-in method startswith of str object at 0x1014951c0> = '123'.startswith
+    E        +    where '123' = <function f at 0x1014aea28>()
+    E        +  and   '456' = <function g at 0x101477c80>()
     
     failure_demo.py:195: AssertionError
     _____________________ TestMoreErrors.test_global_func ______________________
     
-    self = <failure_demo.TestMoreErrors instance at 0x10136aef0>
+    self = <failure_demo.TestMoreErrors instance at 0x1014b3ab8>
     
         def test_global_func(self):
     >       assert isinstance(globf(42), float)
@@ -510,18 +510,18 @@ get on the terminal - we are working on that):
     failure_demo.py:198: AssertionError
     _______________________ TestMoreErrors.test_instance _______________________
     
-    self = <failure_demo.TestMoreErrors instance at 0x10151c440>
+    self = <failure_demo.TestMoreErrors instance at 0x1014a2878>
     
         def test_instance(self):
             self.x = 6*7
     >       assert self.x != 42
     E       assert 42 != 42
-    E        +  where 42 = <failure_demo.TestMoreErrors instance at 0x10151c440>.x
+    E        +  where 42 = <failure_demo.TestMoreErrors instance at 0x1014a2878>.x
     
     failure_demo.py:202: AssertionError
     _______________________ TestMoreErrors.test_compare ________________________
     
-    self = <failure_demo.TestMoreErrors instance at 0x101373a70>
+    self = <failure_demo.TestMoreErrors instance at 0x10149da70>
     
         def test_compare(self):
     >       assert globf(10) < 5
@@ -531,7 +531,7 @@ get on the terminal - we are working on that):
     failure_demo.py:205: AssertionError
     _____________________ TestMoreErrors.test_try_finally ______________________
     
-    self = <failure_demo.TestMoreErrors instance at 0x101363c68>
+    self = <failure_demo.TestMoreErrors instance at 0x101493908>
     
         def test_try_finally(self):
             x = 1
@@ -540,4 +540,4 @@ get on the terminal - we are working on that):
     E           assert 1 == 0
     
     failure_demo.py:210: AssertionError
-    ======================== 39 failed in 0.41 seconds =========================
+    ======================== 39 failed in 1.05 seconds =========================

doc/example/simple.txt

@@ -53,7 +53,7 @@ Let's run this without supplying our new command line option::
     test_sample.py:6: AssertionError
     ----------------------------- Captured stdout ------------------------------
     first
-    1 failed in 0.02 seconds
+    1 failed in 0.50 seconds
 
 And now with supplying a command line option::
 
@@ -109,13 +109,13 @@ directory with the above conftest.py::
 
     $ py.test
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     gw0 I
     gw0 [0]
     
     scheduling tests via LoadScheduling
     
-    =============================  in 0.71 seconds =============================
+    =============================  in 5.12 seconds =============================
 
 .. _`excontrolskip`:
 
@@ -156,25 +156,25 @@ and when running it will see a skipped "slow" test::
 
     $ py.test -rs    # "-rs" means report details on the little 's'
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 2 items
     
     test_module.py .s
     ========================= short test summary info ==========================
-    SKIP [1] /Users/hpk/tmp/doc-exec-630/conftest.py:9: need --runslow option to run
+    SKIP [1] /Users/hpk/tmp/doc-exec-158/conftest.py:9: need --runslow option to run
     
-    =================== 1 passed, 1 skipped in 0.02 seconds ====================
+    =================== 1 passed, 1 skipped in 0.09 seconds ====================
 
 Or run it including the ``slow`` marked test::
 
     $ py.test --runslow
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 2 items
     
     test_module.py ..
     
-    ========================= 2 passed in 0.62 seconds =========================
+    ========================= 2 passed in 0.02 seconds =========================
 
 Writing well integrated assertion helpers
 --------------------------------------------------
@@ -213,7 +213,7 @@ Let's run our little function::
     E       Failed: not configured: 42
     
     test_checkconfig.py:8: Failed
-    1 failed in 0.02 seconds
+    1 failed in 0.07 seconds
 
 Detect if running from within a py.test run
 --------------------------------------------------------------
@@ -240,9 +240,9 @@ and then check for the ``sys._called_from_test`` flag::
         # called from within a test run
     else:
         # called "normally"
-    
+
 accordingly in your application.  It's also a good idea
-to rather use your own application module rather than ``sys``
+to use your own application module rather than ``sys``
 for handling flag.
 
 Adding info to test report header
@@ -261,11 +261,11 @@ which will add the string to the test header accordingly::
 
     $ py.test
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     project deps: mylib-1.1
     collecting ... collected 0 items
     
-    =============================  in 0.00 seconds =============================
+    =============================  in 0.01 seconds =============================
 
 .. regendoc:wipe
 
@@ -275,7 +275,7 @@ information on e.g. the value of ``config.option.verbose`` so that
 you present more information appropriately::
 
     # content of conftest.py
-    
+
     def pytest_report_header(config):
         if config.option.verbose > 0:
             return ["info1: did you know that ...", "did you?"]
@@ -284,21 +284,21 @@ which will add info only when run with "--v"::
 
     $ py.test -v
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0 -- /Users/hpk/venv/1/bin/python
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2 -- /Users/hpk/venv/0/bin/python
     info1: did you know that ...
     did you?
     collecting ... collected 0 items
     
-    =============================  in 0.00 seconds =============================
+    =============================  in 0.03 seconds =============================
 
 and nothing when run plainly::
 
     $ py.test
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 0 items
     
-    =============================  in 0.00 seconds =============================
+    =============================  in 0.01 seconds =============================
 
 profiling test duration
 --------------------------
@@ -308,26 +308,26 @@ profiling test duration
 .. versionadded: 2.2
 
 If you have a slow running large test suite you might want to find
-out which tests are slowest. Let's make an artifical test suite::
+out which tests are the slowest. Let's make an artifical test suite::
 
     # content of test_some_are_slow.py
-   
-    import time 
+
+    import time
 
     def test_funcfast():
         pass
-    
+
     def test_funcslow1():
         time.sleep(0.1)
-        
+
     def test_funcslow2():
         time.sleep(0.2)
-   
-Now we can profile which test functions execute slowest::
+
+Now we can profile which test functions execute the slowest::
 
     $ py.test --durations=3
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 3 items
     
     test_some_are_slow.py ...
@@ -335,5 +335,5 @@ Now we can profile which test functions execute slowest::
     ========================= slowest 3 test durations =========================
     0.20s call     test_some_are_slow.py::test_funcslow2
     0.10s call     test_some_are_slow.py::test_funcslow1
-    0.00s setup    test_some_are_slow.py::test_funcfast
-    ========================= 3 passed in 0.32 seconds =========================
+    0.00s call     test_some_are_slow.py::test_funcfast
+    ========================= 3 passed in 0.33 seconds =========================

doc/faq.txt

@@ -18,7 +18,7 @@ utilities, all starting with ``py.<TAB>``, thus providing nice
 TAB-completion. If
 you install ``pip install pycmd`` you get these tools from a separate
 package.  These days the command line tool could be called ``pytest``
-since many people have gotten used to the old name and there
+but since many people have gotten used to the old name and there
 is another tool named "pytest" we just decided to stick with
 ``py.test``.
 
@@ -47,14 +47,14 @@ customizable testing frameworks for Python.   However,
 ``py.test`` still uses many metaprogramming techniques and
 reading its source is thus likely not something for Python beginners.
 
-A second "magic" issue arguably the assert statement debugging feature. When
+A second "magic" issue is arguably the assert statement debugging feature. When
 loading test modules py.test rewrites the source code of assert statements. When
 a rewritten assert statement fails, its error message has more information than
 the original. py.test also has a second assert debugging technique. When an
 ``assert`` statement that was missed by the rewriter fails, py.test
 re-interprets the expression to show intermediate values if a test fails. This
-second technique suffers from caveat that the rewriting does not: If your
-expression has side effects (better to avoid them anyway!)  the intermediate
+second technique suffers from a caveat that the rewriting does not: If your
+expression has side effects (better to avoid them anyway!) the intermediate
 values may not be the same, confusing the reinterpreter and obfuscating the
 initial error (this is also explained at the command line if it happens).
 You can turn off all assertion debugging with ``py.test --assertmode=off``.
@@ -91,8 +91,8 @@ Why the ``pytest_funcarg__*`` name for funcarg factories?
 
 We like `Convention over Configuration`_ and didn't see much point
 in allowing a more flexible or abstract mechanism.  Moreover,
-is is nice to be able to search for ``pytest_funcarg__MYARG`` in
-a source code and safely find all factory functions for
+it is nice to be able to search for ``pytest_funcarg__MYARG`` in
+source code and safely find all factory functions for
 the ``MYARG`` function argument.
 
 .. _`Convention over Configuration`: http://en.wikipedia.org/wiki/Convention_over_Configuration

doc/funcargs.txt

@@ -16,7 +16,7 @@ control their life cycle in relation to the test execution. It is
 also possible to run a test function multiple times with different objects.
 
 The basic mechanism for injecting objects is also called the
-*funcarg mechanism* because objects are ultimatly injected
+*funcarg mechanism* because objects are ultimately injected
 by calling a test function with it as an argument.  Unlike the
 classical xUnit approach *funcargs* relate more to `Dependency Injection`_
 because they help to de-couple test code from objects required for
@@ -62,7 +62,7 @@ Running the test looks like this::
 
     $ py.test test_simplefactory.py
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 1 items
     
     test_simplefactory.py F
@@ -119,9 +119,9 @@ think of as "resources").
 The funcarg **request** object
 =============================================
 
-Each funcarg factory receives a **request** object which is tied to a
-specific test function call.  A request object is passed to a funcarg
-factory and provides access to test configuration and context:
+Each funcarg factory receives a **request** object tied to a specific test
+function call.  A request object is passed to a funcarg factory and provides
+access to test configuration and context:
 
 .. autoclass:: _pytest.python.FuncargRequest()
     :members: function,cls,module,keywords,config
@@ -167,7 +167,7 @@ Running this will generate ten invocations of ``test_func`` passing in each of t
 
     $ py.test test_example.py
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 10 items
     
     test_example.py .........F
@@ -182,7 +182,7 @@ Running this will generate ten invocations of ``test_func`` passing in each of t
     E       assert 9 < 9
     
     test_example.py:6: AssertionError
-    ==================== 1 failed, 9 passed in 0.05 seconds ====================
+    ==================== 1 failed, 9 passed in 0.07 seconds ====================
 
 Obviously, only when ``numiter`` has the value of ``9`` does the test fail.  Note that the ``pytest_generate_tests(metafunc)`` hook is called during
 the test collection phase which is separate from the actual test running.
@@ -190,7 +190,7 @@ Let's just look at what is collected::
 
     $ py.test --collectonly test_example.py
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 10 items
     <Module 'test_example.py'>
       <Function 'test_func[0]'>
@@ -210,13 +210,13 @@ If you want to select only the run with the value ``7`` you could do::
 
     $ py.test -v -k 7 test_example.py  # or -k test_func[7]
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0 -- /Users/hpk/venv/1/bin/python
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2 -- /Users/hpk/venv/0/bin/python
     collecting ... collected 10 items
     
     test_example.py:5: test_func[7] PASSED
     
     ======================= 9 tests deselected by '-k7' ========================
-    ================== 1 passed, 9 deselected in 0.02 seconds ==================
+    ================== 1 passed, 9 deselected in 0.01 seconds ==================
 
 You might want to look at :ref:`more parametrization examples <paramexamples>`.
 
@@ -240,5 +240,5 @@ in the class or module where a test function is defined:
 
 ``metafunc.config``: access to command line opts and general config
 
-.. automethod:: Metafunc.parametrize(name, values, idmaker=None)
-.. automethod:: Metafunc.addcall(funcargs=None, id=_notexists, param=_notexists)
+.. automethod:: Metafunc.parametrize
+.. automethod:: Metafunc.addcall(funcargs=None,id=_notexists,param=_notexists)

doc/getting-started.txt

@@ -22,9 +22,10 @@ Installation options::
 To check your installation has installed the correct version::
 
     $ py.test --version
-    This is py.test version 2.2.0, imported from /Users/hpk/p/pytest/pytest.pyc
+    This is py.test version 2.2.2, imported from /Users/hpk/p/pytest/pytest.pyc
     setuptools registered plugins:
-      pytest-xdist-1.7.dev1 at /Users/hpk/p/pytest-xdist/xdist/plugin.pyc
+      pytest-xdist-1.8 at /Users/hpk/p/pytest-xdist/xdist/plugin.pyc
+      pytest-cov-1.4 at /Users/hpk/venv/0/lib/python2.7/site-packages/pytest_cov.pyc
 
 If you get an error checkout :ref:`installation issues`.
 
@@ -46,7 +47,7 @@ That's it. You can execute the test function now::
 
     $ py.test
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 1 items
     
     test_sample.py F
@@ -60,7 +61,7 @@ That's it. You can execute the test function now::
     E        +  where 4 = func(3)
     
     test_sample.py:5: AssertionError
-    ========================= 1 failed in 0.04 seconds =========================
+    ========================= 1 failed in 0.02 seconds =========================
 
 py.test found the ``test_answer`` function by following :ref:`standard test discovery rules <test discovery>`, basically detecting the ``test_`` prefixes.  We got a failure report because our little ``func(3)`` call did not return ``5``.
 
@@ -126,7 +127,7 @@ run the module by passing its filename::
     ================================= FAILURES =================================
     ____________________________ TestClass.test_two ____________________________
     
-    self = <test_class.TestClass instance at 0x10150a170>
+    self = <test_class.TestClass instance at 0x1013225a8>
     
         def test_two(self):
             x = "hello"
@@ -163,7 +164,7 @@ before performing the test function call.  Let's just run it::
     ================================= FAILURES =================================
     _____________________________ test_needsfiles ______________________________
     
-    tmpdir = local('/Users/hpk/tmp/pytest-1595/test_needsfiles0')
+    tmpdir = local('/Users/hpk/tmp/pytest-20/test_needsfiles0')
     
         def test_needsfiles(tmpdir):
             print tmpdir
@@ -172,8 +173,8 @@ before performing the test function call.  Let's just run it::
     
     test_tmpdir.py:3: AssertionError
     ----------------------------- Captured stdout ------------------------------
-    /Users/hpk/tmp/pytest-1595/test_needsfiles0
-    1 failed in 0.15 seconds
+    /Users/hpk/tmp/pytest-20/test_needsfiles0
+    1 failed in 0.11 seconds
 
 Before the test runs, a unique-per-test-invocation temporary directory
 was created.  More info at :ref:`tmpdir handling`.

doc/goodpractises.txt

@@ -21,7 +21,7 @@ dependency configurations or Python interpreters is `tox`_.
 Use tox and Continuous Integration servers
 -------------------------------------------------
 
-If you frequently relase code to the public you
+If you frequently release code to the public you
 may want to look into `tox`_, the virtualenv test automation
 tool and its `pytest support <http://codespeak.net/tox/example/pytest.html>`_.
 The basic idea is to generate a JUnitXML file through the ``--junitxml=PATH`` option and have a continuous integration server like Jenkins_ pick it up
@@ -30,7 +30,7 @@ and generate reports.
 .. _standalone:
 .. _`genscript method`:
 
-Create a py.test standalone Script
+Create a py.test standalone script
 -------------------------------------------
 
 If you are a maintainer or application developer and want others
@@ -159,7 +159,7 @@ You can run your tests by pointing to it::
 
     * find ``basedir`` -- this is the first "upward" (towards the root)
       directory not containing an ``__init__.py``.  If both the ``a``
-      and ``b`` directories contain an ``__init__.py`` the basedir will 
+      and ``b`` directories contain an ``__init__.py`` the basedir will
       be the parent dir of ``a``.
 
     * perform ``sys.path.insert(0, basedir)`` to make the test module

doc/monkeypatch.txt

@@ -14,14 +14,14 @@ and a discussion of its motivation.
 
 .. _`monkeypatch blog post`: http://tetamap.wordpress.com/2009/03/03/monkeypatching-in-unit-tests-done-right/
 
-
-Simple example: patching ``os.path.expanduser``
+Simple example: monkeypatching functions
 ---------------------------------------------------
 
-If, for instance, you want to pretend that ``os.expanduser`` returns a certain
+If you want to pretend that ``os.expanduser`` returns a certain
 directory, you can use the :py:meth:`monkeypatch.setattr` method to
 patch this function before calling into a function which uses it::
 
+    # content of test_module.py
     import os.path
     def getssh(): # pseudo application code
         return os.path.join(os.path.expanduser("~admin"), '.ssh')
@@ -33,22 +33,15 @@ patch this function before calling into a function which uses it::
         x = getssh()
         assert x == '/abc/.ssh'
 
-After the test function finishes the ``os.path.expanduser`` modification
-will be undone.
-
-.. background check:
-   $ py.test
-   =========================== test session starts ============================
-   platform darwin -- Python 2.7.1 -- pytest-2.2.0
-   collecting ... collected 0 items
-   
-   =============================  in 0.20 seconds =============================
+Here our test function monkeypatches ``os.path.expanduser`` and
+then calls into an function that calls it.  After the test function 
+finishes the ``os.path.expanduser`` modification will be undone.
 
 Method reference of the monkeypatch function argument
 -----------------------------------------------------
 
 .. autoclass:: monkeypatch
-    :members: setattr, delattr, setitem, delitem, setenv, delenv, syspath_prepend, undo
+    :members: setattr, delattr, setitem, delitem, setenv, delenv, syspath_prepend, chdir, undo
 
 ``monkeypatch.setattr/delattr/delitem/delenv()`` all
 by default raise an Exception if the target does not exist.

doc/plugins.txt

@@ -264,7 +264,7 @@ specification.  However, a hook function may accept *fewer* parameters
 by simply not specifying them.  If you mistype argument names or the
 hook name itself you get an error showing the available arguments.
 
-Initialisation, command line and configuration hooks
+Initialization, command line and configuration hooks
 --------------------------------------------------------------------
 
 .. currentmodule:: _pytest.hookspec

doc/recwarn.txt

@@ -1,5 +1,5 @@
 
-Asserting deprecation and other warnings.
+Asserting deprecation and other warnings
 =====================================================
 
 The recwarn function argument
@@ -35,4 +35,3 @@ warning::
 
     def test_global():
         pytest.deprecated_call(myfunction, 17)
-

doc/skipping.txt

@@ -130,7 +130,7 @@ Running it with the report-on-xfail option gives this output::
 
     example $ py.test -rx xfail_demo.py
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 6 items
     
     xfail_demo.py xxxxxx
@@ -147,7 +147,7 @@ Running it with the report-on-xfail option gives this output::
     XFAIL xfail_demo.py::test_hello6
       reason: reason
     
-    ======================== 6 xfailed in 0.08 seconds =========================
+    ======================== 6 xfailed in 0.16 seconds =========================
 
 .. _`evaluation of skipif/xfail conditions`:
 

doc/test/plugin/cov.txt

@@ -35,10 +35,11 @@ However easy_install does not provide an uninstall facility.
 
 .. IMPORTANT::
 
-    Ensure that you manually delete the init_covmain.pth file in your site-packages directory.
+    Ensure that you manually delete the init_covmain.pth file in your
+    site-packages directory.
 
-    This file starts coverage collection of subprocesses if appropriate during site initialisation
-    at python startup.
+    This file starts coverage collection of subprocesses if appropriate during
+    site initialization at python startup.
 
 
 Usage
@@ -198,7 +199,7 @@ slave.
 
 For subprocess measurement environment variables must make it from the main process to the
 subprocess.  The python used by the subprocess must have pytest-cov installed.  The subprocess must
-do normal site initialisation so that the environment variables can be detected and coverage
+do normal site initialization so that the environment variables can be detected and coverage
 started.
 
 

doc/tmpdir.txt

@@ -28,7 +28,7 @@ Running this would result in a passed test except for the last
 
     $ py.test test_tmpdir.py
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 1 items
     
     test_tmpdir.py F
@@ -36,7 +36,7 @@ Running this would result in a passed test except for the last
     ================================= FAILURES =================================
     _____________________________ test_create_file _____________________________
     
-    tmpdir = local('/Users/hpk/tmp/pytest-1596/test_create_file0')
+    tmpdir = local('/Users/hpk/tmp/pytest-21/test_create_file0')
     
         def test_create_file(tmpdir):
             p = tmpdir.mkdir("sub").join("hello.txt")
@@ -47,7 +47,7 @@ Running this would result in a passed test except for the last
     E       assert 0
     
     test_tmpdir.py:7: AssertionError
-    ========================= 1 failed in 0.20 seconds =========================
+    ========================= 1 failed in 0.07 seconds =========================
 
 .. _`base temporary directory`:
 

doc/unittest.txt

@@ -24,7 +24,7 @@ Running it yields::
 
     $ py.test test_unittest.py
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
+    platform darwin -- Python 2.7.1 -- pytest-2.2.2
     collecting ... collected 1 items
     
     test_unittest.py F
@@ -42,7 +42,7 @@ Running it yields::
     test_unittest.py:8: AssertionError
     ----------------------------- Captured stdout ------------------------------
     hello
-    ========================= 1 failed in 0.23 seconds =========================
+    ========================= 1 failed in 0.15 seconds =========================
 
 .. _`unittest.py style`: http://docs.python.org/library/unittest.html
 

doc/usage.txt

@@ -96,11 +96,11 @@ can use a helper::
 .. versionadded: 2.0.0
 
 In previous versions you could only enter PDB tracing if
-you disable capturing on the command line via ``py.test -s``.
+you disabled capturing on the command line via ``py.test -s``.
 
 .. _durations:
 
-Profiling test execution duration 
+Profiling test execution duration
 -------------------------------------
 
 .. versionadded: 2.2

doc/xunit_setup.txt

@@ -24,13 +24,11 @@ module you can optionally implement the following fixture methods
 which will usually be called once for all the functions::
 
     def setup_module(module):
-        """ setup up any state specific to the execution
-            of the given module.
-        """
+        """ setup any state specific to the execution of the given module."""
 
     def teardown_module(module):
-        """ teardown any state that was previously setup
-            with a setup_module method.
+        """ teardown any state that was previously setup with a setup_module
+        method.
         """
 
 Class level setup/teardown
@@ -41,14 +39,14 @@ and after all test methods of the class are called::
 
     @classmethod
     def setup_class(cls):
-        """ setup up any state specific to the execution
-            of the given class (which usually contains tests).
+        """ setup any state specific to the execution of the given class (which
+        usually contains tests).
         """
 
     @classmethod
     def teardown_class(cls):
-        """ teardown any state that was previously setup
-            with a call to setup_class.
+        """ teardown any state that was previously setup with a call to
+        setup_class.
         """
 
 Method and function level setup/teardown
@@ -57,31 +55,29 @@ Method and function level setup/teardown
 Similarly, the following methods are called around each method invocation::
 
     def setup_method(self, method):
-        """ setup up any state tied to the execution of the given
-        method in a class.  setup_method is invoked for every
-        test method of a class.
+        """ setup any state tied to the execution of the given method in a
+        class.  setup_method is invoked for every test method of a class.
         """
 
     def teardown_method(self, method):
-        """ teardown any state that was previously setup
-        with a setup_method call.
+        """ teardown any state that was previously setup with a setup_method
+        call.
         """
 
 If you would rather define test functions directly at module level
 you can also use the following functions to implement fixtures::
 
     def setup_function(function):
-        """ setup up any state tied to the execution of the given
-        function. Invoked for every test function in the module.
+        """ setup any state tied to the execution of the given function.
+        Invoked for every test function in the module.
         """
 
     def teardown_function(function):
-        """ teardown any state that was previously setup
-        with a setup_function call.
+        """ teardown any state that was previously setup with a setup_function
+        call.
         """
-    
-Note that it possible that setup/teardown pairs are invoked multiple
-times per testing process.
+
+Note that it is possible for setup/teardown pairs to be invoked multiple times
+per testing process.
 
 .. _`unittest.py module`: http://docs.python.org/library/unittest.html
-

setup.py

@@ -11,20 +11,20 @@ cross-project testing tool for Python.
 
 Platforms: Linux, Win32, OSX
 
-Interpreters: Python versions 2.4 through to 3.2, Jython 2.5.1 and PyPy-1.5
+Interpreters: Python versions 2.4 through to 3.2, Jython 2.5.1 and PyPy-1.6/1.7
 
 Bugs and issues: http://bitbucket.org/hpk42/pytest/issues/
 
 Web page: http://pytest.org
 
-(c) Holger Krekel and others, 2004-2011
+(c) Holger Krekel and others, 2004-2012
 """
 def main():
     setup(
         name='pytest',
         description='py.test: simple powerful testing with Python',
         long_description = long_description,
-        version='2.2.0',
+        version='2.2.2',
         url='http://pytest.org',
         license='MIT license',
         platforms=['unix', 'linux', 'osx', 'cygwin', 'win32'],
@@ -32,7 +32,7 @@ def main():
         author_email='holger at merlinux.eu',
         entry_points= make_entry_points(),
         # the following should be enabled for release
-        install_requires=['py>=1.4.5'],
+        install_requires=['py>=1.4.7.dev2'],
         classifiers=['Development Status :: 6 - Mature',
                      'Intended Audience :: Developers',
                      'License :: OSI Approved :: MIT License',

testing/acceptance_test.py

@@ -410,15 +410,20 @@ class TestInvocationVariants:
             "*1 passed*"
         ])
 
+        def join_pythonpath(what):
+            cur = py.std.os.environ.get('PYTHONPATH')
+            if cur:
+                return str(what) + ':' + cur
+            return what
         empty_package = testdir.mkpydir("empty_package")
-        monkeypatch.setenv('PYTHONPATH', empty_package)
+        monkeypatch.setenv('PYTHONPATH', join_pythonpath(empty_package))
         result = testdir.runpytest("--pyargs", ".")
         assert result.ret == 0
         result.stdout.fnmatch_lines([
             "*2 passed*"
         ])
 
-        monkeypatch.setenv('PYTHONPATH', testdir)
+        monkeypatch.setenv('PYTHONPATH', join_pythonpath(testdir))
         path.join('test_hello.py').remove()
         result = testdir.runpytest("--pyargs", "tpkg.test_hello")
         assert result.ret != 0

testing/test_assertinterpret.py

@@ -28,17 +28,14 @@ def test_assert_with_explicit_message():
         assert e.msg == 'hello'
 
 def test_assert_within_finally():
-    class A:
-        def f():
-            pass
-    excinfo = py.test.raises(TypeError, """
+    excinfo = py.test.raises(ZeroDivisionError, """
         try:
-            A().f()
+            1/0
         finally:
             i = 42
     """)
     s = excinfo.exconly()
-    assert s.find("takes no argument") != -1
+    assert py.std.re.search("division.+by zero", s) is not None
 
     #def g():
     #    A.f()

testing/test_capture.py

@@ -205,7 +205,7 @@ class TestPerTestCapturing:
             #"*1 fixture failure*"
         ])
 
-    def test_teardown_final_capturing(self, testdir):
+    def test_teardown_capturing_final(self, testdir):
         p = testdir.makepyfile("""
             def teardown_module(mod):
                 print ("teardown module")

testing/test_mark.py

@@ -228,18 +228,26 @@ class TestFunctional:
         keywords = item.keywords
         marker = keywords['hello']
         assert marker.args == ("pos0", "pos1")
-        assert marker.kwargs == {'x': 3, 'y': 2, 'z': 4}
+        assert marker.kwargs == {'x': 1, 'y': 2, 'z': 4}
 
-    def test_mark_other(self, testdir):
-        pytest.raises(TypeError, '''
-            testdir.getitem("""
+        # test the new __iter__ interface
+        l = list(marker)
+        assert len(l) == 3
+        assert l[0].args == ("pos0",)
+        assert l[1].args == ()
+        assert l[2].args == ("pos1", )
+
+    def test_mark_with_wrong_marker(self, testdir):
+        reprec = testdir.inline_runsource("""
                 import pytest
                 class pytestmark:
                     pass
                 def test_func():
                     pass
-            """)
-        ''')
+        """)
+        l = reprec.getfailedcollections()
+        assert len(l) == 1
+        assert "TypeError" in str(l[0].longrepr)
 
     def test_mark_dynamically_in_funcarg(self, testdir):
         testdir.makeconftest("""
@@ -259,6 +267,23 @@ class TestFunctional:
             "keyword: *hello*"
         ])
 
+    def test_merging_markers_two_functions(self, testdir):
+        p = testdir.makepyfile("""
+            import pytest
+            @pytest.mark.hello("pos1", z=4)
+            @pytest.mark.hello("pos0", z=3)
+            def test_func(self):
+                pass
+        """)
+        items, rec = testdir.inline_genitems(p)
+        item, = items
+        keywords = item.keywords
+        marker = keywords['hello']
+        l = list(marker)
+        assert len(l) == 2
+        assert l[0].args == ("pos0",)
+        assert l[1].args == ("pos1",)
+
 
 class TestKeywordSelection:
     def test_select_simple(self, testdir):

testing/test_monkeypatch.py

@@ -2,6 +2,17 @@ import os, sys
 import pytest
 from _pytest.monkeypatch import monkeypatch as MonkeyPatch
 
+def pytest_funcarg__mp(request):
+    cwd = os.getcwd()
+    sys_path = list(sys.path)
+
+    def cleanup():
+        sys.path[:] = sys_path
+        os.chdir(cwd)
+
+    request.addfinalizer(cleanup)
+    return MonkeyPatch()
+
 def test_setattr():
     class A:
         x = 1
@@ -59,6 +70,29 @@ def test_setitem():
     monkeypatch.undo()
     assert d['x'] == 5
 
+def test_setitem_deleted_meanwhile():
+    d = {}
+    monkeypatch = MonkeyPatch()
+    monkeypatch.setitem(d, 'x', 2)
+    del d['x']
+    monkeypatch.undo()
+    assert not d
+
+@pytest.mark.parametrize("before", [True, False])
+def test_setenv_deleted_meanwhile(before):
+    key = "qwpeoip123"
+    if before:
+        os.environ[key] = "world"
+    monkeypatch = MonkeyPatch()
+    monkeypatch.setenv(key, 'hello')
+    del os.environ[key]
+    monkeypatch.undo()
+    if before:
+        assert os.environ[key] == "world"
+        del os.environ[key]
+    else:
+        assert key not in os.environ
+
 def test_delitem():
     d = {'x': 1}
     monkeypatch = MonkeyPatch()
@@ -121,19 +155,41 @@ def test_monkeypatch_plugin(testdir):
     res = reprec.countoutcomes()
     assert tuple(res) == (1, 0, 0), res
 
-def test_syspath_prepend():
+def test_syspath_prepend(mp):
     old = list(sys.path)
-    try:
-        monkeypatch = MonkeyPatch()
-        monkeypatch.syspath_prepend('world')
-        monkeypatch.syspath_prepend('hello')
-        assert sys.path[0] == "hello"
-        assert sys.path[1] == "world"
-        monkeypatch.undo()
-        assert sys.path == old
-        monkeypatch.undo()
-        assert sys.path == old
-    finally:
-        sys.path[:] = old
+    mp.syspath_prepend('world')
+    mp.syspath_prepend('hello')
+    assert sys.path[0] == "hello"
+    assert sys.path[1] == "world"
+    mp.undo()
+    assert sys.path == old
+    mp.undo()
+    assert sys.path == old
 
+def test_syspath_prepend_double_undo(mp):
+    mp.syspath_prepend('hello world')
+    mp.undo()
+    sys.path.append('more hello world')
+    mp.undo()
+    assert sys.path[-1] == 'more hello world'
 
+def test_chdir_with_path_local(mp, tmpdir):
+    mp.chdir(tmpdir)
+    assert os.getcwd() == tmpdir.strpath
+
+def test_chdir_with_str(mp, tmpdir):
+    mp.chdir(tmpdir.strpath)
+    assert os.getcwd() == tmpdir.strpath
+
+def test_chdir_undo(mp, tmpdir):
+    cwd = os.getcwd()
+    mp.chdir(tmpdir)
+    mp.undo()
+    assert os.getcwd() == cwd
+
+def test_chdir_double_undo(mp, tmpdir):
+    mp.chdir(tmpdir.strpath)
+    mp.undo()
+    tmpdir.chdir()
+    mp.undo()
+    assert os.getcwd() == tmpdir.strpath

testing/test_python.py

@@ -477,7 +477,7 @@ class TestTracebackCutting:
         out = result.stdout.str()
         assert out.find("conftest.py:2: ValueError") != -1
         numentries = out.count("_ _ _ _") # separator for traceback entries
-        assert numentries >3
+        assert numentries > 3
 
     def test_traceback_error_during_import(self, testdir):
         testdir.makepyfile("""
@@ -689,7 +689,7 @@ class TestRequest:
         teardownlist = item.getparent(pytest.Module).obj.teardownlist
         ss = item.session._setupstate
         assert not teardownlist
-        ss.teardown_exact(item)
+        ss.teardown_exact(item, None)
         print(ss.stack)
         assert teardownlist == [1]
 
@@ -983,11 +983,12 @@ class TestMetafunc:
         metafunc = funcargs.Metafunc(func)
         metafunc.parametrize('x', [1], indirect=True)
         metafunc.parametrize('y', [2,3], indirect=True)
+        metafunc.parametrize('unnamed', [1], indirect=True)
         assert len(metafunc._calls) == 2
         assert metafunc._calls[0].funcargs == {}
         assert metafunc._calls[1].funcargs == {}
-        assert metafunc._calls[0].params == dict(x=1,y=2)
-        assert metafunc._calls[1].params == dict(x=1,y=3)
+        assert metafunc._calls[0].params == dict(x=1,y=2, unnamed=1)
+        assert metafunc._calls[1].params == dict(x=1,y=3, unnamed=1)
 
     def test_addcalls_and_parametrize_indirect(self):
         def func(x, y): pass
@@ -1048,6 +1049,23 @@ class TestMetafunc:
         assert metafunc._calls[1].funcargs == dict(x=3, y=4)
         assert metafunc._calls[1].id == "3-4"
 
+    def test_parametrize_multiple_times(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+            pytestmark = pytest.mark.parametrize("x", [1,2])
+            def test_func(x):
+                assert 0, x
+            class TestClass:
+                pytestmark = pytest.mark.parametrize("y", [3,4])
+                def test_meth(self, x, y):
+                    assert 0, x
+        """)
+        result = testdir.runpytest()
+        assert result.ret == 1
+        result.stdout.fnmatch_lines([
+            "*6 fail*",
+        ])
+
 class TestMetafuncFunctional:
     def test_attributes(self, testdir):
         p = testdir.makepyfile("""
@@ -1517,3 +1535,38 @@ def test_customize_through_attributes(testdir):
         "*MyInstance*",
         "*MyFunction*test_hello*",
     ])
+
+
+def test_unorderable_types(testdir):
+    testdir.makepyfile("""
+        class TestJoinEmpty:
+            pass
+
+        def make_test():
+            class Test:
+                pass
+            Test.__name__ = "TestFoo"
+            return Test
+        TestFoo = make_test()
+    """)
+    result = testdir.runpytest()
+    assert "TypeError" not in result.stdout.str()
+    assert result.ret == 0
+
+def test_issue117_sessionscopeteardown(testdir):
+    testdir.makepyfile("""
+        def pytest_funcarg__app(request):
+            app = request.cached_setup(
+                scope='session',
+                setup=lambda: 0,
+                teardown=lambda x: 3/x)
+            return app
+        def test_func(app):
+            pass
+    """)
+    result = testdir.runpytest()
+    assert result.ret != 0
+    result.stderr.fnmatch_lines([
+        "*3/x*",
+        "*ZeroDivisionError*",
+    ])

testing/test_resultlog.py

@@ -133,23 +133,26 @@ class TestWithFunctionIntegration:
         assert lines[14].startswith('X ')
         assert len(lines) == 15
 
-    def test_internal_exception(self):
+    @pytest.mark.parametrize("style", ("native", "long", "short"))
+    def test_internal_exception(self, style):
         # they are produced for example by a teardown failing
-        # at the end of the run
+        # at the end of the run or a failing hook invocation
         try:
             raise ValueError
         except ValueError:
             excinfo = py.code.ExceptionInfo()
         reslog = ResultLog(None, py.io.TextIO())
-        reslog.pytest_internalerror(excinfo.getrepr())
+        reslog.pytest_internalerror(excinfo.getrepr(style=style))
         entry = reslog.logfile.getvalue()
         entry_lines = entry.splitlines()
 
         assert entry_lines[0].startswith('! ')
-        assert os.path.basename(__file__)[:-9] in entry_lines[0] #.pyc/class
+        if style != "native":
+            assert os.path.basename(__file__)[:-9] in entry_lines[0] #.pyc/class
         assert entry_lines[-1][0] == ' '
         assert 'ValueError' in entry
 
+
 def test_generic(testdir, LineMatcher):
     testdir.plugins.append("resultlog")
     testdir.makepyfile("""

testing/test_runner.py

@@ -1,4 +1,4 @@
-import pytest, py, sys
+import pytest, py, sys, os
 from _pytest import runner
 from py._code.code import ReprExceptionInfo
 
@@ -30,9 +30,9 @@ class TestSetupState:
     def test_teardown_exact_stack_empty(self, testdir):
         item = testdir.getitem("def test_func(): pass")
         ss = runner.SetupState()
-        ss.teardown_exact(item)
-        ss.teardown_exact(item)
-        ss.teardown_exact(item)
+        ss.teardown_exact(item, None)
+        ss.teardown_exact(item, None)
+        ss.teardown_exact(item, None)
 
     def test_setup_fails_and_failure_is_cached(self, testdir):
         item = testdir.getitem("""
@@ -315,6 +315,21 @@ class TestSessionReports:
         assert not rep.passed
         assert rep.skipped
 
+
+reporttypes = [
+    runner.BaseReport,
+    runner.TestReport,
+    runner.TeardownErrorReport,
+    runner.CollectReport,
+]
+
+@pytest.mark.parametrize('reporttype', reporttypes, ids=[x.__name__ for x in reporttypes])
+def test_report_extra_parameters(reporttype):
+    args = py.std.inspect.getargspec(reporttype.__init__)[0][1:]
+    basekw = dict.fromkeys(args, [])
+    report = reporttype(newthing=1, **basekw)
+    assert report.newthing == 1
+
 def test_callinfo():
     ci = runner.CallInfo(lambda: 0, '123')
     assert ci.when == "123"
@@ -423,21 +438,18 @@ def test_importorskip():
         py.test.fail("spurious skip")
 
 def test_importorskip_imports_last_module_part():
-    import os
     ospath = py.test.importorskip("os.path")
     assert os.path == ospath
 
 
 def test_pytest_cmdline_main(testdir):
     p = testdir.makepyfile("""
-        import sys
-        sys.path.insert(0, %r)
         import py
         def test_hello():
             assert 1
         if __name__ == '__main__':
            py.test.cmdline.main([__file__])
-    """ % (str(py._pydir.dirpath())))
+    """)
     import subprocess
     popen = subprocess.Popen([sys.executable, str(p)], stdout=subprocess.PIPE)
     s = popen.stdout.read()

testing/test_terminal.py

@@ -256,6 +256,31 @@ class TestCollectonly:
             *1 error*
         """).strip())
 
+    def test_collectonly_missing_path(self, testdir):
+        """this checks issue 115,
+            failure in parseargs will cause session
+            not to have the items attribute
+        """
+        result = testdir.runpytest("--collectonly", "uhm_missing_path")
+        assert result.ret == 3
+        result.stderr.fnmatch_lines([
+            '*ERROR: file not found*',
+        ])
+
+    def test_collectonly_quiet(self, testdir):
+        testdir.makepyfile("def test_foo(): pass")
+        result = testdir.runpytest("--collectonly", "-q")
+        result.stdout.fnmatch_lines([
+            '*test_foo*',
+        ])
+
+    def test_collectonly_more_quiet(self, testdir):
+        testdir.makepyfile(test_fun="def test_foo(): pass")
+        result = testdir.runpytest("--collectonly", "-qq")
+        result.stdout.fnmatch_lines([
+            '*test_fun.py: 1*',
+        ])
+
 
 def test_repr_python_version(monkeypatch):
     try:

testing/test_unittest.py

@@ -38,7 +38,7 @@ def test_setup(testdir):
                 assert self.foo2 == 1
             def teardown_method(self, method):
                 assert 0, "42"
-                
+
     """)
     reprec = testdir.inline_run("-s", testpath)
     assert reprec.matchreport("test_both", when="call").passed
@@ -232,6 +232,29 @@ def test_module_level_pytestmark(testdir):
     reprec.assertoutcome(skipped=1)
 
 
+def test_testcase_skip_property(testdir):
+    testpath = testdir.makepyfile("""
+        import unittest
+        class MyTestCase(unittest.TestCase):
+            skip = 'dont run'
+            def test_func(self):
+                pass
+        """)
+    reprec = testdir.inline_run(testpath, "-s")
+    reprec.assertoutcome(skipped=1)
+
+def test_testfunction_skip_property(testdir):
+    testpath = testdir.makepyfile("""
+        import unittest
+        class MyTestCase(unittest.TestCase):
+            def test_func(self):
+                pass
+            test_func.skip = 'dont run'
+        """)
+    reprec = testdir.inline_run(testpath, "-s")
+    reprec.assertoutcome(skipped=1)
+
+
 class TestTrialUnittest:
     def setup_class(cls):
         pytest.importorskip("twisted.trial.unittest")
@@ -408,3 +431,31 @@ def test_unittest_not_shown_in_traceback(testdir):
     """)
     res = testdir.runpytest()
     assert "failUnlessEqual" not in res.stdout.str()
+
+def test_unorderable_types(testdir):
+    testdir.makepyfile("""
+        import unittest
+        class TestJoinEmpty(unittest.TestCase):
+            pass
+
+        def make_test():
+            class Test(unittest.TestCase):
+                pass
+            Test.__name__ = "TestFoo"
+            return Test
+        TestFoo = make_test()
+    """)
+    result = testdir.runpytest()
+    assert "TypeError" not in result.stdout.str()
+    assert result.ret == 0
+
+def test_unittest_typerror_traceback(testdir):
+    testdir.makepyfile("""
+        import unittest
+        class TestJoinEmpty(unittest.TestCase):
+            def test_hello(self, arg1):
+                pass
+    """)
+    result = testdir.runpytest()
+    assert "TypeError" in result.stdout.str()
+    assert result.ret == 1

tox.ini

@@ -33,7 +33,7 @@ deps=:pypi:twisted
      :pypi:pexpect
      py>=1.4.5.dev1
 commands=
-  py.test -rsxf \
+  py.test -rsxf testing/test_unittest.py \
         --junitxml={envlogdir}/junit-{envname}.xml {posargs:testing/test_unittest.py}
 [testenv:doctest]
 changedir=.
@@ -51,8 +51,7 @@ commands=
     make html
 
 [testenv:py31]
-deps=py>1.4.0
-    :pypi:nose>=1.0
+deps=:pypi:nose>=1.0
 
 [testenv:py31-xdist]
 deps=pytest-xdist