fix doc release version

bump versions, depend on already released py-1.4.25

.gitignore

@@ -0,0 +1,32 @@
+# Automatically generated by `hgimportsvn`
+.svn
+.hgsvn
+
+# Ignore local virtualenvs
+lib/
+bin/
+include/
+.Python/
+
+# These lines are suggested according to the svn:ignore property
+# Feel free to enable them by uncommenting them
+*.pyc
+*.pyo
+*.swp
+*.class
+*.orig
+*~
+
+doc/*/_build
+build/
+dist/
+*.egg-info
+issue/
+env/
+3rdparty/
+.tox
+.cache
+.coverage
+.ropeproject
+.idea
+

.hgignore

@@ -1,9 +1,16 @@
-
 # Automatically generated by `hgimportsvn`
 syntax:glob
 .svn
 .hgsvn
 
+# Ignore local virtualenvs
+syntax:glob
+lib/
+bin/
+include/
+.Python/
+.env/
+
 # These lines are suggested according to the svn:ignore property
 # Feel free to enable them by uncommenting them
 syntax:glob
@@ -15,11 +22,16 @@ syntax:glob
 *.orig
 *~
 
-doc/_build
+doc/*/_build
 build/
 dist/
 *.egg-info
 issue/
 env/
+env3/
 3rdparty/
 .tox
+.cache
+.coverage
+.ropeproject
+*.sublime-*

.hgtags

@@ -44,3 +44,30 @@ c777dcad166548b7499564cb49ae5c8b4b07f935 2.0.3
 e5e1746a197f0398356a43fbe2eebac9690f795d 2.1.0
 5864412c6f3c903384243bd315639d101d7ebc67 2.1.2
 12a05d59249f80276e25fd8b96e8e545b1332b7a 2.1.3
+1522710369337d96bf9568569d5f0ca9b38a74e0 2.2.0
+3da8cec6c5326ed27c144c9b6d7a64a648370005 2.2.1
+92b916483c1e65a80dc80e3f7816b39e84b36a4d 2.2.2
+3c11c5c9776f3c678719161e96cc0a08169c1cb8 2.2.3
+ad9fe504a371ad8eb613052d58f229aa66f53527 2.2.4
+c27a60097767c16a54ae56d9669a77925b213b9b 2.3.0
+acf0e1477fb19a1d35a4e40242b77fa6af32eb17 2.3.1
+8738b828dec53937765db71951ef955cca4c51f6 2.3.2
+7fe44182c434f8ac89149a3c340479872a5d5ccb 2.3.3
+ef299e57f24218dbdd949498d7e660723636bcc3 2.3.4
+fc3a793e87ec907000a47ea0d3a372a2fe218c0a 2.3.5
+b93ac0cdae02effaa3c136a681cc45bba757fe46 1.4.14
+b93ac0cdae02effaa3c136a681cc45bba757fe46 1.4.14
+0000000000000000000000000000000000000000 1.4.14
+0000000000000000000000000000000000000000 1.4.14
+0000000000000000000000000000000000000000 1.4.14
+af860de70cc3f157ac34ca1d4bf557a057bff775 2.4.0
+8828c924acae0b4cad2e2cb92943d51da7cb744a 2.4.1
+8d051f89184bfa3033f5e59819dff9f32a612941 2.4.2
+a064ad64d167508a8e9e73766b1a4e6bd10c85db 2.5.0
+039d543d1ca02a716c0b0de9a7131beb8021e8a2 2.5.1
+421d3b4d150d901de24b1cbeb8955547b1420483 2.5.2
+60725b17a9d1af4100abb8be3f9f4ddf6262bf34 2.6.0
+60725b17a9d1af4100abb8be3f9f4ddf6262bf34 2.6.0
+88af949b9611494e2c65d528f9e565b00fb7e8ca 2.6.0
+a4f9639702baa3eb4f3b16e162f74f7b69f3f9e1 2.6.1
+a4f25c5e649892b5cc746d21be971e4773478af9 2.6.2

.travis.yml

@@ -0,0 +1,11 @@
+language: python
+# command to install dependencies
+install: "pip install -U detox"
+# # command to run tests
+script: detox --recreate -i ALL=https://devpi.net/hpk/dev/
+
+notifications:
+  irc:
+    - "chat.freenode.net#pytest-dev"
+  email:
+    - pytest-commit@python.org

AUTHORS

@@ -1,25 +1,47 @@
 Holger Krekel, holger at merlinux eu
 merlinux GmbH, Germany, office at merlinux eu
 
-Contributors include:: 
+Contributors include::
 
 Ronny Pfannschmidt
 Benjamin Peterson
 Floris Bruynooghe
+Jason R. Coombs
+Wouter van Ackooy
 Samuele Pedroni
+Anatoly Bubenkoff
+Brianna Laugher
 Carl Friedrich Bolz
 Armin Rigo
+Maho
+Jaap Broekhuizen
 Maciek Fijalkowski
 Guido Wesdorp
 Brian Dorsey
 Ross Lawley
 Ralf Schmitt
-Chris Lamb 
+Chris Lamb
 Harald Armin Massa
 Martijn Faassen
-Ian Bicking 
+Ian Bicking
 Jan Balster
 Grig Gheorghiu
 Bob Ippolito
 Christian Tismer
 Daniel Nuri
+Graham Horler
+Andreas Zeidler
+Brian Okken
+Katarzyna Jachim
+Christian Theunert
+Anthon van der Neut
+Mark Abramowitz
+Piotr Banaszkiewicz
+Jurko Gospodnetić
+Marc Schlaich
+Christopher Gilling
+Daniel Grana
+Andy Freeland
+Trevor Bekolay
+David Mohr
+Nicolas Delaby

CONTRIBUTING.rst

@@ -0,0 +1,171 @@
+============
+Contributing
+============
+
+Contributions are highly welcomed and appreciated.  Every little help counts,
+so do not hesitate!
+
+
+Types of contributions
+======================
+
+Report bugs
+-----------
+
+Report bugs at https://bitbucket.org/hpk42/pytest/issues.
+
+If you are reporting a bug, please include:
+
+* Your operating system name and version.
+* Any details about your local setup that might be helpful in troubleshooting,
+  specifically Python interpreter version,
+  installed libraries and pytest version.
+* Detailed steps to reproduce the bug.
+
+Submit feedback for developers
+------------------------------
+
+Do you like pytest?  Share some love on Twitter or in your blog posts!
+
+We'd also like to hear about your propositions and suggestions.  Feel free to
+`submit them as issues <https://bitbucket.org/hpk42/pytest/issues>`__ and:
+
+* Set the "kind" to "enhancement" or "proposal" so that we can quickly find
+  about them.
+* Explain in detail how they should work.
+* Keep the scope as narrow as possible.  This will make it easier to implement.
+* If you have required skills and/or knowledge, we are very happy for
+  :ref:`pull requests <pull-requests>`.
+
+
+Fix bugs
+--------
+
+Look through the BitBucket issues for bugs.  Here is sample filter you can use:
+https://bitbucket.org/hpk42/pytest/issues?status=new&status=open&kind=bug
+
+:ref:`Talk <contact>` to developers to find out how you can fix specific bugs.
+
+Implement features
+------------------
+
+Look through the BitBucket issues for enhancements.  Here is sample filter you
+can use:
+https://bitbucket.org/hpk42/pytest/issues?status=new&status=open&kind=enhancement
+
+:ref:`Talk <contact>` to developers to find out how you can implement specific
+features.
+
+Write documentation
+-------------------
+
+pytest could always use more documentation.  What exactly is needed?
+
+* More complementary documentation.  Have you perhaps found something unclear?
+* Documentation translations.  We currently have English and Japanese versions.
+* Docstrings.  There's never too much of them.
+* Blog posts, articles and such -- they're all very appreciated.
+
+.. _pull-requests:
+
+Preparing Pull Requests on Bitbucket
+=====================================
+
+.. note::
+  What is a "pull request"?  It informs project's core developers about the
+  changes you want to review and merge.  Pull requests are stored on
+  `BitBucket servers <https://bitbucket.org/hpk42/pytest/pull-requests>`__.
+  Once you send pull request, we can discuss it's potential modifications and
+  even add more commits to it later on.
+
+The primary development platform for pytest is BitBucket.  You can find all
+the issues there and submit your pull requests.
+
+1. Fork the
+   `pytest BitBucket repository <https://bitbucket.org/hpk42/pytest>`__.  It's
+   fine to use ``pytest`` as your fork repository name because it will live
+   under your user.
+
+.. _virtualenvactivate:
+
+2. Create and activate a fork-specific virtualenv
+   (http://www.virtualenv.org/en/latest/)::
+
+    $ virtualenv pytest-venv
+    $ source pytest-venv/bin/activate
+
+.. _checkout:
+
+3. Clone your fork locally using `Mercurial <http://mercurial.selenic.com/>`_
+   (``hg``) and create a branch::
+
+    $ hg clone ssh://hg@bitbucket.org/YOUR_BITBUCKET_USERNAME/pytest
+    $ cd pytest
+    $ hg branch your-branch-name
+
+   If you need some help with Mercurial, follow this quick start
+   guide: http://mercurial.selenic.com/wiki/QuickStart
+
+.. _testing-pytest:
+
+4. You can now edit your local working copy.  To test you need to
+   install the "tox" tool into your virtualenv::
+
+    $ pip install tox
+
+  You need to have Python 2.7 and 3.3 available in your system.  Now
+  running tests is as simple as issuing this command::
+
+    $ python runtox.py -e py27,py33,flakes
+
+  This command will run tests via the "tox" tool against Python 2.7 and 3.3
+  and also perform "flakes" coding-style checks.  ``runtox.py`` is
+  a thin wrapper around ``tox`` which installs from a development package
+  index where newer (not yet released to pypi) versions of dependencies
+  (especially ``py``) might be present.
+
+  To run tests on py27 and pass options (e.g. enter pdb on failure)
+  to pytest you can do::
+
+    $ python runtox.py -e py27 -- --pdb
+
+  or to only run tests in a particular test module on py33::
+
+    $ python runtox.py -e py33 -- testing/test_config.py
+
+5. Commit and push once your tests pass and you are happy with your change(s)::
+
+    $ hg commit -m"<commit message>"
+    $ hg push -b .
+
+6. Finally, submit a pull request through the BitBucket website:
+
+  .. image:: img/pullrequest.png
+     :width: 700px
+     :align: center
+
+  ::
+
+    source: YOUR_BITBUCKET_USERNAME/pytest
+    branch: your-branch-name
+
+    target: hpk42/pytest
+    branch: default
+
+.. _contribution-using-git:
+
+What about git (and so GitHub)?
+-------------------------------
+
+There used to be the pytest GitHub mirror.  It was removed in favor of the
+Mercurial one, to remove confusion of people not knowing where it's better to
+put their issues and pull requests.  Also it wasn't easily possible to automate
+the mirroring process.
+
+However, it's still possible to use git to contribute to pytest using tools
+like `gitifyhg <https://github.com/buchuki/gitifyhg>`_ which allows you to
+clone and work with Mercurial repo still using git.
+
+.. warning::
+  Remember that git is **not** a default version control system for pytest and
+  you need to be careful using it.

HOWTORELEASE.rst

@@ -0,0 +1,47 @@
+
+How to release pytest (draft)
+--------------------------------------------
+
+1. bump version numbers in setup.py and pytest/__init__.py
+
+2. check and finalize CHANGELOG
+
+3. write doc/en/announce/pytest-VERSION.txt and include
+   it in doc/en/announce/index.txt
+
+4. use devpi for uploading a release tarball to a staging area:
+   - ``devpi use https://devpi.net/USER/dev`` 
+   - ``devpi upload``
+
+5. run from multiple machines:
+   - ``devpi use https://devpi.net/USER/dev`` 
+   - ``devpi test pytest-VERSION``
+
+6. check that tests pass for relevant combinations with
+   ``devpi list pytest`` 
+   or look at failures with "devpi list -f pytest".
+   There will be some failed environments like e.g. the py33-trial 
+   or py27-pexpect tox environments on Win32 platforms
+   which is ok (tox does not support skipping on
+   per-platform basis yet).
+
+7. XXX "regen docs" (not easy to do currently as it requires
+   a development version of the regendoc tool from ronny)
+
+8. go to "doc/en" and upload docs with "make install"
+   (the latter requires ssh-login permissions on pytest.org 
+   because it uses rsync).  Note that the "install" target of
+   doc/en/Makefile defines where the rsync goes to, typically
+   to the "latest" section of pytest.org.
+
+9. publish to pypi "devpi push pytest-2.6.2 pypi:NAME" where NAME 
+   is the name of pypi.python.org as configured in your 
+   ~/.pypirc file -- it's the same you would use with 
+   "setup.py upload -r NAME"
+
+10. send release announcement to mailing lists:
+
+   pytest-dev
+   testing-in-python
+   python-announce-list@python.org
+

ISSUES.txt

@@ -1,11 +1,83 @@
-checks / deprecations for next release
----------------------------------------------------------------
-tags: bug 2.4 core xdist
 
-* check oejskit plugin compatibility
-* move pytest_nose out of pylib because it implicitely extends
-  the protocol now - setup/teardown is called at module level.
-  consider making calling of setup/teardown configurable
+
+recorder = monkeypatch.function(".......")
+-------------------------------------------------------------
+tags: nice feature 
+
+Like monkeypatch.replace but sets a mock-like call recorder:
+
+    recorder = monkeypatch.function("os.path.abspath")
+    recorder.set_return("/hello")
+    os.path.abspath("hello")
+    call, = recorder.calls
+    assert call.args.path == "hello"
+    assert call.returned == "/hello"
+    ...
+
+Unlike mock, "args.path" acts on the parsed auto-spec'ed ``os.path.abspath``
+so it's independent from if the client side called "os.path.abspath(path=...)"
+or "os.path.abspath('positional')".
+
+refine parametrize API
+-------------------------------------------------------------
+tags: critical feature 
+
+extend metafunc.parametrize to directly support indirection, example:
+
+    def setupdb(request, config):
+        # 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 dynamic_setup_database(val)
+
+    @pytest.mark.parametrize("db", ["pg", "mysql"], setupfunc=setupdb)
+    def test_heavy_functional_test(db):
+        ...
+
+There would be no need to write or explain funcarg factories and
+their special __ syntax.
+
+The examples and improvements should also show how to put the parametrize
+decorator to a class, to a module or even to a directory.  For the directory
+part a conftest.py content like this::
+
+    pytestmark = [
+        @pytest.mark.parametrize_setup("db", ...),
+    ]
+
+probably makes sense in order to keep the declarative nature.   This mirrors
+the marker-mechanism with respect to a test module but puts it to a directory
+scale.
+
+When doing larger scoped parametrization it probably becomes neccessary 
+to allow parametrization to be ignored if the according parameter is not
+used (currently any parametrized argument that is not present in a function will cause a ValueError). Example:
+
+        @pytest.mark.parametrize("db", ..., mustmatch=False)
+
+means to not raise an error but simply ignore the parametrization
+if the signature of a decorated function does not match. XXX is it
+not sufficient to always allow non-matches?
+
+
+allow parametrized attributes on classes
+-------------------------------------------------- 
+
+tags: wish 2.4
+
+example:
+
+    @pytest.mark.parametrize_attr("db", setupfunc, [1,2,3], scope="class")
+    @pytest.mark.parametrize_attr("tmp", setupfunc, scope="...")
+    class TestMe:
+        def test_hello(self):
+            access self.db ...
+
+this would run the test_hello() function three times with three
+different values for self.db. This could also work with unittest/nose
+style tests, i.e. it leverages existing test suites without needing
+to rewrite them. Together with the previously mentioned setup_test()
+maybe the setupfunc could be ommitted?
 
 optimizations 
 ---------------------------------------------------------------
@@ -25,36 +97,10 @@ appropriately to avoid this issue.  Moreover/Alternatively, we could
 record which implementations of a hook succeeded and only call their
 teardown.
 
-do early-teardown of test modules
------------------------------------------
-tags: feature 2.2
-
-currently teardowns are called when the next tests is setup
-except for the function/method level where interally
-"teardown_exact" tears down immediately.  Generalize
-this to perform the "neccessary" teardown compared to
-the "next" test item during teardown - this should
-get rid of some irritations because otherwise e.g.
-prints of teardown-code appear in the setup of the next test.
-
-consider and document __init__ file usage in test directories
----------------------------------------------------------------
-tags: bug 2.2 core
-
-Currently, a test module is imported with its fully qualified
-package path, determined by checking __init__ files upwards.
-This has the side effect that a source package at the root
-of the test dir could be imported as well.  This is somewhat
-convenient but complicates the picture for running tests against
-different versions of a package.  Also, implicit sys.path
-manipulations are problematic per-se.  Maybe factorting out
-a pytest_addsyspath hook which can be disabled from the command line
-makes sense.  In any case documentation/recommendations for
-certain scenarios makes sense.
 
 relax requirement to have tests/testing contain an __init__
 ----------------------------------------------------------------
-tags: feature 2.2
+tags: feature 
 bb: http://bitbucket.org/hpk42/py-trunk/issue/64
 
 A local test run of a "tests" directory may work
@@ -65,33 +111,33 @@ i.e. port the nose-logic of unloading a test module.
 
 customize test function collection
 -------------------------------------------------------
-tags: feature 2.2
+tags: feature 
 
-- introduce py.test.mark.nocollect for not considering a function for
-  test collection at all.  maybe also introduce a py.test.mark.test to
+- introduce pytest.mark.nocollect for not considering a function for
+  test collection at all.  maybe also introduce a pytest.mark.test to
   explicitely mark a function to become a tested one.  Lookup JUnit ways
   of tagging tests.
 
 introduce pytest.mark.importorskip
 -------------------------------------------------------
-tags: feature 2.2
+tags: feature 
 
 in addition to the imperative pytest.importorskip also introduce
 a pytest.mark.importorskip so that the test count is more correct.
 
 
-introduce py.test.mark.platform
+introduce pytest.mark.platform
 -------------------------------------------------------
-tags: feature 2.2
+tags: feature 
 
 Introduce nice-to-spell platform-skipping, examples:
 
-    @py.test.mark.platform("python3")
-    @py.test.mark.platform("not python3")
-    @py.test.mark.platform("win32 and not python3")
-    @py.test.mark.platform("darwin")
-    @py.test.mark.platform("not (jython and win32)")
-    @py.test.mark.platform("not (jython and win32)", xfail=True)
+    @pytest.mark.platform("python3")
+    @pytest.mark.platform("not python3")
+    @pytest.mark.platform("win32 and not python3")
+    @pytest.mark.platform("darwin")
+    @pytest.mark.platform("not (jython and win32)")
+    @pytest.mark.platform("not (jython and win32)", xfail=True)
 
 etc. Idea is to allow Python expressions which can operate
 on common spellings for operating systems and python
@@ -99,44 +145,36 @@ interpreter versions.
 
 pytest.mark.xfail signature change
 -------------------------------------------------------
-tags: feature 2.2
+tags: feature 
 
 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"?
-
-introduce py.test.mark registration
------------------------------------------
-tags: feature 2.2
-
-introduce a hook that allows to register a named mark decorator
-with documentation and add "py.test --marks" to get
-a list of available marks.  Deprecate "dynamic" mark
-definitions.
+Compatibility? how to introduce a new name/keep compat?
 
 allow to non-intrusively apply skipfs/xfail/marks
 ---------------------------------------------------
-tags: feature 2.2
+tags: feature 
 
 use case: mark a module or directory structures
 to be skipped on certain platforms (i.e. no import
 attempt will be made).
 
 consider introducing a hook/mechanism that allows to apply marks
-from conftests or plugins.
+from conftests or plugins. (See extended parametrization)
+
 
 explicit referencing of conftest.py files
 -----------------------------------------
-tags: feature 2.2
+tags: feature 
 
 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
+improve central pytest ini file
+-------------------------------
+tags: feature 
 
 introduce more declarative configuration options:
 - (to-be-collected test directories)
@@ -147,76 +185,36 @@ introduce more declarative configuration options:
 
 new documentation
 ----------------------------------
-tags: feature 2.2
+tags: feature 
 
-- logo py.test
+- logo pytest
 - 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 
 
-With 1.1.1 py.test fails at least on windows if an import
+With 1.1.1 pytest fails at least on windows if an import
 is relative and compared against an absolute conftest.py
 path. Normalize.
 
-call termination with small timeout
--------------------------------------------------
-tags: feature 2.2
-test: testing/pytest/dist/test_dsession.py - test_terminate_on_hanging_node
-
-Call gateway group termination with a small timeout if available.
-Should make dist-testing less likely to leave lost processes.
-
-consider globals: py.test.ensuretemp and config
+consider globals: pytest.ensuretemp and config
 --------------------------------------------------------------
-tags: experimental-wish 2.2
+tags: experimental-wish 
 
-consider deprecating py.test.ensuretemp and py.test.config
-to further reduce py.test globality.  Also consider
-having py.test.config and ensuretemp coming from
+consider deprecating pytest.ensuretemp and pytest.config
+to further reduce pytest globality.  Also consider
+having pytest.config and ensuretemp coming from
 a plugin rather than being there from the start.
 
-consider allowing funcargs for setup methods
---------------------------------------------------------------
-tags: experimental-wish 2.2
-
-Users have expressed the wish to have funcargs available to setup
-functions.  Experiment with allowing funcargs there - it might
-also help to make the py.test.ensuretemp and config deprecation.
-For filling funcargs for setup methods, we could call funcarg
-factories with a request object that not have a cls/function
-attributes.  However, how to handle parametrized test functions
-and funcargs?
-
-setup_function -> request can be like it is now
-setup_class -> request has no request.function
-setup_module -> request has no request.cls
 
 consider pytest_addsyspath hook
 -----------------------------------------
-tags: 2.2
+tags: wish
 
-py.test could call a new pytest_addsyspath() in order to systematically
+pytest could call a new pytest_addsyspath() in order to systematically
 allow manipulation of sys.path and to inhibit it via --no-addsyspath
 in order to more easily run against installed packages.
 
@@ -224,19 +222,12 @@ Alternatively it could also be done via the config object
 and pytest_configure.
 
 
-show plugin information in test header
+
+deprecate global pytest.config usage
 ----------------------------------------------------------------
-tags: feature 2.2
+tags: feature 
 
-Now that external plugins are becoming more numerous
-it would be useful to have external plugins along with
-their versions displayed as a header line.
-
-deprecate global py.test.config usage
-----------------------------------------------------------------
-tags: feature 2.2
-
-py.test.ensuretemp and py.test.config are probably the last
+pytest.ensuretemp and pytest.config are probably the last
 objects containing global state.  Often using them is not
 neccessary.  This is about trying to get rid of them, i.e.
 deprecating them and checking with PyPy's usages as well
@@ -244,9 +235,130 @@ as others.
 
 remove deprecated bits in collect.py
 -------------------------------------------------------------------
-tags: feature 2.2
+tags: feature 
 
 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 
+
+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.findone("test_*.py")
+    result = pytester.runpytest(p)
+    assert result.ret == 0
+    assert result.passed == 1
+
+Another idea is to allow to define a full scenario including the run
+in one content string::
+
+    runscenario("""
+        test_{TESTNAME}.py:
+            import pytest
+            @pytest.mark.xfail
+            def test_that_fails():
+                assert 0
+
+            @pytest.mark.skipif("True")
+            def test_hello():
+                pass
+
+        conftest.py:
+            import pytest
+            def pytest_runsetup_setup(item):
+                pytest.skip("abc")
+
+        runpytest -rsxX
+        *SKIP*{TESTNAME}*
+        *1 skipped* 
+    """)
+
+This could be run with at least three different ways to invoke pytest:
+through the shell, through "python -m pytest" and inlined. As inlined
+would be the fastest it could be run first (or "--fast" mode).
+
+
+Create isolate plugin
+---------------------
+tags: feature
+
+The idea is that you can e.g. import modules in a test and afterwards
+sys.modules, sys.meta_path etc would be reverted.  It can go further
+then just importing however, e.g. current working direcroty, file
+descriptors, ...
+
+This would probably be done by marking::
+
+    @pytest.mark.isolate(importing=True, cwd=True, fds=False)
+    def test_foo():
+        ...
+
+With the possibility of doing this globally in an ini-file.
+
+
+fnmatch for test names
+----------------------
+tags: feature-wish
+
+various testsuites use suffixes instead of prefixes for test classes
+also it lends itself to bdd style test names::
+
+    class UserBehaviour:
+        def anonymous_should_not_have_inbox(user):
+            ...
+        def registred_should_have_inbox(user):
+            ..
+
+using the following in pytest.ini::
+
+    [pytest]
+    python_classes = Test *Behaviour *Test
+    python_functions = test *_should_*
+
+
+mechanism for running named parts of tests with different reporting behaviour
+------------------------------------------------------------------------------
+tags: feature-wish-incomplete
+
+a few use-cases come to mind:
+
+* fail assertions and record that without stopping a complete test
+
+  * this is in particular hepfull if a small bit of a test is known to fail/xfail::
+
+    def test_fun():
+        with pytest.section('fdcheck, marks=pytest.mark.xfail_if(...)):
+            breaks_on_windows()
+
+* divide functional/acceptance tests into sections
+* provide a different mechanism for generators, maybe something like::
+
+    def pytest_runtest_call(item)
+        if not generator:
+            ...
+        prepare_check = GeneratorCheckprepare()
+
+        gen = item.obj(**fixtures)
+        for check in gen
+            id, call = prepare_check(check)
+            # bubble should only prevent exception propagation after a failure
+            # the whole test should still fail
+            # there might be need for a loer level api and taking custom markers into account
+            with pytest.section(id, bubble=False):
+                call()
+
+

MANIFEST.in

@@ -1,7 +1,7 @@
 include CHANGELOG
-include README.txt
+include README.rst
 include setup.py
-include distribute_setup.py
+include tox.ini
 include LICENSE
 graft doc
 graft testing

README.rst

@@ -0,0 +1,55 @@
+.. image:: https://drone.io/bitbucket.org/hpk42/pytest/status.png
+   :target: https://drone.io/bitbucket.org/hpk42/pytest/latest
+.. image:: https://pypip.in/v/pytest/badge.png
+   :target: https://crate.io/packages/pytest/
+
+Documentation: http://pytest.org/latest/
+
+Changelog: http://pytest.org/latest/changelog.html
+
+Issues: https://bitbucket.org/hpk42/pytest/issues?status=open
+
+CI: https://drone.io/bitbucket.org/hpk42/pytest
+
+The ``pytest`` testing tool makes it easy to write small tests, yet
+scales to support complex functional testing.  It provides
+
+- `auto-discovery
+  <http://pytest.org/latest/goodpractises.html#python-test-discovery>`_
+  of test modules and functions,
+- detailed info on failing `assert statements <http://pytest.org/latest/assert.html>`_ (no need to remember ``self.assert*`` names)
+- `modular fixtures <http://pytest.org/latest/fixture.html>`_  for
+  managing small or parametrized long-lived test resources.
+- multi-paradigm support: you can use ``pytest`` to run test suites based
+  on `unittest <http://pytest.org/latest/unittest.html>`_ (or trial),
+  `nose <http://pytest.org/latest/nose.html>`_
+- single-source compatibility from Python2.6 all the way up to
+  Python3.4, PyPy-2.3, (jython-2.5 untested)
+
+
+- many `external plugins <http://pytest.org/latest/plugins.html#installing-external-plugins-searching>`_.
+
+A simple example for a test::
+
+    # content of test_module.py
+    def test_function():
+        i = 4
+        assert i == 3
+
+which can be run with ``py.test test_module.py``.  See `getting-started <http://pytest.org/latest/getting-started.html#our-first-test-run>`_ for more examples.
+
+For much more info, including PDF docs, see
+
+    http://pytest.org
+
+and report bugs at:
+
+    http://bitbucket.org/hpk42/pytest/issues/
+
+and checkout or fork repo at:
+
+    http://bitbucket.org/hpk42/pytest/
+
+
+Copyright Holger Krekel and others, 2004-2014
+Licensed under the MIT license.

README.txt

@@ -1,4 +0,0 @@
-py.test is a simple and popular testing tool for Python.
-
-See http://pytest.org for more documentation.
-

_pytest/__init__.py

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

_pytest/_argcomplete.py

@@ -0,0 +1,104 @@
+
+"""allow bash-completion for argparse with argcomplete if installed
+needs argcomplete>=0.5.6 for python 3.2/3.3 (older versions fail
+to find the magic string, so _ARGCOMPLETE env. var is never set, and
+this does not need special code.
+
+argcomplete does not support python 2.5 (although the changes for that
+are minor).
+
+Function try_argcomplete(parser) should be called directly before
+the call to ArgumentParser.parse_args().
+
+The filescompleter is what you normally would use on the positional
+arguments specification, in order to get "dirname/" after "dirn<TAB>"
+instead of the default "dirname ":
+
+   optparser.add_argument(Config._file_or_dir, nargs='*'
+                               ).completer=filescompleter
+
+Other, application specific, completers should go in the file
+doing the add_argument calls as they need to be specified as .completer
+attributes as well. (If argcomplete is not installed, the function the
+attribute points to will not be used).
+
+SPEEDUP
+=======
+The generic argcomplete script for bash-completion
+(/etc/bash_completion.d/python-argcomplete.sh )
+uses a python program to determine startup script generated by pip.
+You can speed up completion somewhat by changing this script to include
+  # PYTHON_ARGCOMPLETE_OK
+so the the python-argcomplete-check-easy-install-script does not
+need to be called to find the entry point of the code and see if that is
+marked  with PYTHON_ARGCOMPLETE_OK
+
+INSTALL/DEBUGGING
+=================
+To include this support in another application that has setup.py generated
+scripts:
+- add the line:
+    # PYTHON_ARGCOMPLETE_OK
+  near the top of the main python entry point
+- include in the file calling parse_args():
+    from _argcomplete import try_argcomplete, filescompleter
+   , call try_argcomplete just before parse_args(), and optionally add
+   filescompleter to the positional arguments' add_argument()
+If things do not work right away:
+- switch on argcomplete debugging with (also helpful when doing custom
+  completers):
+    export _ARC_DEBUG=1
+- run:
+    python-argcomplete-check-easy-install-script $(which appname)
+    echo $?
+  will echo 0 if the magic line has been found, 1 if not
+- sometimes it helps to find early on errors using:
+    _ARGCOMPLETE=1 _ARC_DEBUG=1 appname
+  which should throw a KeyError: 'COMPLINE' (which is properly set by the
+  global argcomplete script).
+"""
+
+import sys
+import os
+from glob import glob
+
+class FastFilesCompleter:
+    'Fast file completer class'
+    def __init__(self, directories=True):
+        self.directories = directories
+
+    def __call__(self, prefix, **kwargs):
+        """only called on non option completions"""
+        if os.path.sep in prefix[1:]: #
+            prefix_dir = len(os.path.dirname(prefix) + os.path.sep)
+        else:
+            prefix_dir = 0
+        completion = []
+        globbed = []
+        if '*' not in prefix and '?' not in prefix:
+            if prefix[-1] == os.path.sep:  # we are on unix, otherwise no bash
+                globbed.extend(glob(prefix + '.*'))
+            prefix += '*'
+        globbed.extend(glob(prefix))
+        for x in sorted(globbed):
+            if os.path.isdir(x):
+                x += '/'
+            # append stripping the prefix (like bash, not like compgen)
+            completion.append(x[prefix_dir:])
+        return completion
+
+if os.environ.get('_ARGCOMPLETE'):
+    # argcomplete 0.5.6 is not compatible with python 2.5.6: print/with/format
+    if sys.version_info[:2] < (2, 6):
+        sys.exit(1)
+    try:
+        import argcomplete.completers
+    except ImportError:
+        sys.exit(-1)
+    filescompleter = FastFilesCompleter()
+
+    def try_argcomplete(parser):
+        argcomplete.autocomplete(parser)
+else:
+    def try_argcomplete(parser): pass
+    filescompleter = None

_pytest/assertion/__init__.py

@@ -3,24 +3,35 @@ support for presenting detailed information in failing assertions.
 """
 import py
 import sys
-import pytest
 from _pytest.monkeypatch import monkeypatch
 from _pytest.assertion import util
 
+
 def pytest_addoption(parser):
     group = parser.getgroup("debugconfig")
-    group.addoption('--assert', action="store", dest="assertmode",
+    group.addoption('--assert',
+                    action="store",
+                    dest="assertmode",
                     choices=("rewrite", "reinterp", "plain",),
-                    default="rewrite", metavar="MODE",
-                    help="""control assertion debugging tools.
-'plain' performs no assertion debugging.
-'reinterp' reinterprets assert statements after they failed to provide assertion expression information.
-'rewrite' (the default) rewrites assert statements in test modules on import
-to provide assert expression information. """)
-    group.addoption('--no-assert', action="store_true", default=False,
-        dest="noassert", help="DEPRECATED equivalent to --assert=plain")
-    group.addoption('--nomagic', action="store_true", default=False,
-        dest="nomagic", help="DEPRECATED equivalent to --assert=plain")
+                    default="rewrite",
+                    metavar="MODE",
+                    help="""control assertion debugging tools.  'plain'
+                            performs no assertion debugging.  'reinterp'
+                            reinterprets assert statements after they failed
+                            to provide assertion expression information.
+                            'rewrite' (the default) rewrites assert
+                            statements in test modules on import to
+                            provide assert expression information. """)
+    group.addoption('--no-assert',
+                    action="store_true",
+                    default=False,
+                    dest="noassert",
+                    help="DEPRECATED equivalent to --assert=plain")
+    group.addoption('--nomagic', '--no-magic',
+                    action="store_true",
+                    default=False,
+                    help="DEPRECATED equivalent to --assert=plain")
+
 
 class AssertionState:
     """State for the assertion plugin."""
@@ -29,38 +40,44 @@ class AssertionState:
         self.mode = mode
         self.trace = config.trace.root.get("assertion")
 
+
 def pytest_configure(config):
     mode = config.getvalue("assertmode")
     if config.getvalue("noassert") or config.getvalue("nomagic"):
         mode = "plain"
     if mode == "rewrite":
         try:
-            import ast
+            import ast  # noqa
         except ImportError:
             mode = "reinterp"
         else:
-            if sys.platform.startswith('java'):
+            # Both Jython and CPython 2.6.0 have AST bugs that make the
+            # assertion rewriting hook malfunction.
+            if (sys.platform.startswith('java') or
+                    sys.version_info[:3] == (2, 6, 0)):
                 mode = "reinterp"
     if mode != "plain":
         _load_modules(mode)
         m = monkeypatch()
         config._cleanup.append(m.undo)
         m.setattr(py.builtin.builtins, 'AssertionError',
-                  reinterpret.AssertionError)
+                  reinterpret.AssertionError)  # noqa
     hook = None
     if mode == "rewrite":
-        hook = rewrite.AssertionRewritingHook()
-        sys.meta_path.append(hook)
+        hook = rewrite.AssertionRewritingHook()  # noqa
+        sys.meta_path.insert(0, hook)
     warn_about_missing_assertion(mode)
     config._assertstate = AssertionState(config, mode)
     config._assertstate.hook = hook
     config._assertstate.trace("configured with mode set to %r" % (mode,))
 
+
 def pytest_unconfigure(config):
     hook = config._assertstate.hook
-    if hook is not None:
+    if hook is not None and hook in sys.meta_path:
         sys.meta_path.remove(hook)
 
+
 def pytest_collection(session):
     # this hook is only called when test modules are collected
     # so for example not in the master process of pytest-xdist
@@ -69,35 +86,62 @@ def pytest_collection(session):
     if hook is not None:
         hook.set_session(session)
 
+
 def pytest_runtest_setup(item):
+    """Setup the pytest_assertrepr_compare hook
+
+    The newinterpret and rewrite modules will use util._reprcompare if
+    it exists to use custom reporting via the
+    pytest_assertrepr_compare hook.  This sets up this custom
+    comparison for the test.
+    """
     def callbinrepr(op, left, right):
+        """Call the pytest_assertrepr_compare hook and prepare the result
+
+        This uses the first result from the hook and then ensures the
+        following:
+        * Overly verbose explanations are dropped unles -vv was used.
+        * Embedded newlines are escaped to help util.format_explanation()
+          later.
+        * If the rewrite mode is used embedded %-characters are replaced
+          to protect later % formatting.
+
+        The result can be formatted by util.format_explanation() for
+        pretty printing.
+        """
         hook_result = item.ihook.pytest_assertrepr_compare(
             config=item.config, op=op, left=left, right=right)
         for new_expl in hook_result:
             if new_expl:
-                res = '\n~'.join(new_expl)
+                if (sum(len(p) for p in new_expl[1:]) > 80*8
+                        and item.config.option.verbose < 2):
+                    new_expl[1:] = [py.builtin._totext(
+                        'Detailed information truncated, use "-vv" to show')]
+                new_expl = [line.replace("\n", "\\n") for line in new_expl]
+                res = py.builtin._totext("\n~").join(new_expl)
                 if item.config.getvalue("assertmode") == "rewrite":
-                    # The result will be fed back a python % formatting
-                    # operation, which will fail if there are extraneous
-                    # '%'s in the string. Escape them here.
                     res = res.replace("%", "%%")
                 return res
     util._reprcompare = callbinrepr
 
+
 def pytest_runtest_teardown(item):
     util._reprcompare = None
 
+
 def pytest_sessionfinish(session):
     hook = session.config._assertstate.hook
     if hook is not None:
         hook.session = None
 
+
 def _load_modules(mode):
     """Lazily import assertion related code."""
     global rewrite, reinterpret
-    from _pytest.assertion import reinterpret
+    from _pytest.assertion import reinterpret  # noqa
     if mode == "rewrite":
-        from _pytest.assertion import rewrite
+        from _pytest.assertion import rewrite  # noqa
+
 
 def warn_about_missing_assertion(mode):
     try:
@@ -112,8 +156,10 @@ def warn_about_missing_assertion(mode):
             specifically = "failing tests may report as passing"
 
         sys.stderr.write("WARNING: " + specifically +
-                        " because assert statements are not executed "
-                        "by the underlying Python interpreter "
-                        "(are you using python -O?)\n")
+                         " because assert statements are not executed "
+                         "by the underlying Python interpreter "
+                         "(are you using python -O?)\n")
 
+
+# Expose this plugin's implementation for the pytest_assertrepr_compare hook
 pytest_assertrepr_compare = util.assertrepr_compare

_pytest/assertion/newinterpret.py

@@ -11,7 +11,7 @@ from _pytest.assertion import util
 from _pytest.assertion.reinterpret import BuiltinAssertionError
 
 
-if sys.platform.startswith("java") and sys.version_info < (2, 5, 2):
+if sys.platform.startswith("java"):
     # See http://bugs.jython.org/issue1497
     _exprs = ("BoolOp", "BinOp", "UnaryOp", "Lambda", "IfExp", "Dict",
               "ListComp", "GeneratorExp", "Yield", "Compare", "Call",
@@ -286,7 +286,19 @@ class DebugInterpreter(ast.NodeVisitor):
         source = "__exprinfo_expr.%s" % (attr.attr,)
         co = self._compile(source)
         try:
-            result = self.frame.eval(co, __exprinfo_expr=source_result)
+            try:
+                result = self.frame.eval(co, __exprinfo_expr=source_result)
+            except AttributeError:
+                # Maybe the attribute name needs to be mangled?
+                if not attr.attr.startswith("__") or attr.attr.endswith("__"):
+                    raise
+                source = "getattr(__exprinfo_expr.__class__, '__name__', '')"
+                co = self._compile(source)
+                class_name = self.frame.eval(co, __exprinfo_expr=source_result)
+                mangled_attr = "_" + class_name +  attr.attr
+                source = "__exprinfo_expr.%s" % (mangled_attr,)
+                co = self._compile(source)
+                result = self.frame.eval(co, __exprinfo_expr=source_result)
         except Exception:
             raise Failure(explanation)
         explanation = "%s\n{%s = %s.%s\n}" % (self.frame.repr(result),

_pytest/assertion/oldinterpret.py

@@ -1,8 +1,9 @@
+import traceback
+import types
 import py
 import sys, inspect
 from compiler import parse, ast, pycodegen
-from _pytest.assertion.util import format_explanation
-from _pytest.assertion.reinterpret import BuiltinAssertionError
+from _pytest.assertion.util import format_explanation, BuiltinAssertionError
 
 passthroughex = py.builtin._sysex
 
@@ -56,7 +57,7 @@ class View(object):
     def __getattr__(self, attr):
         # attributes not found in the normal hierarchy rooted on View
         # are looked up in the object's real class
-        return getattr(self.__obj__, attr)
+        return getattr(object.__getattribute__(self, '__obj__'), attr)
 
     def __viewkey__(self):
         return self.__obj__.__class__
@@ -356,7 +357,18 @@ class Getattr(Interpretable):
         expr.eval(frame)
         source = '__exprinfo_expr.%s' % self.attrname
         try:
-            self.result = frame.eval(source, __exprinfo_expr=expr.result)
+            try:
+                self.result = frame.eval(source, __exprinfo_expr=expr.result)
+            except AttributeError:
+                # Maybe the attribute name needs to be mangled?
+                if (not self.attrname.startswith("__") or
+                    self.attrname.endswith("__")):
+                    raise
+                source = "getattr(__exprinfo_expr.__class__, '__name__', '')"
+                class_name = frame.eval(source, __exprinfo_expr=expr.result)
+                mangled_attr = "_" + class_name +  self.attrname
+                source = "__exprinfo_expr.%s" % (mangled_attr,)
+                self.result = frame.eval(source, __exprinfo_expr=expr.result)
         except passthroughex:
             raise
         except:
@@ -467,7 +479,7 @@ def check(s, frame=None):
 def interpret(source, frame, should_fail=False):
     module = Interpretable(parse(source, 'exec').node)
     #print "got module", module
-    if isinstance(frame, py.std.types.FrameType):
+    if isinstance(frame, types.FrameType):
         frame = py.code.Frame(frame)
     try:
         module.run(frame)
@@ -477,7 +489,6 @@ def interpret(source, frame, should_fail=False):
     except passthroughex:
         raise
     except:
-        import traceback
         traceback.print_exc()
     if should_fail:
         return ("(assertion failed, but when it was re-run for "
@@ -527,10 +538,13 @@ if __name__ == '__main__':
     # example:
     def f():
         return 5
+
     def g():
         return 3
+
     def h(x):
         return 'never'
+
     check("f() * g() == 5")
     check("not f()")
     check("not (f() and g() or 0)")

_pytest/assertion/reinterpret.py

@@ -1,19 +1,26 @@
 import sys
 import py
+from _pytest.assertion.util import BuiltinAssertionError
+u = py.builtin._totext
 
-BuiltinAssertionError = py.builtin.builtins.AssertionError
 
 class AssertionError(BuiltinAssertionError):
     def __init__(self, *args):
         BuiltinAssertionError.__init__(self, *args)
         if args:
+            # on Python2.6 we get len(args)==2 for: assert 0, (x,y)
+            # on Python2.7 and above we always get len(args) == 1
+            # with args[0] being the (x,y) tuple.
+            if len(args) > 1:
+                toprint = args
+            else:
+                toprint = args[0]
             try:
-                self.msg = str(args[0])
-            except py.builtin._sysex:
-                raise
-            except:
-                self.msg = "<[broken __repr__] %s at %0xd>" %(
-                    args[0].__class__, id(args[0]))
+                self.msg = u(toprint)
+            except Exception:
+                self.msg = u(
+                    "<[broken __repr__] %s at %0xd>"
+                    % (toprint.__class__, id(toprint)))
         else:
             f = py.code.Frame(sys._getframe(1))
             try:
@@ -38,11 +45,8 @@ class AssertionError(BuiltinAssertionError):
 
 if sys.version_info > (3, 0):
     AssertionError.__module__ = "builtins"
-    reinterpret_old = "old reinterpretation not available for py3"
-else:
-    from _pytest.assertion.oldinterpret import interpret as reinterpret_old
-if sys.version_info >= (2, 6) or (sys.platform.startswith("java")):
+
+if sys.version_info >= (2, 6) or sys.platform.startswith("java"):
     from _pytest.assertion.newinterpret import interpret as reinterpret
 else:
-    reinterpret = reinterpret_old
-
+    from _pytest.assertion.oldinterpret import interpret as reinterpret

_pytest/assertion/rewrite.py

@@ -1,12 +1,12 @@
 """Rewrite assertion AST to produce nice error messages"""
 
 import ast
-import collections
 import errno
 import itertools
 import imp
 import marshal
 import os
+import re
 import struct
 import sys
 import types
@@ -15,13 +15,7 @@ import py
 from _pytest.assertion import util
 
 
-# Windows gives ENOENT in places *nix gives ENOTDIR.
-if sys.platform.startswith("win"):
-    PATH_COMPONENT_NOT_DIR = errno.ENOENT
-else:
-    PATH_COMPONENT_NOT_DIR = errno.ENOTDIR
-
-# py.test caches rewritten pycs in __pycache__.
+# pytest caches rewritten pycs in __pycache__.
 if hasattr(imp, "get_tag"):
     PYTEST_TAG = imp.get_tag() + "-PYTEST"
 else:
@@ -35,17 +29,19 @@ else:
     PYTEST_TAG = "%s-%s%s-PYTEST" % (impl, ver[0], ver[1])
     del ver, impl
 
-PYC_EXT = ".py" + "c" if __debug__ else "o"
+PYC_EXT = ".py" + (__debug__ and "c" or "o")
 PYC_TAIL = "." + PYTEST_TAG + PYC_EXT
 
 REWRITE_NEWLINES = sys.version_info[:2] != (2, 7) and sys.version_info < (3, 2)
+ASCII_IS_DEFAULT_ENCODING = sys.version_info[0] < 3
 
 class AssertionRewritingHook(object):
-    """Import hook which rewrites asserts."""
+    """PEP302 Import hook which rewrites asserts."""
 
     def __init__(self):
         self.session = None
         self.modules = {}
+        self._register_with_pkg_resources()
 
     def set_session(self, session):
         self.fnpats = session.config.getini("python_files")
@@ -60,8 +56,12 @@ class AssertionRewritingHook(object):
         names = name.rsplit(".", 1)
         lastname = names[-1]
         pth = None
-        if path is not None and len(path) == 1:
-            pth = path[0]
+        if path is not None:
+            # Starting with Python 3.3, path is a _NamespacePath(), which
+            # causes problems if not converted to list.
+            path = list(path)
+            if len(path) == 1:
+                pth = path[0]
         if pth is None:
             try:
                 fd, fn, desc = imp.find_module(lastname, path)
@@ -96,12 +96,13 @@ class AssertionRewritingHook(object):
             finally:
                 self.session = sess
         else:
-            state.trace("matched test file (was specified on cmdline): %r" % (fn,))
+            state.trace("matched test file (was specified on cmdline): %r" %
+                        (fn,))
         # The requested module looks like a test file, so rewrite it. This is
         # the most magical part of the process: load the source, rewrite the
         # asserts, and load the rewritten source. We also cache the rewritten
         # module code in a special pyc. We must be aware of the possibility of
-        # concurrent py.test processes rewriting and loading pycs. To avoid
+        # concurrent pytest processes rewriting and loading pycs. To avoid
         # tricky race conditions, we maintain the following invariant: The
         # cached pyc is always a complete, valid pyc. Operations on it must be
         # atomic. POSIX's atomic rename comes in handy.
@@ -117,28 +118,28 @@ class AssertionRewritingHook(object):
                     # common case) or it's blocked by a non-dir node. In the
                     # latter case, we'll ignore it in _write_pyc.
                     pass
-                elif e == PATH_COMPONENT_NOT_DIR:
+                elif e in [errno.ENOENT, errno.ENOTDIR]:
                     # One of the path components was not a directory, likely
                     # because we're in a zip file.
                     write = False
                 elif e == errno.EACCES:
-                    state.trace("read only directory: %r" % (fn_pypath.dirname,))
+                    state.trace("read only directory: %r" % fn_pypath.dirname)
                     write = False
                 else:
                     raise
         cache_name = fn_pypath.basename[:-3] + PYC_TAIL
         pyc = os.path.join(cache_dir, cache_name)
-        # Notice that even if we're in a read-only directory, I'm going to check
-        # for a cached pyc. This may not be optimal...
-        co = _read_pyc(fn_pypath, pyc)
+        # Notice that even if we're in a read-only directory, I'm going
+        # to check for a cached pyc. This may not be optimal...
+        co = _read_pyc(fn_pypath, pyc, state.trace)
         if co is None:
             state.trace("rewriting %r" % (fn,))
-            co = _rewrite_test(state, fn_pypath)
+            source_stat, co = _rewrite_test(state, fn_pypath)
             if co is None:
                 # Probably a SyntaxError in the test.
                 return None
             if write:
-                _make_rewritten_pyc(state, fn_pypath, pyc, co)
+                _make_rewritten_pyc(state, source_stat, pyc, co)
         else:
             state.trace("found cached rewritten pyc for %r" % (fn,))
         self.modules[name] = co, pyc
@@ -154,30 +155,63 @@ class AssertionRewritingHook(object):
             mod.__file__ = co.co_filename
             # Normally, this attribute is 3.2+.
             mod.__cached__ = pyc
+            mod.__loader__ = self
             py.builtin.exec_(co, mod.__dict__)
         except:
             del sys.modules[name]
             raise
         return sys.modules[name]
 
-def _write_pyc(co, source_path, pyc):
-    # Technically, we don't have to have the same pyc format as (C)Python, since
-    # these "pycs" should never be seen by builtin import. However, there's
-    # little reason deviate, and I hope sometime to be able to use
-    # imp.load_compiled to load them. (See the comment in load_module above.)
-    mtime = int(source_path.mtime())
+
+
+    def is_package(self, name):
+        try:
+            fd, fn, desc = imp.find_module(name)
+        except ImportError:
+            return False
+        if fd is not None:
+            fd.close()
+        tp = desc[2]
+        return tp == imp.PKG_DIRECTORY
+
+    @classmethod
+    def _register_with_pkg_resources(cls):
+        """
+        Ensure package resources can be loaded from this loader. May be called
+        multiple times, as the operation is idempotent.
+        """
+        try:
+            import pkg_resources
+            # access an attribute in case a deferred importer is present
+            pkg_resources.__name__
+        except ImportError:
+            return
+
+        # Since pytest tests are always located in the file system, the
+        #  DefaultProvider is appropriate.
+        pkg_resources.register_loader_type(cls, pkg_resources.DefaultProvider)
+
+
+def _write_pyc(state, co, source_stat, pyc):
+    # Technically, we don't have to have the same pyc format as
+    # (C)Python, since these "pycs" should never be seen by builtin
+    # import. However, there's little reason deviate, and I hope
+    # sometime to be able to use imp.load_compiled to load them. (See
+    # the comment in load_module above.)
     try:
         fp = open(pyc, "wb")
     except IOError:
         err = sys.exc_info()[1].errno
-        if err == PATH_COMPONENT_NOT_DIR:
-            # This happens when we get a EEXIST in find_module creating the
-            # __pycache__ directory and __pycache__ is by some non-dir node.
-            return False
-        raise
+        state.trace("error writing pyc file at %s: errno=%s" %(pyc, err))
+        # we ignore any failure to write the cache file
+        # there are many reasons, permission-denied, __pycache__ being a
+        # file etc.
+        return False
     try:
         fp.write(imp.get_magic())
-        fp.write(struct.pack("<l", mtime))
+        mtime = int(source_stat.mtime)
+        size = source_stat.size & 0xFFFFFFFF
+        fp.write(struct.pack("<ll", mtime, size))
         marshal.dump(co, fp)
     finally:
         fp.close()
@@ -186,12 +220,45 @@ def _write_pyc(co, source_path, pyc):
 RN = "\r\n".encode("utf-8")
 N = "\n".encode("utf-8")
 
+cookie_re = re.compile(r"^[ \t\f]*#.*coding[:=][ \t]*[-\w.]+")
+BOM_UTF8 = '\xef\xbb\xbf'
+
 def _rewrite_test(state, fn):
     """Try to read and rewrite *fn* and return the code object."""
     try:
+        stat = fn.stat()
         source = fn.read("rb")
     except EnvironmentError:
-        return None
+        return None, None
+    if ASCII_IS_DEFAULT_ENCODING:
+        # ASCII is the default encoding in Python 2. Without a coding
+        # declaration, Python 2 will complain about any bytes in the file
+        # outside the ASCII range. Sadly, this behavior does not extend to
+        # compile() or ast.parse(), which prefer to interpret the bytes as
+        # latin-1. (At least they properly handle explicit coding cookies.) To
+        # preserve this error behavior, we could force ast.parse() to use ASCII
+        # as the encoding by inserting a coding cookie. Unfortunately, that
+        # messes up line numbers. Thus, we have to check ourselves if anything
+        # is outside the ASCII range in the case no encoding is explicitly
+        # declared. For more context, see issue #269. Yay for Python 3 which
+        # gets this right.
+        end1 = source.find("\n")
+        end2 = source.find("\n", end1 + 1)
+        if (not source.startswith(BOM_UTF8) and
+            cookie_re.match(source[0:end1]) is None and
+            cookie_re.match(source[end1 + 1:end2]) is None):
+            if hasattr(state, "_indecode"):
+                # encodings imported us again, so don't rewrite.
+                return None, None
+            state._indecode = True
+            try:
+                try:
+                    source.decode("ascii")
+                except UnicodeDecodeError:
+                    # Let it fail in real import.
+                    return None, None
+            finally:
+                del state._indecode
     # On Python versions which are not 2.7 and less than or equal to 3.1, the
     # parser expects *nix newlines.
     if REWRITE_NEWLINES:
@@ -201,7 +268,7 @@ def _rewrite_test(state, fn):
     except SyntaxError:
         # Let this pop up again in the real import.
         state.trace("failed to parse: %r" % (fn,))
-        return None
+        return None, None
     rewrite_asserts(tree)
     try:
         co = compile(tree, fn.strpath, "exec")
@@ -209,24 +276,24 @@ def _rewrite_test(state, fn):
         # It's possible that this error is from some bug in the
         # assertion rewriting, but I don't know of a fast way to tell.
         state.trace("failed to compile: %r" % (fn,))
-        return None
-    return co
+        return None, None
+    return stat, co
 
-def _make_rewritten_pyc(state, fn, pyc, co):
+def _make_rewritten_pyc(state, source_stat, pyc, co):
     """Try to dump rewritten code to *pyc*."""
     if sys.platform.startswith("win"):
         # Windows grants exclusive access to open files and doesn't have atomic
         # rename, so just write into the final file.
-        _write_pyc(co, fn, pyc)
+        _write_pyc(state, co, source_stat, pyc)
     else:
         # When not on windows, assume rename is atomic. Dump the code object
         # into a file specific to this process and atomically replace it.
         proc_pyc = pyc + "." + str(os.getpid())
-        if _write_pyc(co, fn, proc_pyc):
+        if _write_pyc(state, co, source_stat, proc_pyc):
             os.rename(proc_pyc, pyc)
 
-def _read_pyc(source, pyc):
-    """Possibly read a py.test pyc containing rewritten code.
+def _read_pyc(source, pyc, trace=lambda x: None):
+    """Possibly read a pytest pyc containing rewritten code.
 
     Return rewritten code if successful or None if not.
     """
@@ -234,24 +301,28 @@ def _read_pyc(source, pyc):
         fp = open(pyc, "rb")
     except IOError:
         return None
-    try:
+    with fp:
         try:
             mtime = int(source.mtime())
-            data = fp.read(8)
-        except EnvironmentError:
+            size = source.size()
+            data = fp.read(12)
+        except EnvironmentError as e:
+            trace('_read_pyc(%s): EnvironmentError %s' % (source, e))
             return None
         # Check for invalid or out of date pyc file.
-        if (len(data) != 8 or
-            data[:4] != imp.get_magic() or
-            struct.unpack("<l", data[4:])[0] != mtime):
+        if (len(data) != 12 or data[:4] != imp.get_magic() or
+                struct.unpack("<ll", data[4:]) != (mtime, size)):
+            trace('_read_pyc(%s): invalid or out of date pyc' % source)
+            return None
+        try:
+            co = marshal.load(fp)
+        except Exception as e:
+            trace('_read_pyc(%s): marshal.load error %s' % (source, e))
             return None
-        co = marshal.load(fp)
         if not isinstance(co, types.CodeType):
-            # That's interesting....
+            trace('_read_pyc(%s): not a code object' % source)
             return None
         return co
-    finally:
-        fp.close()
 
 
 def rewrite_asserts(mod):
@@ -259,8 +330,56 @@ def rewrite_asserts(mod):
     AssertionRewriter().run(mod)
 
 
-_saferepr = py.io.saferepr
-from _pytest.assertion.util import format_explanation as _format_explanation
+def _saferepr(obj):
+    """Get a safe repr of an object for assertion error messages.
+
+    The assertion formatting (util.format_explanation()) requires
+    newlines to be escaped since they are a special character for it.
+    Normally assertion.util.format_explanation() does this but for a
+    custom repr it is possible to contain one of the special escape
+    sequences, especially '\n{' and '\n}' are likely to be present in
+    JSON reprs.
+
+    """
+    repr = py.io.saferepr(obj)
+    if py.builtin._istext(repr):
+        t = py.builtin.text
+    else:
+        t = py.builtin.bytes
+    return repr.replace(t("\n"), t("\\n"))
+
+
+from _pytest.assertion.util import format_explanation as _format_explanation # noqa
+
+def _format_assertmsg(obj):
+    """Format the custom assertion message given.
+
+    For strings this simply replaces newlines with '\n~' so that
+    util.format_explanation() will preserve them instead of escaping
+    newlines.  For other objects py.io.saferepr() is used first.
+
+    """
+    # reprlib appears to have a bug which means that if a string
+    # contains a newline it gets escaped, however if an object has a
+    # .__repr__() which contains newlines it does not get escaped.
+    # However in either case we want to preserve the newline.
+    if py.builtin._istext(obj) or py.builtin._isbytes(obj):
+        s = obj
+        is_repr = False
+    else:
+        s = py.io.saferepr(obj)
+        is_repr = True
+    if py.builtin._istext(s):
+        t = py.builtin.text
+    else:
+        t = py.builtin.bytes
+    s = s.replace(t("\n"), t("\n~"))
+    if is_repr:
+        s = s.replace(t("\\n"), t("\n~"))
+    return s
+
+def _should_repr_global_name(obj):
+    return not hasattr(obj, "__name__") and not py.builtin.callable(obj)
 
 def _format_boolop(explanations, is_or):
     return "(" + (is_or and " or " or " and ").join(explanations) + ")"
@@ -281,35 +400,35 @@ def _call_reprcompare(ops, results, expls, each_obj):
 
 
 unary_map = {
-    ast.Not : "not %s",
-    ast.Invert : "~%s",
-    ast.USub : "-%s",
-    ast.UAdd : "+%s"
+    ast.Not: "not %s",
+    ast.Invert: "~%s",
+    ast.USub: "-%s",
+    ast.UAdd: "+%s"
 }
 
 binop_map = {
-    ast.BitOr : "|",
-    ast.BitXor : "^",
-    ast.BitAnd : "&",
-    ast.LShift : "<<",
-    ast.RShift : ">>",
-    ast.Add : "+",
-    ast.Sub : "-",
-    ast.Mult : "*",
-    ast.Div : "/",
-    ast.FloorDiv : "//",
-    ast.Mod : "%",
-    ast.Eq : "==",
-    ast.NotEq : "!=",
-    ast.Lt : "<",
-    ast.LtE : "<=",
-    ast.Gt : ">",
-    ast.GtE : ">=",
-    ast.Pow : "**",
-    ast.Is : "is",
-    ast.IsNot : "is not",
-    ast.In : "in",
-    ast.NotIn : "not in"
+    ast.BitOr: "|",
+    ast.BitXor: "^",
+    ast.BitAnd: "&",
+    ast.LShift: "<<",
+    ast.RShift: ">>",
+    ast.Add: "+",
+    ast.Sub: "-",
+    ast.Mult: "*",
+    ast.Div: "/",
+    ast.FloorDiv: "//",
+    ast.Mod: "%%", # escaped for string formatting
+    ast.Eq: "==",
+    ast.NotEq: "!=",
+    ast.Lt: "<",
+    ast.LtE: "<=",
+    ast.Gt: ">",
+    ast.GtE: ">=",
+    ast.Pow: "**",
+    ast.Is: "is",
+    ast.IsNot: "is not",
+    ast.In: "in",
+    ast.NotIn: "not in"
 }
 
 
@@ -327,6 +446,56 @@ def set_location(node, lineno, col_offset):
 
 
 class AssertionRewriter(ast.NodeVisitor):
+    """Assertion rewriting implementation.
+
+    The main entrypoint is to call .run() with an ast.Module instance,
+    this will then find all the assert statements and re-write them to
+    provide intermediate values and a detailed assertion error.  See
+    http://pybites.blogspot.be/2011/07/behind-scenes-of-pytests-new-assertion.html
+    for an overview of how this works.
+
+    The entry point here is .run() which will iterate over all the
+    statenemts in an ast.Module and for each ast.Assert statement it
+    finds call .visit() with it.  Then .visit_Assert() takes over and
+    is responsible for creating new ast statements to replace the
+    original assert statement: it re-writes the test of an assertion
+    to provide intermediate values and replace it with an if statement
+    which raises an assertion error with a detailed explanation in
+    case the expression is false.
+
+    For this .visit_Assert() uses the visitor pattern to visit all the
+    AST nodes of the ast.Assert.test field, each visit call returning
+    an AST node and the corresponding explanation string.  During this
+    state is kept in several instance attributes:
+
+    :statements: All the AST statements which will replace the assert
+       statement.
+
+    :variables: This is populated by .variable() with each variable
+       used by the statements so that they can all be set to None at
+       the end of the statements.
+
+    :variable_counter: Counter to create new unique variables needed
+       by statements.  Variables are created using .variable() and
+       have the form of "@py_assert0".
+
+    :on_failure: The AST statements which will be executed if the
+       assertion test fails.  This is the code which will construct
+       the failure message and raises the AssertionError.
+
+    :explanation_specifiers: A dict filled by .explanation_param()
+       with %-formatting placeholders and their corresponding
+       expressions to use in the building of an assertion message.
+       This is used by .pop_format_context() to build a message.
+
+    :stack: A stack of the explanation_specifiers dicts maintained by
+       .push_format_context() and .pop_format_context() which allows
+       to build another %-formatted string while already building one.
+
+    This state is reset on every new assert statement visited and used
+    by the other visitors.
+
+    """
 
     def run(self, mod):
         """Find all assert statements in *mod* and rewrite them."""
@@ -342,7 +511,7 @@ class AssertionRewriter(ast.NodeVisitor):
         lineno = 0
         for item in mod.body:
             if (expect_docstring and isinstance(item, ast.Expr) and
-                isinstance(item.value, ast.Str)):
+                    isinstance(item.value, ast.Str)):
                 doc = item.value.s
                 if "PYTEST_DONT_REWRITE" in doc:
                     # The module has disabled assertion rewriting.
@@ -408,15 +577,41 @@ class AssertionRewriter(ast.NodeVisitor):
         return ast.Attribute(builtin_name, name, ast.Load())
 
     def explanation_param(self, expr):
+        """Return a new named %-formatting placeholder for expr.
+
+        This creates a %-formatting placeholder for expr in the
+        current formatting context, e.g. ``%(py0)s``.  The placeholder
+        and expr are placed in the current format context so that it
+        can be used on the next call to .pop_format_context().
+
+        """
         specifier = "py" + str(next(self.variable_counter))
         self.explanation_specifiers[specifier] = expr
         return "%(" + specifier + ")s"
 
     def push_format_context(self):
+        """Create a new formatting context.
+
+        The format context is used for when an explanation wants to
+        have a variable value formatted in the assertion message.  In
+        this case the value required can be added using
+        .explanation_param().  Finally .pop_format_context() is used
+        to format a string of %-formatted values as added by
+        .explanation_param().
+
+        """
         self.explanation_specifiers = {}
         self.stack.append(self.explanation_specifiers)
 
     def pop_format_context(self, expl_expr):
+        """Format the %-formatted string with current format context.
+
+        The expl_expr should be an ast.Str instance constructed from
+        the %-placeholders created by .explanation_param().  This will
+        add the required code to format said string to .on_failure and
+        return the ast.Name instance of the formatted string.
+
+        """
         current = self.stack.pop()
         if self.stack:
             self.explanation_specifiers = self.stack[-1]
@@ -434,11 +629,15 @@ class AssertionRewriter(ast.NodeVisitor):
         return res, self.explanation_param(self.display(res))
 
     def visit_Assert(self, assert_):
-        if assert_.msg:
-            # There's already a message. Don't mess with it.
-            return [assert_]
+        """Return the AST statements to replace the ast.Assert instance.
+
+        This re-writes the test of an assertion to provide
+        intermediate values and replace it with an if statement which
+        raises an assertion error with a detailed explanation in case
+        the expression is false.
+
+        """
         self.statements = []
-        self.cond_chain = ()
         self.variables = []
         self.variable_counter = itertools.count()
         self.stack = []
@@ -450,8 +649,13 @@ class AssertionRewriter(ast.NodeVisitor):
         body = self.on_failure
         negation = ast.UnaryOp(ast.Not(), top_condition)
         self.statements.append(ast.If(negation, body, []))
-        explanation = "assert " + explanation
-        template = ast.Str(explanation)
+        if assert_.msg:
+            assertmsg = self.helper('format_assertmsg', assert_.msg)
+            explanation = "\n>assert " + explanation
+        else:
+            assertmsg = ast.Str("")
+            explanation = "assert " + explanation
+        template = ast.BinOp(assertmsg, ast.Add(), ast.Str(explanation))
         msg = self.pop_format_context(template)
         fmt = self.helper("format_explanation", msg)
         err_name = ast.Name("AssertionError", ast.Load())
@@ -463,7 +667,8 @@ class AssertionRewriter(ast.NodeVisitor):
         body.append(raise_)
         # Clear temporary variables by setting them to None.
         if self.variables:
-            variables = [ast.Name(name, ast.Store()) for name in self.variables]
+            variables = [ast.Name(name, ast.Store())
+                         for name in self.variables]
             clear = ast.Assign(variables, ast.Name("None", ast.Load()))
             self.statements.append(clear)
         # Fix line numbers.
@@ -472,11 +677,12 @@ class AssertionRewriter(ast.NodeVisitor):
         return self.statements
 
     def visit_Name(self, name):
-        # Check if the name is local or not.
+        # Display the repr of the name if it's a local variable or
+        # _should_repr_global_name() thinks it's acceptable.
         locs = ast.Call(self.builtin("locals"), [], [], None, None)
-        globs = ast.Call(self.builtin("globals"), [], [], None, None)
-        ops = [ast.In(), ast.IsNot()]
-        test = ast.Compare(ast.Str(name.id), ops, [locs, globs])
+        inlocs = ast.Compare(ast.Str(name.id), [ast.In()], [locs])
+        dorepr = self.helper("should_repr_global_name", name)
+        test = ast.BoolOp(ast.Or(), [inlocs, dorepr])
         expr = ast.IfExp(test, self.display(name), ast.Str(name.id))
         return name, self.explanation_param(expr)
 
@@ -493,7 +699,8 @@ class AssertionRewriter(ast.NodeVisitor):
         for i, v in enumerate(boolop.values):
             if i:
                 fail_inner = []
-                self.on_failure.append(ast.If(cond, fail_inner, []))
+                # cond is set in a prior loop iteration below
+                self.on_failure.append(ast.If(cond, fail_inner, [])) # noqa
                 self.on_failure = fail_inner
             self.push_format_context()
             res, expl = self.visit(v)
@@ -549,7 +756,8 @@ class AssertionRewriter(ast.NodeVisitor):
             new_kwarg, expl = self.visit(call.kwargs)
             arg_expls.append("**" + expl)
         expl = "%s(%s)" % (func_expl, ', '.join(arg_expls))
-        new_call = ast.Call(new_func, new_args, new_kwargs, new_star, new_kwarg)
+        new_call = ast.Call(new_func, new_args, new_kwargs,
+                            new_star, new_kwarg)
         res = self.assign(new_call)
         res_expl = self.explanation_param(self.display(res))
         outer_expl = "%s\n{%s = %s\n}" % (res_expl, res_expl, expl)
@@ -585,7 +793,7 @@ class AssertionRewriter(ast.NodeVisitor):
             res_expr = ast.Compare(left_res, [op], [next_res])
             self.statements.append(ast.Assign([store_names[i]], res_expr))
             left_res, left_expl = next_res, next_expl
-        # Use py.code._reprcompare if that's available.
+        # Use pytest.assertion.util._reprcompare if that's available.
         expl_call = self.helper("call_reprcompare",
                                 ast.Tuple(syms, ast.Load()),
                                 ast.Tuple(load_names, ast.Load()),

_pytest/assertion/util.py

@@ -1,7 +1,14 @@
 """Utilities for assertion debugging"""
+import pprint
 
 import py
+try:
+    from collections import Sequence
+except ImportError:
+    Sequence = list
 
+BuiltinAssertionError = py.builtin.builtins.AssertionError
+u = py.builtin._totext
 
 # The _reprcompare attribute on the util module is used by the new assertion
 # interpretation code and assertion rewriter to detect this plugin was
@@ -9,6 +16,7 @@ import py
 # DebugInterpreter.
 _reprcompare = None
 
+
 def format_explanation(explanation):
     """This formats an explanation
 
@@ -19,7 +27,18 @@ def format_explanation(explanation):
     for when one explanation needs to span multiple lines, e.g. when
     displaying diffs.
     """
-    # simplify 'assert False where False = ...'
+    explanation = _collapse_false(explanation)
+    lines = _split_explanation(explanation)
+    result = _format_lines(lines)
+    return u('\n').join(result)
+
+
+def _collapse_false(explanation):
+    """Collapse expansions of False
+
+    So this strips out any "assert False\n{where False = ...\n}"
+    blocks.
+    """
     where = 0
     while True:
         start = where = explanation.find("False\n{False = ", where)
@@ -41,38 +60,59 @@ def format_explanation(explanation):
             explanation = (explanation[:start] + explanation[start+15:end-1] +
                            explanation[end+1:])
             where -= 17
-    raw_lines = (explanation or '').split('\n')
-    # escape newlines not followed by {, } and ~
+    return explanation
+
+
+def _split_explanation(explanation):
+    """Return a list of individual lines in the explanation
+
+    This will return a list of lines split on '\n{', '\n}' and '\n~'.
+    Any other newlines will be escaped and appear in the line as the
+    literal '\n' characters.
+    """
+    raw_lines = (explanation or u('')).split('\n')
     lines = [raw_lines[0]]
     for l in raw_lines[1:]:
-        if l.startswith('{') or l.startswith('}') or l.startswith('~'):
+        if l and l[0] in ['{', '}', '~', '>']:
             lines.append(l)
         else:
             lines[-1] += '\\n' + l
+    return lines
 
+
+def _format_lines(lines):
+    """Format the individual lines
+
+    This will replace the '{', '}' and '~' characters of our mini
+    formatting language with the proper 'where ...', 'and ...' and ' +
+    ...' text, taking care of indentation along the way.
+
+    Return a list of formatted lines.
+    """
     result = lines[:1]
     stack = [0]
     stackcnt = [0]
     for line in lines[1:]:
         if line.startswith('{'):
             if stackcnt[-1]:
-                s = 'and   '
+                s = u('and   ')
             else:
-                s = 'where '
+                s = u('where ')
             stack.append(len(result))
             stackcnt[-1] += 1
             stackcnt.append(0)
-            result.append(' +' + '  '*(len(stack)-1) + s + line[1:])
+            result.append(u(' +') + u('  ')*(len(stack)-1) + s + line[1:])
         elif line.startswith('}'):
-            assert line.startswith('}')
             stack.pop()
             stackcnt.pop()
             result[stack[-1]] += line[1:]
         else:
-            assert line.startswith('~')
-            result.append('  '*len(stack) + line[1:])
+            assert line[0] in ['~', '>']
+            stack[-1] += 1
+            indent = len(stack) if line.startswith('~') else len(stack) - 1
+            result.append(u('  ')*indent + line[1:])
     assert len(stack) == 1
-    return '\n'.join(result)
+    return result
 
 
 # Provide basestring in python3
@@ -82,132 +122,163 @@ except NameError:
     basestring = str
 
 
-def assertrepr_compare(op, left, right):
-    """return specialised explanations for some operators/operands"""
-    width = 80 - 15 - len(op) - 2 # 15 chars indentation, 1 space around op
+def assertrepr_compare(config, op, left, right):
+    """Return specialised explanations for some operators/operands"""
+    width = 80 - 15 - len(op) - 2  # 15 chars indentation, 1 space around op
     left_repr = py.io.saferepr(left, maxsize=int(width/2))
     right_repr = py.io.saferepr(right, maxsize=width-len(left_repr))
-    summary = '%s %s %s' % (left_repr, op, right_repr)
+    summary = u('%s %s %s') % (left_repr, op, right_repr)
 
-    issequence = lambda x: isinstance(x, (list, tuple))
+    issequence = lambda x: (isinstance(x, (list, tuple, Sequence))
+                            and not isinstance(x, basestring))
     istext = lambda x: isinstance(x, basestring)
     isdict = lambda x: isinstance(x, dict)
-    isset = lambda x: isinstance(x, set)
+    isset = lambda x: isinstance(x, (set, frozenset))
 
+    verbose = config.getoption('verbose')
     explanation = None
     try:
         if op == '==':
             if istext(left) and istext(right):
-                explanation = _diff_text(left, right)
+                explanation = _diff_text(left, right, verbose)
             elif issequence(left) and issequence(right):
-                explanation = _compare_eq_sequence(left, right)
+                explanation = _compare_eq_sequence(left, right, verbose)
             elif isset(left) and isset(right):
-                explanation = _compare_eq_set(left, right)
+                explanation = _compare_eq_set(left, right, verbose)
             elif isdict(left) and isdict(right):
-                explanation = _diff_text(py.std.pprint.pformat(left),
-                                         py.std.pprint.pformat(right))
+                explanation = _compare_eq_dict(left, right, verbose)
         elif op == 'not in':
             if istext(left) and istext(right):
-                explanation = _notin_text(left, right)
-    except py.builtin._sysex:
-        raise
-    except:
-        excinfo = py.code.ExceptionInfo()
-        explanation = ['(pytest_assertion plugin: representation of '
-            'details failed. Probably an object has a faulty __repr__.)',
-            str(excinfo)
-            ]
-
+                explanation = _notin_text(left, right, verbose)
+    except Exception:
+        explanation = [
+            u('(pytest_assertion plugin: representation of details failed.  '
+              'Probably an object has a faulty __repr__.)'),
+            u(py.code.ExceptionInfo())]
 
     if not explanation:
         return None
 
-    # Don't include pageloads of data, should be configurable
-    if len(''.join(explanation)) > 80*8:
-        explanation = ['Detailed information too verbose, truncated']
-
     return [summary] + explanation
 
 
-def _diff_text(left, right):
-    """Return the explanation for the diff between text
+def _diff_text(left, right, verbose=False):
+    """Return the explanation for the diff between text or bytes
 
-    This will skip leading and trailing characters which are
-    identical to keep the diff minimal.
+    Unless --verbose is used this will skip leading and trailing
+    characters which are identical to keep the diff minimal.
+
+    If the input are bytes they will be safely converted to text.
     """
+    from difflib import ndiff
     explanation = []
-    i = 0 # just in case left or right has zero length
-    for i in range(min(len(left), len(right))):
-        if left[i] != right[i]:
-            break
-    if i > 42:
-        i -= 10                 # Provide some context
-        explanation = ['Skipping %s identical '
-                       'leading characters in diff' % i]
-        left = left[i:]
-        right = right[i:]
-    if len(left) == len(right):
-        for i in range(len(left)):
-            if left[-i] != right[-i]:
+    if isinstance(left, py.builtin.bytes):
+        left = u(repr(left)[1:-1]).replace(r'\n', '\n')
+    if isinstance(right, py.builtin.bytes):
+        right = u(repr(right)[1:-1]).replace(r'\n', '\n')
+    if not verbose:
+        i = 0  # just in case left or right has zero length
+        for i in range(min(len(left), len(right))):
+            if left[i] != right[i]:
                 break
         if i > 42:
-            i -= 10     # Provide some context
-            explanation += ['Skipping %s identical '
-                            'trailing characters in diff' % i]
-            left = left[:-i]
-            right = right[:-i]
+            i -= 10                 # Provide some context
+            explanation = [u('Skipping %s identical leading '
+                             'characters in diff, use -v to show') % i]
+            left = left[i:]
+            right = right[i:]
+        if len(left) == len(right):
+            for i in range(len(left)):
+                if left[-i] != right[-i]:
+                    break
+            if i > 42:
+                i -= 10     # Provide some context
+                explanation += [u('Skipping %s identical trailing '
+                                  'characters in diff, use -v to show') % i]
+                left = left[:-i]
+                right = right[:-i]
     explanation += [line.strip('\n')
-                    for line in py.std.difflib.ndiff(left.splitlines(),
-                                                     right.splitlines())]
+                    for line in ndiff(left.splitlines(),
+                                      right.splitlines())]
     return explanation
 
 
-def _compare_eq_sequence(left, right):
+def _compare_eq_sequence(left, right, verbose=False):
     explanation = []
     for i in range(min(len(left), len(right))):
         if left[i] != right[i]:
-            explanation += ['At index %s diff: %r != %r' %
-                            (i, left[i], right[i])]
+            explanation += [u('At index %s diff: %r != %r')
+                            % (i, left[i], right[i])]
             break
     if len(left) > len(right):
-        explanation += ['Left contains more items, '
-            'first extra item: %s' % py.io.saferepr(left[len(right)],)]
+        explanation += [u('Left contains more items, first extra item: %s')
+                        % py.io.saferepr(left[len(right)],)]
     elif len(left) < len(right):
-        explanation += ['Right contains more items, '
-            'first extra item: %s' % py.io.saferepr(right[len(left)],)]
-    return explanation # + _diff_text(py.std.pprint.pformat(left),
-                       #             py.std.pprint.pformat(right))
+        explanation += [
+            u('Right contains more items, first extra item: %s') %
+            py.io.saferepr(right[len(left)],)]
+    return explanation  # + _diff_text(pprint.pformat(left),
+                        #              pprint.pformat(right))
 
 
-def _compare_eq_set(left, right):
+def _compare_eq_set(left, right, verbose=False):
     explanation = []
     diff_left = left - right
     diff_right = right - left
     if diff_left:
-        explanation.append('Extra items in the left set:')
+        explanation.append(u('Extra items in the left set:'))
         for item in diff_left:
             explanation.append(py.io.saferepr(item))
     if diff_right:
-        explanation.append('Extra items in the right set:')
+        explanation.append(u('Extra items in the right set:'))
         for item in diff_right:
             explanation.append(py.io.saferepr(item))
     return explanation
 
 
-def _notin_text(term, text):
+def _compare_eq_dict(left, right, verbose=False):
+    explanation = []
+    common = set(left).intersection(set(right))
+    same = dict((k, left[k]) for k in common if left[k] == right[k])
+    if same and not verbose:
+        explanation += [u('Omitting %s identical items, use -v to show') %
+                        len(same)]
+    elif same:
+        explanation += [u('Common items:')]
+        explanation += pprint.pformat(same).splitlines()
+    diff = set(k for k in common if left[k] != right[k])
+    if diff:
+        explanation += [u('Differing items:')]
+        for k in diff:
+            explanation += [py.io.saferepr({k: left[k]}) + ' != ' +
+                            py.io.saferepr({k: right[k]})]
+    extra_left = set(left) - set(right)
+    if extra_left:
+        explanation.append(u('Left contains more items:'))
+        explanation.extend(pprint.pformat(
+            dict((k, left[k]) for k in extra_left)).splitlines())
+    extra_right = set(right) - set(left)
+    if extra_right:
+        explanation.append(u('Right contains more items:'))
+        explanation.extend(pprint.pformat(
+            dict((k, right[k]) for k in extra_right)).splitlines())
+    return explanation
+
+
+def _notin_text(term, text, verbose=False):
     index = text.find(term)
     head = text[:index]
     tail = text[index+len(term):]
     correct_text = head + tail
-    diff = _diff_text(correct_text, text)
-    newdiff = ['%s is contained here:' % py.io.saferepr(term, maxsize=42)]
+    diff = _diff_text(correct_text, text, verbose)
+    newdiff = [u('%s is contained here:') % py.io.saferepr(term, maxsize=42)]
     for line in diff:
-        if line.startswith('Skipping'):
+        if line.startswith(u('Skipping')):
             continue
-        if line.startswith('- '):
+        if line.startswith(u('- ')):
             continue
-        if line.startswith('+ '):
-            newdiff.append('  ' + line[2:])
+        if line.startswith(u('+ ')):
+            newdiff.append(u('  ') + line[2:])
         else:
             newdiff.append(line)
     return newdiff

_pytest/capture.py

@@ -1,214 +1,447 @@
-""" per-test stdout/stderr capturing mechanisms, ``capsys`` and ``capfd`` function arguments.  """
+"""
+per-test stdout/stderr capturing mechanism.
 
-import pytest, py
+"""
+from __future__ import with_statement
+
+import sys
 import os
+from tempfile import TemporaryFile
+
+import py
+import pytest
+
+from py.io import TextIO
+unicode = py.builtin.text
+
+patchsysdict = {0: 'stdin', 1: 'stdout', 2: 'stderr'}
+
 
 def pytest_addoption(parser):
     group = parser.getgroup("general")
-    group._addoption('--capture', action="store", default=None,
-        metavar="method", type="choice", choices=['fd', 'sys', 'no'],
-        help="per-test capturing method: one of fd (default)|sys|no.")
-    group._addoption('-s', action="store_const", const="no", dest="capture",
+    group._addoption(
+        '--capture', action="store",
+        default="fd" if hasattr(os, "dup") else "sys",
+        metavar="method", choices=['fd', 'sys', 'no'],
+        help="per-test capturing method: one of fd|sys|no.")
+    group._addoption(
+        '-s', action="store_const", const="no", dest="capture",
         help="shortcut for --capture=no.")
 
+
 @pytest.mark.tryfirst
-def pytest_cmdline_parse(pluginmanager, args):
-    # we want to perform capturing already for plugin/conftest loading
-    if '-s' in args or "--capture=no" in args:
-        method = "no"
-    elif hasattr(os, 'dup') and '--capture=sys' not in args:
-        method = "fd"
-    else:
-        method = "sys"
-    capman = CaptureManager(method)
+def pytest_load_initial_conftests(early_config, parser, args, __multicall__):
+    ns = early_config.known_args_namespace
+    pluginmanager = early_config.pluginmanager
+    capman = CaptureManager(ns.capture)
     pluginmanager.register(capman, "capturemanager")
 
-def addouterr(rep, outerr):
-    for secname, content in zip(["out", "err"], outerr):
-        if content:
-            rep.sections.append(("Captured std%s" % secname, content))
+    # make sure that capturemanager is properly reset at final shutdown
+    pluginmanager.add_shutdown(capman.reset_capturings)
+
+    # make sure logging does not raise exceptions at the end
+    def silence_logging_at_shutdown():
+        if "logging" in sys.modules:
+            sys.modules["logging"].raiseExceptions = False
+    pluginmanager.add_shutdown(silence_logging_at_shutdown)
+
+    # finally trigger conftest loading but while capturing (issue93)
+    capman.init_capturings()
+    try:
+        try:
+            return __multicall__.execute()
+        finally:
+            out, err = capman.suspendcapture()
+    except:
+        sys.stdout.write(out)
+        sys.stderr.write(err)
+        raise
 
-class NoCapture:
-    def startall(self):
-        pass
-    def resume(self):
-        pass
-    def reset(self):
-        pass
-    def suspend(self):
-        return "", ""
 
 class CaptureManager:
-    def __init__(self, defaultmethod=None):
-        self._method2capture = {}
-        self._defaultmethod = defaultmethod
-
-    def _maketempfile(self):
-        f = py.std.tempfile.TemporaryFile()
-        newf = py.io.dupfile(f, encoding="UTF-8")
-        f.close()
-        return newf
-
-    def _makestringio(self):
-        return py.io.TextIO()
+    def __init__(self, method):
+        self._method = method
 
     def _getcapture(self, method):
         if method == "fd":
-            return py.io.StdCaptureFD(now=False,
-                out=self._maketempfile(), err=self._maketempfile()
-            )
+            return MultiCapture(out=True, err=True, Capture=FDCapture)
         elif method == "sys":
-            return py.io.StdCapture(now=False,
-                out=self._makestringio(), err=self._makestringio()
-            )
+            return MultiCapture(out=True, err=True, Capture=SysCapture)
         elif method == "no":
-            return NoCapture()
+            return MultiCapture(out=False, err=False, in_=False)
         else:
             raise ValueError("unknown capturing method: %r" % method)
 
-    def _getmethod(self, config, fspath):
-        if config.option.capture:
-            method = config.option.capture
-        else:
-            try:
-                method = config._conftest.rget("option_capture", path=fspath)
-            except KeyError:
-                method = "fd"
-        if method == "fd" and not hasattr(os, 'dup'): # e.g. jython
-            method = "sys"
-        return method
+    def init_capturings(self):
+        assert not hasattr(self, "_capturing")
+        self._capturing = self._getcapture(self._method)
+        self._capturing.start_capturing()
 
     def reset_capturings(self):
-        for name, cap in self._method2capture.items():
-            cap.reset()
+        cap = self.__dict__.pop("_capturing", None)
+        if cap is not None:
+            cap.pop_outerr_to_orig()
+            cap.stop_capturing()
 
-    def resumecapture_item(self, item):
-        method = self._getmethod(item.config, item.fspath)
-        if not hasattr(item, 'outerr'):
-            item.outerr = ('', '') # we accumulate outerr on the item
-        return self.resumecapture(method)
+    def resumecapture(self):
+        self._capturing.resume_capturing()
 
-    def resumecapture(self, method=None):
-        if hasattr(self, '_capturing'):
-            raise ValueError("cannot resume, already capturing with %r" %
-                (self._capturing,))
-        if method is None:
-            method = self._defaultmethod
-        cap = self._method2capture.get(method)
-        self._capturing = method
-        if cap is None:
-            self._method2capture[method] = cap = self._getcapture(method)
-            cap.startall()
-        else:
-            cap.resume()
-
-    def suspendcapture(self, item=None):
+    def suspendcapture(self, in_=False):
         self.deactivate_funcargs()
-        if hasattr(self, '_capturing'):
-            method = self._capturing
-            cap = self._method2capture.get(method)
-            if cap is not None:
-                outerr = cap.suspend()
-            del self._capturing
-            if item:
-                outerr = (item.outerr[0] + outerr[0],
-                          item.outerr[1] + outerr[1])
+        cap = getattr(self, "_capturing", None)
+        if cap is not None:
+            outerr = cap.readouterr()
+            cap.suspend_capturing(in_=in_)
             return outerr
-        if hasattr(item, 'outerr'):
-            return item.outerr
-        return "", ""
 
     def activate_funcargs(self, pyfuncitem):
-        if not hasattr(pyfuncitem, 'funcargs'):
-            return
-        assert not hasattr(self, '_capturing_funcargs')
-        self._capturing_funcargs = capturing_funcargs = []
-        for name, capfuncarg in pyfuncitem.funcargs.items():
-            if name in ('capsys', 'capfd'):
-                capturing_funcargs.append(capfuncarg)
-                capfuncarg._start()
+        capfuncarg = pyfuncitem.__dict__.pop("_capfuncarg", None)
+        if capfuncarg is not None:
+            capfuncarg._start()
+            self._capfuncarg = capfuncarg
 
     def deactivate_funcargs(self):
-        capturing_funcargs = getattr(self, '_capturing_funcargs', None)
-        if capturing_funcargs is not None:
-            while capturing_funcargs:
-                capfuncarg = capturing_funcargs.pop()
-                capfuncarg._finalize()
-            del self._capturing_funcargs
+        capfuncarg = self.__dict__.pop("_capfuncarg", None)
+        if capfuncarg is not None:
+            capfuncarg.close()
 
+    @pytest.mark.tryfirst
     def pytest_make_collect_report(self, __multicall__, collector):
-        method = self._getmethod(collector.config, collector.fspath)
-        try:
-            self.resumecapture(method)
-        except ValueError:
-            return # recursive collect, XXX refactor capturing
-                   # to allow for more lightweight recursive capturing
+        if not isinstance(collector, pytest.File):
+            return
+        self.resumecapture()
         try:
             rep = __multicall__.execute()
         finally:
-            outerr = self.suspendcapture()
-        addouterr(rep, outerr)
+            out, err = self.suspendcapture()
+        if out:
+            rep.sections.append(("Captured stdout", out))
+        if err:
+            rep.sections.append(("Captured stderr", err))
         return rep
 
-    @pytest.mark.tryfirst
+    @pytest.mark.hookwrapper
     def pytest_runtest_setup(self, item):
-        self.resumecapture_item(item)
+        self.resumecapture()
+        yield
+        self.suspendcapture_item(item, "setup")
 
-    @pytest.mark.tryfirst
+    @pytest.mark.hookwrapper
     def pytest_runtest_call(self, item):
-        self.resumecapture_item(item)
+        self.resumecapture()
         self.activate_funcargs(item)
+        yield
+        #self.deactivate_funcargs() called from suspendcapture()
+        self.suspendcapture_item(item, "call")
 
-    @pytest.mark.tryfirst
+    @pytest.mark.hookwrapper
     def pytest_runtest_teardown(self, item):
-        self.resumecapture_item(item)
-
-    def pytest_keyboard_interrupt(self, excinfo):
-        if hasattr(self, '_capturing'):
-            self.suspendcapture()
+        self.resumecapture()
+        yield
+        self.suspendcapture_item(item, "teardown")
 
     @pytest.mark.tryfirst
-    def pytest_runtest_makereport(self, __multicall__, item, call):
-        self.deactivate_funcargs()
-        rep = __multicall__.execute()
-        outerr = self.suspendcapture(item)
-        if not rep.passed:
-            addouterr(rep, outerr)
-        if not rep.passed or rep.when == "teardown":
-            outerr = ('', '')
-        item.outerr = outerr
-        return rep
+    def pytest_keyboard_interrupt(self, excinfo):
+        self.reset_capturings()
 
-def pytest_funcarg__capsys(request):
+    @pytest.mark.tryfirst
+    def pytest_internalerror(self, excinfo):
+        self.reset_capturings()
+
+    def suspendcapture_item(self, item, when):
+        out, err = self.suspendcapture()
+        item.add_report_section(when, "out", out)
+        item.add_report_section(when, "err", err)
+
+error_capsysfderror = "cannot use capsys and capfd at the same time"
+
+
+@pytest.fixture
+def capsys(request):
     """enables capturing of writes to sys.stdout/sys.stderr and makes
     captured output available via ``capsys.readouterr()`` method calls
     which return a ``(out, err)`` tuple.
     """
-    return CaptureFuncarg(py.io.StdCapture)
+    if "capfd" in request._funcargs:
+        raise request.raiseerror(error_capsysfderror)
+    request.node._capfuncarg = c = CaptureFixture(SysCapture)
+    return c
 
-def pytest_funcarg__capfd(request):
+@pytest.fixture
+def capfd(request):
     """enables capturing of writes to file descriptors 1 and 2 and makes
-    captured output available via ``capsys.readouterr()`` method calls
+    captured output available via ``capfd.readouterr()`` method calls
     which return a ``(out, err)`` tuple.
     """
+    if "capsys" in request._funcargs:
+        request.raiseerror(error_capsysfderror)
     if not hasattr(os, 'dup'):
-        py.test.skip("capfd funcarg needs os.dup")
-    return CaptureFuncarg(py.io.StdCaptureFD)
+        pytest.skip("capfd funcarg needs os.dup")
+    request.node._capfuncarg = c = CaptureFixture(FDCapture)
+    return c
 
-class CaptureFuncarg:
+
+class CaptureFixture:
     def __init__(self, captureclass):
-        self.capture = captureclass(now=False)
+        self.captureclass = captureclass
 
     def _start(self):
-        self.capture.startall()
-
-    def _finalize(self):
-        if hasattr(self, 'capture'):
-            self.capture.reset()
-            del self.capture
-
-    def readouterr(self):
-        return self.capture.readouterr()
+        self._capture = MultiCapture(out=True, err=True, in_=False,
+                                       Capture=self.captureclass)
+        self._capture.start_capturing()
 
     def close(self):
-        self._finalize()
+        cap = self.__dict__.pop("_capture", None)
+        if cap is not None:
+            self._outerr = cap.pop_outerr_to_orig()
+            cap.stop_capturing()
+
+    def readouterr(self):
+        try:
+            return self._capture.readouterr()
+        except AttributeError:
+            return self._outerr
+
+
+def safe_text_dupfile(f, mode, default_encoding="UTF8"):
+    """ return a open text file object that's a duplicate of f on the
+        FD-level if possible.
+    """
+    encoding = getattr(f, "encoding", None)
+    try:
+        fd = f.fileno()
+    except Exception:
+        if "b" not in getattr(f, "mode", "") and hasattr(f, "encoding"):
+            # we seem to have a text stream, let's just use it
+            return f
+    else:
+        newfd = os.dup(fd)
+        if "b" not in mode:
+            mode += "b"
+        f = os.fdopen(newfd, mode, 0)  # no buffering
+    return EncodedFile(f, encoding or default_encoding)
+
+
+class EncodedFile(object):
+    errors = "strict"  # possibly needed by py3 code (issue555)
+    def __init__(self, buffer, encoding):
+        self.buffer = buffer
+        self.encoding = encoding
+
+    def write(self, obj):
+        if isinstance(obj, unicode):
+            obj = obj.encode(self.encoding, "replace")
+        self.buffer.write(obj)
+
+    def writelines(self, linelist):
+        data = ''.join(linelist)
+        self.write(data)
+
+    def __getattr__(self, name):
+        return getattr(object.__getattribute__(self, "buffer"), name)
+
+
+class MultiCapture(object):
+    out = err = in_ = None
+
+    def __init__(self, out=True, err=True, in_=True, Capture=None):
+        if in_:
+            self.in_ = Capture(0)
+        if out:
+            self.out = Capture(1)
+        if err:
+            self.err = Capture(2)
+
+    def start_capturing(self):
+        if self.in_:
+            self.in_.start()
+        if self.out:
+            self.out.start()
+        if self.err:
+            self.err.start()
+
+    def pop_outerr_to_orig(self):
+        """ pop current snapshot out/err capture and flush to orig streams. """
+        out, err = self.readouterr()
+        if out:
+            self.out.writeorg(out)
+        if err:
+            self.err.writeorg(err)
+        return out, err
+
+    def suspend_capturing(self, in_=False):
+        if self.out:
+            self.out.suspend()
+        if self.err:
+            self.err.suspend()
+        if in_ and self.in_:
+            self.in_.suspend()
+            self._in_suspended = True
+
+    def resume_capturing(self):
+        if self.out:
+            self.out.resume()
+        if self.err:
+            self.err.resume()
+        if hasattr(self, "_in_suspended"):
+            self.in_.resume()
+            del self._in_suspended
+
+    def stop_capturing(self):
+        """ stop capturing and reset capturing streams """
+        if hasattr(self, '_reset'):
+            raise ValueError("was already stopped")
+        self._reset = True
+        if self.out:
+            self.out.done()
+        if self.err:
+            self.err.done()
+        if self.in_:
+            self.in_.done()
+
+    def readouterr(self):
+        """ return snapshot unicode value of stdout/stderr capturings. """
+        return (self.out.snap() if self.out is not None else "",
+                self.err.snap() if self.err is not None else "")
+
+class NoCapture:
+    __init__ = start = done = suspend = resume = lambda *args: None
+
+class FDCapture:
+    """ Capture IO to/from a given os-level filedescriptor. """
+
+    def __init__(self, targetfd, tmpfile=None):
+        self.targetfd = targetfd
+        try:
+            self.targetfd_save = os.dup(self.targetfd)
+        except OSError:
+            self.start = lambda: None
+            self.done = lambda: None
+        else:
+            if targetfd == 0:
+                assert not tmpfile, "cannot set tmpfile with stdin"
+                tmpfile = open(os.devnull, "r")
+                self.syscapture = SysCapture(targetfd)
+            else:
+                if tmpfile is None:
+                    f = TemporaryFile()
+                    with f:
+                        tmpfile = safe_text_dupfile(f, mode="wb+")
+                if targetfd in patchsysdict:
+                    self.syscapture = SysCapture(targetfd, tmpfile)
+                else:
+                    self.syscapture = NoCapture()
+            self.tmpfile = tmpfile
+            self.tmpfile_fd = tmpfile.fileno()
+
+    def __repr__(self):
+        return "<FDCapture %s oldfd=%s>" % (self.targetfd, self.targetfd_save)
+
+    def start(self):
+        """ Start capturing on targetfd using memorized tmpfile. """
+        try:
+            os.fstat(self.targetfd_save)
+        except (AttributeError, OSError):
+            raise ValueError("saved filedescriptor not valid anymore")
+        os.dup2(self.tmpfile_fd, self.targetfd)
+        self.syscapture.start()
+
+    def snap(self):
+        f = self.tmpfile
+        f.seek(0)
+        res = f.read()
+        if res:
+            enc = getattr(f, "encoding", None)
+            if enc and isinstance(res, bytes):
+                res = py.builtin._totext(res, enc, "replace")
+            f.truncate(0)
+            f.seek(0)
+            return res
+        return ''
+
+    def done(self):
+        """ stop capturing, restore streams, return original capture file,
+        seeked to position zero. """
+        targetfd_save = self.__dict__.pop("targetfd_save")
+        os.dup2(targetfd_save, self.targetfd)
+        os.close(targetfd_save)
+        self.syscapture.done()
+        self.tmpfile.close()
+
+    def suspend(self):
+        self.syscapture.suspend()
+        os.dup2(self.targetfd_save, self.targetfd)
+
+    def resume(self):
+        self.syscapture.resume()
+        os.dup2(self.tmpfile_fd, self.targetfd)
+
+    def writeorg(self, data):
+        """ write to original file descriptor. """
+        if py.builtin._istext(data):
+            data = data.encode("utf8") # XXX use encoding of original stream
+        os.write(self.targetfd_save, data)
+
+
+class SysCapture:
+    def __init__(self, fd, tmpfile=None):
+        name = patchsysdict[fd]
+        self._old = getattr(sys, name)
+        self.name = name
+        if tmpfile is None:
+            if name == "stdin":
+                tmpfile = DontReadFromInput()
+            else:
+                tmpfile = TextIO()
+        self.tmpfile = tmpfile
+
+    def start(self):
+        setattr(sys, self.name, self.tmpfile)
+
+    def snap(self):
+        f = self.tmpfile
+        res = f.getvalue()
+        f.truncate(0)
+        f.seek(0)
+        return res
+
+    def done(self):
+        setattr(sys, self.name, self._old)
+        del self._old
+        self.tmpfile.close()
+
+    def suspend(self):
+        setattr(sys, self.name, self._old)
+
+    def resume(self):
+        setattr(sys, self.name, self.tmpfile)
+
+    def writeorg(self, data):
+        self._old.write(data)
+        self._old.flush()
+
+
+class DontReadFromInput:
+    """Temporary stub class.  Ideally when stdin is accessed, the
+    capturing should be turned off, with possibly all data captured
+    so far sent to the screen.  This should be configurable, though,
+    because in automated test runs it is better to crash than
+    hang indefinitely.
+    """
+
+    encoding = None
+
+    def read(self, *args):
+        raise IOError("reading from stdin while output is captured")
+    readline = read
+    readlines = read
+    __iter__ = read
+
+    def fileno(self):
+        raise ValueError("redirected Stdin is pseudofile, has no fileno()")
+
+    def isatty(self):
+        return False
+
+    def close(self):
+        pass

_pytest/config.py

@@ -1,25 +1,118 @@
 """ command line options, ini-file and conftest.py processing. """
+import argparse
+import shlex
+import traceback
+import types
+import warnings
 
 import py
+# DON't import pytest here because it causes import cycle troubles
 import sys, os
+from _pytest import hookspec # the extension point definitions
 from _pytest.core import PluginManager
-import pytest
 
-def pytest_cmdline_parse(pluginmanager, args):
-    config = Config(pluginmanager)
-    config.parse(args)
-    return config
+# pytest startup
+#
+class ConftestImportFailure(Exception):
+    def __init__(self, path, excinfo):
+        Exception.__init__(self, path, excinfo)
+        self.path = path
+        self.excinfo = excinfo
+
+
+def main(args=None, plugins=None):
+    """ return exit code, after performing an in-process test run.
+
+    :arg args: list of command line arguments.
+
+    :arg plugins: list of plugin objects to be auto-registered during
+                  initialization.
+    """
+    try:
+        config = _prepareconfig(args, plugins)
+    except ConftestImportFailure:
+        e = sys.exc_info()[1]
+        tw = py.io.TerminalWriter(sys.stderr)
+        for line in traceback.format_exception(*e.excinfo):
+            tw.line(line.rstrip(), red=True)
+        tw.line("ERROR: could not load %s\n" % (e.path), red=True)
+        return 4
+    else:
+        return config.hook.pytest_cmdline_main(config=config)
+
+class cmdline:  # compatibility namespace
+    main = staticmethod(main)
+
+class UsageError(Exception):
+    """ error in pytest usage or invocation"""
+
+_preinit = []
+
+default_plugins = (
+     "mark main terminal runner python pdb unittest capture skipping "
+     "tmpdir monkeypatch recwarn pastebin helpconfig nose assertion genscript "
+     "junitxml resultlog doctest").split()
+
+def _preloadplugins():
+    assert not _preinit
+    _preinit.append(get_plugin_manager())
+
+def get_plugin_manager():
+    if _preinit:
+        return _preinit.pop(0)
+    # subsequent calls to main will create a fresh instance
+    pluginmanager = PytestPluginManager()
+    pluginmanager.config = Config(pluginmanager) # XXX attr needed?
+    for spec in default_plugins:
+        pluginmanager.import_plugin(spec)
+    return pluginmanager
+
+def _prepareconfig(args=None, plugins=None):
+    if args is None:
+        args = sys.argv[1:]
+    elif isinstance(args, py.path.local):
+        args = [str(args)]
+    elif not isinstance(args, (tuple, list)):
+        if not isinstance(args, str):
+            raise ValueError("not a string or argument list: %r" % (args,))
+        args = shlex.split(args)
+    pluginmanager = get_plugin_manager()
+    try:
+        if plugins:
+            for plugin in plugins:
+                pluginmanager.register(plugin)
+        return pluginmanager.hook.pytest_cmdline_parse(
+                pluginmanager=pluginmanager, args=args)
+    except Exception:
+        pluginmanager.ensure_shutdown()
+        raise
+
+class PytestPluginManager(PluginManager):
+    def __init__(self, hookspecs=[hookspec]):
+        super(PytestPluginManager, self).__init__(hookspecs=hookspecs)
+        self.register(self)
+        if os.environ.get('PYTEST_DEBUG'):
+            err = sys.stderr
+            encoding = getattr(err, 'encoding', 'utf8')
+            try:
+                err = py.io.dupfile(err, encoding=encoding)
+            except Exception:
+                pass
+            self.trace.root.setwriter(err.write)
+
+    def pytest_configure(self, config):
+        config.addinivalue_line("markers",
+            "tryfirst: mark a hook implementation function such that the "
+            "plugin machinery will try to call it first/as early as possible.")
+        config.addinivalue_line("markers",
+            "trylast: mark a hook implementation function such that the "
+            "plugin machinery will try to call it last/as late as possible.")
+        for warning in self._warnings:
+            config.warn(code="I1", message=warning)
 
-def pytest_unconfigure(config):
-    while 1:
-        try:
-            fin = config._cleanup.pop()
-        except IndexError:
-            break
-        fin()
 
 class Parser:
-    """ Parser for command line arguments. """
+    """ Parser for command line arguments and ini-file values.  """
 
     def __init__(self, usage=None, processopt=None):
         self._anonymous = OptionGroup("custom options", parser=self)
@@ -28,22 +121,23 @@ class Parser:
         self._usage = usage
         self._inidict = {}
         self._ininames = []
-        self.hints = []
 
     def processoption(self, option):
         if self._processopt:
             if option.dest:
                 self._processopt(option)
 
-    def addnote(self, note):
-        self._notes.append(note)
-
     def getgroup(self, name, description="", after=None):
         """ get (or create) a named option Group.
 
-        :name: unique name of the option group.
+        :name: name of the option group.
         :description: long description for --help output.
         :after: name of other group, used for ordering --help output.
+
+        The returned group object has an ``addoption`` method with the same
+        signature as :py:func:`parser.addoption
+        <_pytest.config.Parser.addoption>` but will be shown in the
+        respective group in the output of ``pytest. --help``.
         """
         for group in self._groups:
             if group.name == name:
@@ -57,33 +151,221 @@ class Parser:
         return group
 
     def addoption(self, *opts, **attrs):
-        """ add an optparse-style option. """
+        """ register a command line option.
+
+        :opts: option names, can be short or long options.
+        :attrs: same attributes which the ``add_option()`` function of the
+           `argparse library
+           <http://docs.python.org/2/library/argparse.html>`_
+           accepts.
+
+        After command line parsing options are available on the pytest config
+        object via ``config.option.NAME`` where ``NAME`` is usually set
+        by passing a ``dest`` attribute, for example
+        ``addoption("--long", dest="NAME", ...)``.
+        """
         self._anonymous.addoption(*opts, **attrs)
 
     def parse(self, args):
-        self.optparser = optparser = MyOptionParser(self)
+        from _pytest._argcomplete import try_argcomplete
+        self.optparser = self._getparser()
+        try_argcomplete(self.optparser)
+        return self.optparser.parse_args([str(x) for x in args])
+
+    def _getparser(self):
+        from _pytest._argcomplete import filescompleter
+        optparser = MyOptionParser(self)
         groups = self._groups + [self._anonymous]
         for group in groups:
             if group.options:
                 desc = group.description or group.name
-                optgroup = py.std.optparse.OptionGroup(optparser, desc)
-                optgroup.add_options(group.options)
-                optparser.add_option_group(optgroup)
-        return self.optparser.parse_args([str(x) for x in args])
+                arggroup = optparser.add_argument_group(desc)
+                for option in group.options:
+                    n = option.names()
+                    a = option.attrs()
+                    arggroup.add_argument(*n, **a)
+        # bash like autocompletion for dirs (appending '/')
+        optparser.add_argument(FILE_OR_DIR, nargs='*').completer=filescompleter
+        return optparser
 
     def parse_setoption(self, args, option):
-        parsedoption, args = self.parse(args)
+        parsedoption = self.parse(args)
         for name, value in parsedoption.__dict__.items():
             setattr(option, name, value)
-        return args
+        return getattr(parsedoption, FILE_OR_DIR)
+
+    def parse_known_args(self, args):
+        optparser = self._getparser()
+        args = [str(x) for x in args]
+        return optparser.parse_known_args(args)[0]
 
     def addini(self, name, help, type=None, default=None):
-        """ add an ini-file option with the given name and description. """
+        """ register an ini-file option.
+
+        :name: name of the ini-variable
+        :type: type of the variable, can be ``pathlist``, ``args`` or ``linelist``.
+        :default: default value if no ini-file option exists but is queried.
+
+        The value of ini-variables can be retrieved via a call to
+        :py:func:`config.getini(name) <_pytest.config.Config.getini>`.
+        """
         assert type in (None, "pathlist", "args", "linelist")
         self._inidict[name] = (help, type, default)
         self._ininames.append(name)
 
 
+class ArgumentError(Exception):
+    """
+    Raised if an Argument instance is created with invalid or
+    inconsistent arguments.
+    """
+
+    def __init__(self, msg, option):
+        self.msg = msg
+        self.option_id = str(option)
+
+    def __str__(self):
+        if self.option_id:
+            return "option %s: %s" % (self.option_id, self.msg)
+        else:
+            return self.msg
+
+
+class Argument:
+    """class that mimics the necessary behaviour of optparse.Option """
+    _typ_map = {
+        'int': int,
+        'string': str,
+        }
+    # enable after some grace period for plugin writers
+    TYPE_WARN = False
+
+    def __init__(self, *names, **attrs):
+        """store parms in private vars for use in add_argument"""
+        self._attrs = attrs
+        self._short_opts = []
+        self._long_opts = []
+        self.dest = attrs.get('dest')
+        if self.TYPE_WARN:
+            try:
+                help = attrs['help']
+                if '%default' in help:
+                    warnings.warn(
+                        'pytest now uses argparse. "%default" should be'
+                        ' changed to "%(default)s" ',
+                        FutureWarning,
+                        stacklevel=3)
+            except KeyError:
+                pass
+        try:
+            typ = attrs['type']
+        except KeyError:
+            pass
+        else:
+            # this might raise a keyerror as well, don't want to catch that
+            if isinstance(typ, py.builtin._basestring):
+                if typ == 'choice':
+                    if self.TYPE_WARN:
+                        warnings.warn(
+                            'type argument to addoption() is a string %r.'
+                            ' For parsearg this is optional and when supplied '
+                            ' should be a type.'
+                            ' (options: %s)' % (typ, names),
+                            FutureWarning,
+                            stacklevel=3)
+                    # argparse expects a type here take it from
+                    # the type of the first element
+                    attrs['type'] = type(attrs['choices'][0])
+                else:
+                    if self.TYPE_WARN:
+                        warnings.warn(
+                            'type argument to addoption() is a string %r.'
+                            ' For parsearg this should be a type.'
+                            ' (options: %s)' % (typ, names),
+                            FutureWarning,
+                            stacklevel=3)
+                    attrs['type'] = Argument._typ_map[typ]
+                # used in test_parseopt -> test_parse_defaultgetter
+                self.type = attrs['type']
+            else:
+                self.type = typ
+        try:
+            # attribute existence is tested in Config._processopt
+            self.default = attrs['default']
+        except KeyError:
+            pass
+        self._set_opt_strings(names)
+        if not self.dest:
+            if self._long_opts:
+                self.dest = self._long_opts[0][2:].replace('-', '_')
+            else:
+                try:
+                    self.dest = self._short_opts[0][1:]
+                except IndexError:
+                    raise ArgumentError(
+                        'need a long or short option', self)
+
+    def names(self):
+        return self._short_opts + self._long_opts
+
+    def attrs(self):
+        # update any attributes set by processopt
+        attrs = 'default dest help'.split()
+        if self.dest:
+            attrs.append(self.dest)
+        for attr in attrs:
+            try:
+                self._attrs[attr] = getattr(self, attr)
+            except AttributeError:
+                pass
+        if self._attrs.get('help'):
+            a = self._attrs['help']
+            a = a.replace('%default', '%(default)s')
+            #a = a.replace('%prog', '%(prog)s')
+            self._attrs['help'] = a
+        return self._attrs
+
+    def _set_opt_strings(self, opts):
+        """directly from optparse
+
+        might not be necessary as this is passed to argparse later on"""
+        for opt in opts:
+            if len(opt) < 2:
+                raise ArgumentError(
+                    "invalid option string %r: "
+                    "must be at least two characters long" % opt, self)
+            elif len(opt) == 2:
+                if not (opt[0] == "-" and opt[1] != "-"):
+                    raise ArgumentError(
+                        "invalid short option string %r: "
+                        "must be of the form -x, (x any non-dash char)" % opt,
+                        self)
+                self._short_opts.append(opt)
+            else:
+                if not (opt[0:2] == "--" and opt[2] != "-"):
+                    raise ArgumentError(
+                        "invalid long option string %r: "
+                        "must start with --, followed by non-dash" % opt,
+                        self)
+                self._long_opts.append(opt)
+
+    def __repr__(self):
+        retval = 'Argument('
+        if self._short_opts:
+            retval += '_short_opts: ' + repr(self._short_opts) + ', '
+        if self._long_opts:
+            retval += '_long_opts: ' + repr(self._long_opts) + ', '
+        retval += 'dest: ' + repr(self.dest) + ', '
+        if hasattr(self, 'type'):
+            retval += 'type: ' + repr(self.type) + ', '
+        if hasattr(self, 'default'):
+            retval += 'default: ' + repr(self.default) + ', '
+        if retval[-2:] == ', ':  # always long enough to test ("Argument(" )
+            retval = retval[:-2]
+        retval += ')'
+        return retval
+
+
 class OptionGroup:
     def __init__(self, name, description="", parser=None):
         self.name = name
@@ -92,12 +374,18 @@ class OptionGroup:
         self.parser = parser
 
     def addoption(self, *optnames, **attrs):
-        """ add an option to this group. """
-        option = py.std.optparse.Option(*optnames, **attrs)
+        """ add an option to this group.
+
+        if a shortened version of a long option is specified it will
+        be suppressed in the help. addoption('--twowords', '--two-words')
+        results in help showing '--two-words' only, but --twowords gets
+        accepted **and** the automatic destination is in args.twowords
+        """
+        option = Argument(*optnames, **attrs)
         self._addoption_instance(option, shortupper=False)
 
     def _addoption(self, *optnames, **attrs):
-        option = py.std.optparse.Option(*optnames, **attrs)
+        option = Argument(*optnames, **attrs)
         self._addoption_instance(option, shortupper=True)
 
     def _addoption_instance(self, option, shortupper=False):
@@ -110,96 +398,134 @@ class OptionGroup:
         self.options.append(option)
 
 
-class MyOptionParser(py.std.optparse.OptionParser):
+class MyOptionParser(argparse.ArgumentParser):
     def __init__(self, parser):
         self._parser = parser
-        py.std.optparse.OptionParser.__init__(self, usage=parser._usage,
-            add_help_option=False)
-    def format_epilog(self, formatter):
-        hints = self._parser.hints
-        if hints:
-            s = "\n".join(["hint: " + x for x in hints]) + "\n"
-            s = "\n" + s + "\n"
-            return s
-        return ""
+        argparse.ArgumentParser.__init__(self, usage=parser._usage,
+            add_help=False, formatter_class=DropShorterLongHelpFormatter)
+
+    def parse_args(self, args=None, namespace=None):
+        """allow splitting of positional arguments"""
+        args, argv = self.parse_known_args(args, namespace)
+        if argv:
+            for arg in argv:
+                if arg and arg[0] == '-':
+                    msg = argparse._('unrecognized arguments: %s')
+                    self.error(msg % ' '.join(argv))
+            getattr(args, FILE_OR_DIR).extend(argv)
+        return args
+
+class DropShorterLongHelpFormatter(argparse.HelpFormatter):
+    """shorten help for long options that differ only in extra hyphens
+
+    - collapse **long** options that are the same except for extra hyphens
+    - special action attribute map_long_option allows surpressing additional
+      long options
+    - shortcut if there are only two options and one of them is a short one
+    - cache result on action object as this is called at least 2 times
+    """
+    def _format_action_invocation(self, action):
+        orgstr = argparse.HelpFormatter._format_action_invocation(self, action)
+        if orgstr and orgstr[0] != '-': # only optional arguments
+            return orgstr
+        res = getattr(action, '_formatted_action_invocation', None)
+        if res:
+            return res
+        options = orgstr.split(', ')
+        if len(options) == 2 and (len(options[0]) == 2 or len(options[1]) == 2):
+            # a shortcut for '-h, --help' or '--abc', '-a'
+            action._formatted_action_invocation = orgstr
+            return orgstr
+        return_list = []
+        option_map =  getattr(action, 'map_long_option', {})
+        if option_map is None:
+            option_map = {}
+        short_long = {}
+        for option in options:
+            if len(option) == 2 or option[2] == ' ':
+                continue
+            if not option.startswith('--'):
+                raise ArgumentError('long optional argument without "--": [%s]'
+                                    % (option), self)
+            xxoption = option[2:]
+            if xxoption.split()[0] not in option_map:
+                shortened = xxoption.replace('-', '')
+                if shortened not in short_long or \
+                   len(short_long[shortened]) < len(xxoption):
+                    short_long[shortened] = xxoption
+        # now short_long has been filled out to the longest with dashes
+        # **and** we keep the right option ordering from add_argument
+        for option in options: #
+            if len(option) == 2 or option[2] == ' ':
+                return_list.append(option)
+            if option[2:] == short_long.get(option.replace('-', '')):
+                return_list.append(option.replace(' ', '='))
+        action._formatted_action_invocation = ', '.join(return_list)
+        return action._formatted_action_invocation
+
 
 class Conftest(object):
     """ the single place for accessing values and interacting
-        towards conftest modules from py.test objects.
+        towards conftest modules from pytest objects.
     """
-    def __init__(self, onimport=None, confcutdir=None):
+    def __init__(self, onimport=None):
         self._path2confmods = {}
         self._onimport = onimport
         self._conftestpath2mod = {}
-        self._confcutdir = confcutdir
+        self._confcutdir = None
 
-    def setinitial(self, args):
-        """ try to find a first anchor path for looking up global values
-            from conftests. This function is usually called _before_
-            argument parsing.  conftest files may add command line options
-            and we thus have no completely safe way of determining
-            which parts of the arguments are actually related to options
-            and which are file system paths.  We just try here to get
-            bootstrapped ...
+    def setinitial(self, namespace):
+        """ load initial conftest files given a preparsed "namespace".
+            As conftest files may add their own command line options
+            which have arguments ('--my-opt somepath') we might get some
+            false positives.  All builtin and 3rd party plugins will have
+            been loaded, however, so common options will not confuse our logic
+            here.
         """
         current = py.path.local()
-        opt = '--confcutdir'
-        for i in range(len(args)):
-            opt1 = str(args[i])
-            if opt1.startswith(opt):
-                if opt1 == opt:
-                    if len(args) > i:
-                        p = current.join(args[i+1], abs=True)
-                elif opt1.startswith(opt + "="):
-                    p = current.join(opt1[len(opt)+1:], abs=1)
-                self._confcutdir = p
-                break
-        for arg in args + [current]:
-            if hasattr(arg, 'startswith') and arg.startswith("--"):
-                continue
-            anchor = current.join(arg, abs=1)
-            if anchor.check(): # we found some file object
-                self._path2confmods[None] = self.getconftestmodules(anchor)
-                # let's also consider test* dirs
-                if anchor.check(dir=1):
-                    for x in anchor.listdir("test*"):
-                        if x.check(dir=1):
-                            self.getconftestmodules(x)
-                break
-        else:
-            assert 0, "no root of filesystem?"
+        self._confcutdir = current.join(namespace.confcutdir, abs=True) \
+                                if namespace.confcutdir else None
+        testpaths = namespace.file_or_dir
+        foundanchor = False
+        for path in testpaths:
+            path = str(path)
+            # remove node-id syntax
+            i = path.find("::")
+            if i != -1:
+                path = path[:i]
+            anchor = current.join(path, abs=1)
+            if exists(anchor): # we found some file object
+                self._try_load_conftest(anchor)
+                foundanchor = True
+        if not foundanchor:
+            self._try_load_conftest(current)
+
+    def _try_load_conftest(self, anchor):
+        self.getconftestmodules(anchor)
+        # let's also consider test* subdirs
+        if anchor.check(dir=1):
+            for x in anchor.listdir("test*"):
+                if x.check(dir=1):
+                    self.getconftestmodules(x)
 
     def getconftestmodules(self, path):
-        """ return a list of imported conftest modules for the given path.  """
         try:
-            clist = self._path2confmods[path]
+            return self._path2confmods[path]
         except KeyError:
-            if path is None:
-                raise ValueError("missing default confest.")
-            dp = path.dirpath()
             clist = []
-            if dp != path:
-                cutdir = self._confcutdir
-                if cutdir and path != cutdir and not path.relto(cutdir):
-                    pass
-                else:
-                    conftestpath = path.join("conftest.py")
-                    if conftestpath.check(file=1):
-                        clist.append(self.importconftest(conftestpath))
-                clist[:0] = self.getconftestmodules(dp)
+            for parent in path.parts():
+                if self._confcutdir and self._confcutdir.relto(parent):
+                    continue
+                conftestpath = parent.join("conftest.py")
+                if conftestpath.check(file=1):
+                    mod = self.importconftest(conftestpath)
+                    clist.append(mod)
             self._path2confmods[path] = clist
-        # be defensive: avoid changes from caller side to
-        # affect us by always returning a copy of the actual list
-        return clist[:]
+            return clist
 
-    def rget(self, name, path=None):
-        mod, value = self.rget_with_confmod(name, path)
-        return value
-
-    def rget_with_confmod(self, name, path=None):
+    def rget_with_confmod(self, name, path):
         modules = self.getconftestmodules(path)
-        modules.reverse()
-        for mod in modules:
+        for mod in reversed(modules):
             try:
                 return mod, getattr(mod, name)
             except AttributeError:
@@ -207,27 +533,27 @@ class Conftest(object):
         raise KeyError(name)
 
     def importconftest(self, conftestpath):
-        assert conftestpath.check(), conftestpath
         try:
             return self._conftestpath2mod[conftestpath]
         except KeyError:
             pkgpath = conftestpath.pypkgpath()
             if pkgpath is None:
                 _ensure_removed_sysmodule(conftestpath.purebasename)
-            self._conftestpath2mod[conftestpath] = mod = conftestpath.pyimport()
+            try:
+                mod = conftestpath.pyimport()
+            except Exception:
+                raise ConftestImportFailure(conftestpath, sys.exc_info())
+            self._conftestpath2mod[conftestpath] = mod
             dirpath = conftestpath.dirpath()
             if dirpath in self._path2confmods:
                 for path, mods in self._path2confmods.items():
                     if path and path.relto(dirpath) or path == dirpath:
                         assert mod not in mods
                         mods.append(mod)
-            self._postimport(mod)
+            if self._onimport:
+                self._onimport(mod)
             return mod
 
-    def _postimport(self, mod):
-        if self._onimport:
-            self._onimport(mod)
-        return mod
 
 def _ensure_removed_sysmodule(modname):
     try:
@@ -242,31 +568,101 @@ class CmdOptions(object):
     def __repr__(self):
         return "<CmdOptions %r>" %(self.__dict__,)
 
+class Notset:
+    def __repr__(self):
+        return "<NOTSET>"
+
+notset = Notset()
+FILE_OR_DIR = 'file_or_dir'
 class Config(object):
     """ access to configuration values, pluginmanager and plugin hooks.  """
-    def __init__(self, pluginmanager=None):
-        #: command line option values, usually added via parser.addoption(...)
-        #: or parser.getgroup(...).addoption(...) calls
+
+    def __init__(self, pluginmanager):
+        #: access to command line option as attributes.
+        #: (deprecated), use :py:func:`getoption() <_pytest.config.Config.getoption>` instead
         self.option = CmdOptions()
+        _a = FILE_OR_DIR
         self._parser = Parser(
-            usage="usage: %prog [options] [file_or_dir] [file_or_dir] [...]",
+            usage="%%(prog)s [options] [%s] [%s] [...]" % (_a, _a),
             processopt=self._processopt,
         )
         #: a pluginmanager instance
-        self.pluginmanager = pluginmanager or PluginManager(load=True)
+        self.pluginmanager = pluginmanager
         self.trace = self.pluginmanager.trace.root.get("config")
         self._conftest = Conftest(onimport=self._onimportconftest)
         self.hook = self.pluginmanager.hook
         self._inicache = {}
+        self._opt2dest = {}
         self._cleanup = []
+        self.pluginmanager.register(self, "pytestconfig")
+        self.pluginmanager.set_register_callback(self._register_plugin)
+        self._configured = False
+
+    def _register_plugin(self, plugin, name):
+        call_plugin = self.pluginmanager.call_plugin
+        call_plugin(plugin, "pytest_addhooks",
+                    {'pluginmanager': self.pluginmanager})
+        self.hook.pytest_plugin_registered(plugin=plugin,
+                                           manager=self.pluginmanager)
+        dic = call_plugin(plugin, "pytest_namespace", {}) or {}
+        if dic:
+            import pytest
+            setns(pytest, dic)
+        call_plugin(plugin, "pytest_addoption", {'parser': self._parser})
+        if self._configured:
+            call_plugin(plugin, "pytest_configure", {'config': self})
+
+    def do_configure(self):
+        assert not self._configured
+        self._configured = True
+        self.hook.pytest_configure(config=self)
+
+    def do_unconfigure(self):
+        assert self._configured
+        self._configured = False
+        self.hook.pytest_unconfigure(config=self)
+        self.pluginmanager.ensure_shutdown()
+
+    def warn(self, code, message):
+        """ generate a warning for this test session. """
+        self.hook.pytest_logwarning(code=code, message=message,
+                                    fslocation=None, nodeid=None)
+
+    def get_terminal_writer(self):
+        return self.pluginmanager.getplugin("terminalreporter")._tw
+
+    def pytest_cmdline_parse(self, pluginmanager, args):
+        assert self == pluginmanager.config, (self, pluginmanager.config)
+        self.parse(args)
+        return self
+
+    def pytest_unconfigure(config):
+        while config._cleanup:
+            fin = config._cleanup.pop()
+            fin()
+
+    def notify_exception(self, excinfo, option=None):
+        if option and option.fulltrace:
+            style = "long"
+        else:
+            style = "native"
+        excrepr = excinfo.getrepr(funcargs=True,
+            showlocals=getattr(option, 'showlocals', False),
+            style=style,
+        )
+        res = self.hook.pytest_internalerror(excrepr=excrepr,
+                                             excinfo=excinfo)
+        if not py.builtin.any(res):
+            for line in str(excrepr).split("\n"):
+                sys.stderr.write("INTERNALERROR> %s\n" %line)
+                sys.stderr.flush()
+
 
     @classmethod
     def fromdictargs(cls, option_dict, args):
         """ constructor useable for subprocesses. """
-        config = cls()
-        # XXX slightly crude way to initialize capturing
-        import _pytest.capture
-        _pytest.capture.pytest_cmdline_parse(config.pluginmanager, args)
+        pluginmanager = get_plugin_manager()
+        config = pluginmanager.config
         config._preparse(args, addopts=False)
         config.option.__dict__.update(option_dict)
         for x in config.option.plugins:
@@ -278,6 +674,9 @@ class Config(object):
         self.pluginmanager.consider_conftest(conftestmodule)
 
     def _processopt(self, opt):
+        for name in opt._short_opts + opt._long_opts:
+            self._opt2dest[name] = opt.dest
+
         if hasattr(opt, 'default') and opt.dest:
             if not hasattr(self.option, opt.dest):
                 setattr(self.option, opt.dest, opt.default)
@@ -289,24 +688,20 @@ class Config(object):
         plugins += self._conftest.getconftestmodules(fspath)
         return plugins
 
-    def _setinitialconftest(self, args):
-        # capture output during conftest init (#issue93)
-        # XXX introduce load_conftest hook to avoid needing to know
-        # about capturing plugin here
-        capman = self.pluginmanager.getplugin("capturemanager")
-        capman.resumecapture()
-        try:
-            try:
-                self._conftest.setinitial(args)
-            finally:
-                out, err = capman.suspendcapture() # logging might have got it
-        except:
-            sys.stdout.write(out)
-            sys.stderr.write(err)
-            raise
+    def pytest_load_initial_conftests(self, early_config):
+        self._conftest.setinitial(early_config.known_args_namespace)
+    pytest_load_initial_conftests.trylast = True
 
     def _initini(self, args):
-        self.inicfg = getcfg(args, ["pytest.ini", "tox.ini", "setup.cfg"])
+        parsed_args = self._parser.parse_known_args(args)
+        if parsed_args.inifilename:
+            iniconfig = py.iniconfig.IniConfig(parsed_args.inifilename)
+            if 'pytest' in iniconfig.sections:
+                self.inicfg = iniconfig['pytest']
+            else:
+                self.inicfg = {}
+        else:
+            self.inicfg = getcfg(args, ["pytest.ini", "tox.ini", "setup.cfg"])
         self._parser.addini('addopts', 'extra command line options', 'args')
         self._parser.addini('minversion', 'minimally required pytest version')
 
@@ -318,12 +713,22 @@ class Config(object):
         self.pluginmanager.consider_preparse(args)
         self.pluginmanager.consider_setuptools_entrypoints()
         self.pluginmanager.consider_env()
-        self._setinitialconftest(args)
-        self.pluginmanager.do_addoption(self._parser)
-        if addopts:
-            self.hook.pytest_cmdline_preparse(config=self, args=args)
+        self.known_args_namespace = ns = self._parser.parse_known_args(args)
+        try:
+            self.hook.pytest_load_initial_conftests(early_config=self,
+                    args=args, parser=self._parser)
+        except ConftestImportFailure:
+            e = sys.exc_info()[1]
+            if ns.help or ns.version:
+                # we don't want to prevent --help/--version to work
+                # so just let is pass and print a warning at the end
+                self.pluginmanager._warnings.append(
+                        "could not load initial conftests (%s)\n" % e.path)
+            else:
+                raise
 
     def _checkversion(self):
+        import pytest
         minver = self.inicfg.get('minversion', None)
         if minver:
             ver = minver.split(".")
@@ -336,15 +741,15 @@ class Config(object):
 
     def parse(self, args):
         # parse given cmdline arguments into this config object.
-        # Note that this can only be called once per testing process.
         assert not hasattr(self, 'args'), (
                 "can only parse cmdline args at most once per Config object")
         self._origargs = args
         self._preparse(args)
-        self._parser.hints.extend(self.pluginmanager._hints)
+        # XXX deprecated hook:
+        self.hook.pytest_cmdline_preparse(config=self, args=args)
         args = self._parser.parse_setoption(args, self.option)
         if not args:
-            args.append(py.std.os.getcwd())
+            args.append(os.getcwd())
         self.args = args
 
     def addinivalue_line(self, name, line):
@@ -356,8 +761,9 @@ class Config(object):
         x.append(line) # modifies the cached list inline
 
     def getini(self, name):
-        """ return configuration value from an ini file. If the
-        specified name hasn't been registered through a prior ``parse.addini``
+        """ return configuration value from an :ref:`ini file <inifiles>`. If the
+        specified name hasn't been registered through a prior
+        :py:func:`parser.addini <pytest.config.Parser.addini>`
         call (usually from a plugin), a ValueError is raised. """
         try:
             return self._inicache[name]
@@ -381,18 +787,18 @@ class Config(object):
         if type == "pathlist":
             dp = py.path.local(self.inicfg.config.path).dirpath()
             l = []
-            for relpath in py.std.shlex.split(value):
+            for relpath in shlex.split(value):
                 l.append(dp.join(relpath, abs=True))
             return l
         elif type == "args":
-            return py.std.shlex.split(value)
+            return shlex.split(value)
         elif type == "linelist":
             return [t for t in map(lambda x: x.strip(), value.split("\n")) if t]
         else:
             assert type is None
             return value
 
-    def _getconftest_pathlist(self, name, path=None):
+    def _getconftest_pathlist(self, name, path):
         try:
             mod, relroots = self._conftest.rget_with_confmod(name, path)
         except KeyError:
@@ -406,34 +812,42 @@ class Config(object):
             l.append(relroot)
         return l
 
-    def _getconftest(self, name, path=None, check=False):
-        if check:
-            self._checkconftest(name)
-        return self._conftest.rget(name, path)
+    def getoption(self, name, default=notset, skip=False):
+        """ return command line option value.
+
+        :arg name: name of the option.  You may also specify
+            the literal ``--OPT`` option instead of the "dest" option name.
+        :arg default: default value if no option of that name exists.
+        :arg skip: if True raise pytest.skip if option does not exists
+            or has a None value.
+        """
+        name = self._opt2dest.get(name, name)
+        try:
+            val = getattr(self.option, name)
+            if val is None and skip:
+                raise AttributeError(name)
+            return val
+        except AttributeError:
+            if default is not notset:
+                return default
+            if skip:
+                import pytest
+                pytest.skip("no %r option found" %(name,))
+            raise ValueError("no option named %r" % (name,))
 
     def getvalue(self, name, path=None):
-        """ return ``name`` value looked set from command line options.
-
-        (deprecated) if we can't find the option also lookup
-        the name in a matching conftest file.
-        """
-        try:
-            return getattr(self.option, name)
-        except AttributeError:
-            return self._getconftest(name, path, check=False)
+        """ (deprecated, use getoption()) """
+        return self.getoption(name)
 
     def getvalueorskip(self, name, path=None):
-        """ (deprecated) return getvalue(name) or call
-        py.test.skip if no value exists. """
-        __tracebackhide__ = True
-        try:
-            val = self.getvalue(name, path)
-            if val is None:
-                raise KeyError(name)
-            return val
-        except KeyError:
-            py.test.skip("no %r value found" %(name,))
+        """ (deprecated, use getoption(skip=True)) """
+        return self.getoption(name, skip=True)
 
+def exists(path, ignore=EnvironmentError):
+    try:
+        return path.check()
+    except ignore:
+        return False
 
 def getcfg(args, inibasenames):
     args = [x for x in args if not str(x).startswith("-")]
@@ -444,20 +858,29 @@ def getcfg(args, inibasenames):
         for base in arg.parts(reverse=True):
             for inibasename in inibasenames:
                 p = base.join(inibasename)
-                if p.check():
+                if exists(p):
                     iniconfig = py.iniconfig.IniConfig(p)
                     if 'pytest' in iniconfig.sections:
                         return iniconfig['pytest']
     return {}
 
-def findupwards(current, basename):
-    current = py.path.local(current)
-    while 1:
-        p = current.join(basename)
-        if p.check():
-            return p
-        p = current.dirpath()
-        if p == current:
-            return
-        current = p
 
+def setns(obj, dic):
+    import pytest
+    for name, value in dic.items():
+        if isinstance(value, dict):
+            mod = getattr(obj, name, None)
+            if mod is None:
+                modname = "pytest.%s" % name
+                mod = types.ModuleType(modname)
+                sys.modules[modname] = mod
+                mod.__all__ = []
+                setattr(obj, name, mod)
+            obj.__all__.append(name)
+            setns(mod, value)
+        else:
+            setattr(obj, name, value)
+            obj.__all__.append(name)
+            #if obj != pytest:
+            #    pytest.__all__.append(name)
+            setattr(pytest, name, value)

_pytest/core.py

@@ -1,20 +1,15 @@
 """
 pytest PluginManager, basic initialization and tracing.
-(c) Holger Krekel 2004-2010
 """
-import sys, os
+import os
+import sys
 import inspect
 import py
-from _pytest import hookspec # the extension point definitions
+# don't import pytest to avoid circular imports
 
 assert py.__version__.split(".")[:2] >= ['1', '4'], ("installation problem: "
     "%s is too old, remove or upgrade 'py'" % (py.__version__))
 
-default_plugins = (
- "config mark main terminal runner python pdb unittest capture skipping "
- "tmpdir monkeypatch recwarn pastebin helpconfig nose assertion genscript "
- "junitxml resultlog doctest").split()
-
 class TagTracer:
     def __init__(self):
         self._tag2proc = {}
@@ -24,12 +19,28 @@ class TagTracer:
     def get(self, name):
         return TagTracerSub(self, (name,))
 
+    def format_message(self, tags, args):
+        if isinstance(args[-1], dict):
+            extra = args[-1]
+            args = args[:-1]
+        else:
+            extra = {}
+
+        content = " ".join(map(str, args))
+        indent = "  " * self.indent
+
+        lines = [
+            "%s%s [%s]\n" %(indent, content, ":".join(tags))
+        ]
+
+        for name, value in extra.items():
+            lines.append("%s    %s: %s\n" % (indent, name, value))
+        return lines
+
     def processmessage(self, tags, args):
-        if self.writer is not None:
-            if args:
-                indent = "  " * self.indent
-                content = " ".join(map(str, args))
-                self.writer("%s%s [%s]\n" %(indent, content, ":".join(tags)))
+        if self.writer is not None and args:
+            lines = self.format_message(tags, args)
+            self.writer(''.join(lines))
         try:
             self._tag2proc[tags](tags, args)
         except KeyError:
@@ -57,36 +68,36 @@ class TagTracerSub:
         return self.__class__(self.root, self.tags + (name,))
 
 class PluginManager(object):
-    def __init__(self, load=False):
+    def __init__(self, hookspecs=None):
         self._name2plugin = {}
         self._listattrcache = {}
         self._plugins = []
-        self._hints = []
+        self._warnings = []
         self.trace = TagTracer().get("pluginmanage")
         self._plugin_distinfo = []
-        if os.environ.get('PYTEST_DEBUG'):
-            err = sys.stderr
-            encoding = getattr(err, 'encoding', 'utf8')
-            try:
-                err = py.io.dupfile(err, encoding=encoding)
-            except Exception:
-                pass
-            self.trace.root.setwriter(err.write)
-        self.hook = HookRelay([hookspec], pm=self)
-        self.register(self)
-        if load:
-            for spec in default_plugins:
-                self.import_plugin(spec)
+        self._shutdown = []
+        self.hook = HookRelay(hookspecs or [], pm=self)
+
+    def do_configure(self, config):
+        # backward compatibility
+        config.do_configure()
+
+    def set_register_callback(self, callback):
+        assert not hasattr(self, "_registercallback")
+        self._registercallback = callback
 
     def register(self, plugin, name=None, prepend=False):
-        assert not self.isregistered(plugin), plugin
+        if self._name2plugin.get(name, None) == -1:
+            return
         name = name or getattr(plugin, '__name__', str(id(plugin)))
-        if name in self._name2plugin:
-            return False
+        if self.isregistered(plugin, name):
+            raise ValueError("Plugin already registered: %s=%s\n%s" %(
+                              name, plugin, self._name2plugin))
         #self.trace("registering", name, plugin)
         self._name2plugin[name] = plugin
-        self.call_plugin(plugin, "pytest_addhooks", {'pluginmanager': self})
-        self.hook.pytest_plugin_registered(manager=self, plugin=plugin)
+        reg = getattr(self, "_registercallback", None)
+        if reg is not None:
+            reg(plugin, name)
         if not prepend:
             self._plugins.append(plugin)
         else:
@@ -97,11 +108,21 @@ class PluginManager(object):
         if plugin is None:
             plugin = self.getplugin(name=name)
         self._plugins.remove(plugin)
-        self.hook.pytest_plugin_unregistered(plugin=plugin)
         for name, value in list(self._name2plugin.items()):
             if value == plugin:
                 del self._name2plugin[name]
 
+    def add_shutdown(self, func):
+        self._shutdown.append(func)
+
+    def ensure_shutdown(self):
+        while self._shutdown:
+            func = self._shutdown.pop()
+            func()
+        self._plugins = []
+        self._name2plugin.clear()
+        self._listattrcache.clear()
+
     def isregistered(self, plugin, name=None):
         if self.getplugin(name) is not None:
             return True
@@ -109,15 +130,16 @@ class PluginManager(object):
             if plugin == val:
                 return True
 
-    def addhooks(self, spec):
-        self.hook._addhooks(spec, prefix="pytest_")
+    def addhooks(self, spec, prefix="pytest_"):
+        self.hook._addhooks(spec, prefix=prefix)
 
     def getplugins(self):
         return list(self._plugins)
 
     def skipifmissing(self, name):
         if not self.hasplugin(name):
-            py.test.skip("plugin %r is missing" % name)
+            import pytest
+            pytest.skip("plugin %r is missing" % name)
 
     def hasplugin(self, name):
         return bool(self.getplugin(name))
@@ -133,7 +155,7 @@ class PluginManager(object):
     # API for bootstrapping
     #
     def _envlist(self, varname):
-        val = py.std.os.environ.get(varname, None)
+        val = os.environ.get(varname, None)
         if val is not None:
             return val.split(',')
         return ()
@@ -192,7 +214,6 @@ class PluginManager(object):
         if self.getplugin(modname) is not None:
             return
         try:
-            #self.trace("importing", modname)
             mod = importplugin(modname)
         except KeyboardInterrupt:
             raise
@@ -201,92 +222,15 @@ class PluginManager(object):
                 return self.import_plugin(modname[7:])
             raise
         except:
-            e = py.std.sys.exc_info()[1]
-            if not hasattr(py.test, 'skip'):
+            e = sys.exc_info()[1]
+            import pytest
+            if not hasattr(pytest, 'skip') or not isinstance(e, pytest.skip.Exception):
                 raise
-            elif not isinstance(e, py.test.skip.Exception):
-                raise
-            self._hints.append("skipped plugin %r: %s" %((modname, e.msg)))
+            self._warnings.append("skipped plugin %r: %s" %((modname, e.msg)))
         else:
             self.register(mod, modname)
             self.consider_module(mod)
 
-    def pytest_configure(self, config):
-        config.addinivalue_line("markers",
-            "tryfirst: mark a hook implementation function such that the "
-            "plugin machinery will try to call it first/as early as possible.")
-        config.addinivalue_line("markers",
-            "trylast: mark a hook implementation function such that the "
-            "plugin machinery will try to call it last/as late as possible.")
-
-    def pytest_plugin_registered(self, plugin):
-        import pytest
-        dic = self.call_plugin(plugin, "pytest_namespace", {}) or {}
-        if dic:
-            self._setns(pytest, dic)
-        if hasattr(self, '_config'):
-            self.call_plugin(plugin, "pytest_addoption",
-                {'parser': self._config._parser})
-            self.call_plugin(plugin, "pytest_configure",
-                {'config': self._config})
-
-    def _setns(self, obj, dic):
-        import pytest
-        for name, value in dic.items():
-            if isinstance(value, dict):
-                mod = getattr(obj, name, None)
-                if mod is None:
-                    modname = "pytest.%s" % name
-                    mod = py.std.types.ModuleType(modname)
-                    sys.modules[modname] = mod
-                    mod.__all__ = []
-                    setattr(obj, name, mod)
-                obj.__all__.append(name)
-                self._setns(mod, value)
-            else:
-                setattr(obj, name, value)
-                obj.__all__.append(name)
-                #if obj != pytest:
-                #    pytest.__all__.append(name)
-                setattr(pytest, name, value)
-
-    def pytest_terminal_summary(self, terminalreporter):
-        tw = terminalreporter._tw
-        if terminalreporter.config.option.traceconfig:
-            for hint in self._hints:
-                tw.line("hint: %s" % hint)
-
-    def do_addoption(self, parser):
-        mname = "pytest_addoption"
-        methods = reversed(self.listattr(mname))
-        MultiCall(methods, {'parser': parser}).execute()
-
-    def do_configure(self, config):
-        assert not hasattr(self, '_config')
-        self._config = config
-        config.hook.pytest_configure(config=self._config)
-
-    def do_unconfigure(self, config):
-        config = self._config
-        del self._config
-        config.hook.pytest_unconfigure(config=config)
-        config.pluginmanager.unregister(self)
-
-    def notify_exception(self, excinfo, option=None):
-        if option and option.fulltrace:
-            style = "long"
-        else:
-            style = "native"
-        excrepr = excinfo.getrepr(funcargs=True,
-            showlocals=getattr(option, 'showlocals', False),
-            style=style,
-        )
-        res = self.hook.pytest_internalerror(excrepr=excrepr)
-        if not py.builtin.any(res):
-            for line in str(excrepr).split("\n"):
-                sys.stderr.write("INTERNALERROR> %s\n" %line)
-                sys.stderr.flush()
-
     def listattr(self, attrname, plugins=None):
         if plugins is None:
             plugins = self._plugins
@@ -297,18 +241,22 @@ class PluginManager(object):
             pass
         l = []
         last = []
+        wrappers = []
         for plugin in plugins:
             try:
                 meth = getattr(plugin, attrname)
-                if hasattr(meth, 'tryfirst'):
-                    last.append(meth)
-                elif hasattr(meth, 'trylast'):
-                    l.insert(0, meth)
-                else:
-                    l.append(meth)
             except AttributeError:
                 continue
+            if hasattr(meth, 'hookwrapper'):
+                wrappers.append(meth)
+            elif hasattr(meth, 'tryfirst'):
+                last.append(meth)
+            elif hasattr(meth, 'trylast'):
+                l.insert(0, meth)
+            else:
+                l.append(meth)
         l.extend(last)
+        l.extend(wrappers)
         self._listattrcache[key] = list(l)
         return l
 
@@ -321,16 +269,22 @@ def importplugin(importspec):
     name = importspec
     try:
         mod = "_pytest." + name
-        return __import__(mod, None, None, '__doc__')
+        __import__(mod)
+        return sys.modules[mod]
     except ImportError:
-        #e = py.std.sys.exc_info()[1]
-        #if str(e).find(name) == -1:
-        #    raise
-        pass #
-    return __import__(importspec, None, None, '__doc__')
+        __import__(importspec)
+        return sys.modules[importspec]
 
 class MultiCall:
     """ execute a call into multiple python functions/methods. """
+
+    class WrongHookWrapper(Exception):
+        """ a hook wrapper does not behave correctly. """
+        def __init__(self, func, message):
+            Exception.__init__(self, func, message)
+            self.func = func
+            self.message = message
+
     def __init__(self, methods, kwargs, firstresult=False):
         self.methods = list(methods)
         self.kwargs = kwargs
@@ -342,16 +296,39 @@ class MultiCall:
         return "<MultiCall %s, kwargs=%r>" %(status, self.kwargs)
 
     def execute(self):
-        while self.methods:
-            method = self.methods.pop()
-            kwargs = self.getkwargs(method)
-            res = method(**kwargs)
-            if res is not None:
-                self.results.append(res)
-                if self.firstresult:
-                    return res
-        if not self.firstresult:
-            return self.results
+        next_finalizers = []
+        try:
+            while self.methods:
+                method = self.methods.pop()
+                kwargs = self.getkwargs(method)
+                if hasattr(method, "hookwrapper"):
+                    it = method(**kwargs)
+                    next = getattr(it, "next", None)
+                    if next is None:
+                        next = getattr(it, "__next__", None)
+                        if next is None:
+                            raise self.WrongHookWrapper(method,
+                                "wrapper does not contain a yield")
+                    res = next()
+                    next_finalizers.append((method, next))
+                else:
+                    res = method(**kwargs)
+                if res is not None:
+                    self.results.append(res)
+                    if self.firstresult:
+                        return res
+            if not self.firstresult:
+                return self.results
+        finally:
+            for method, fin in reversed(next_finalizers):
+                try:
+                    fin()
+                except StopIteration:
+                    pass
+                else:
+                    raise self.WrongHookWrapper(method,
+                                "wrapper contain more than one yield")
+
 
     def getkwargs(self, method):
         kwargs = {}
@@ -364,19 +341,36 @@ class MultiCall:
         return kwargs
 
 def varnames(func):
+    """ return argument name tuple for a function, method, class or callable.
+
+    In case of a class, its "__init__" method is considered.
+    For methods the "self" parameter is not included unless you are passing
+    an unbound method with Python3 (which has no supports for unbound methods)
+    """
+    cache = getattr(func, "__dict__", {})
     try:
-        return func._varnames
-    except AttributeError:
+        return cache["_varnames"]
+    except KeyError:
         pass
-    if not inspect.isfunction(func) and not inspect.ismethod(func):
-        func = getattr(func, '__call__', func)
-    ismethod = inspect.ismethod(func)
+    if inspect.isclass(func):
+        try:
+            func = func.__init__
+        except AttributeError:
+            return ()
+        ismethod = True
+    else:
+        if not inspect.isfunction(func) and not inspect.ismethod(func):
+            func = getattr(func, '__call__', func)
+        ismethod = inspect.ismethod(func)
     rawcode = py.code.getrawcode(func)
     try:
         x = rawcode.co_varnames[ismethod:rawcode.co_argcount]
     except AttributeError:
         x = ()
-    py.builtin._getfuncdict(func)['_varnames'] = x
+    try:
+        cache["_varnames"] = x
+    except TypeError:
+        pass
     return x
 
 class HookRelay:
@@ -434,44 +428,3 @@ class HookCaller:
             self.trace.root.indent -= 1
         return res
 
-_preinit = []
-
-def _preloadplugins():
-    _preinit.append(PluginManager(load=True))
-
-def _prepareconfig(args=None, plugins=None):
-    if args is None:
-        args = sys.argv[1:]
-    elif isinstance(args, py.path.local):
-        args = [str(args)]
-    elif not isinstance(args, (tuple, list)):
-        if not isinstance(args, str):
-            raise ValueError("not a string or argument list: %r" % (args,))
-        args = py.std.shlex.split(args)
-    if _preinit:
-       _pluginmanager = _preinit.pop(0)
-    else: # subsequent calls to main will create a fresh instance
-        _pluginmanager = PluginManager(load=True)
-    hook = _pluginmanager.hook
-    if plugins:
-        for plugin in plugins:
-            _pluginmanager.register(plugin)
-    return hook.pytest_cmdline_parse(
-            pluginmanager=_pluginmanager, args=args)
-
-def main(args=None, plugins=None):
-    """ returned exit code integer, after an in-process testing run
-    with the given command line arguments, preloading an optional list
-    of passed in plugin objects. """
-    try:
-        config = _prepareconfig(args, plugins)
-        exitstatus = config.hook.pytest_cmdline_main(config=config)
-    except UsageError:
-        e = sys.exc_info()[1]
-        sys.stderr.write("ERROR: %s\n" %(e.args[0],))
-        exitstatus = 3
-    return exitstatus
-
-class UsageError(Exception):
-    """ error in py.test usage or invocation"""
-

_pytest/doctest.py

@@ -1,6 +1,8 @@
 """ discover and run doctests in modules and test files."""
-
+from __future__ import absolute_import
+import traceback
 import pytest, py
+from _pytest.python import FixtureRequest, FuncFixtureInfo
 from py._code.code import TerminalRepr, ReprFileLocation
 
 def pytest_addoption(parser):
@@ -33,25 +35,43 @@ class ReprFailDoctest(TerminalRepr):
         self.reprlocation.toterminal(tw)
 
 class DoctestItem(pytest.Item):
+    def __init__(self, name, parent, runner=None, dtest=None):
+        super(DoctestItem, self).__init__(name, parent)
+        self.runner = runner
+        self.dtest = dtest
+
+    def runtest(self):
+        self.runner.run(self.dtest)
+
     def repr_failure(self, excinfo):
-        doctest = py.std.doctest
+        import doctest
         if excinfo.errisinstance((doctest.DocTestFailure,
                                   doctest.UnexpectedException)):
             doctestfailure = excinfo.value
             example = doctestfailure.example
             test = doctestfailure.test
             filename = test.filename
-            lineno = test.lineno + example.lineno + 1
+            if test.lineno is None:
+                lineno = None
+            else:
+                lineno = test.lineno + example.lineno + 1
             message = excinfo.type.__name__
             reprlocation = ReprFileLocation(filename, lineno, message)
-            checker = py.std.doctest.OutputChecker()
-            REPORT_UDIFF = py.std.doctest.REPORT_UDIFF
+            checker = doctest.OutputChecker()
+            REPORT_UDIFF = doctest.REPORT_UDIFF
             filelines = py.path.local(filename).readlines(cr=0)
-            i = max(test.lineno, max(0, lineno - 10)) # XXX?
             lines = []
-            for line in filelines[i:lineno]:
-                lines.append("%03d %s" % (i+1, line))
-                i += 1
+            if lineno is not None:
+                i = max(test.lineno, max(0, lineno - 10)) # XXX?
+                for line in filelines[i:lineno]:
+                    lines.append("%03d %s" % (i+1, line))
+                    i += 1
+            else:
+                lines.append('EXAMPLE LOCATION UNKNOWN, not showing all tests of that example')
+                indent = '>>>'
+                for line in example.source.splitlines():
+                    lines.append('??? %s %s' % (indent, line))
+                    indent = '...'
             if excinfo.errisinstance(doctest.DocTestFailure):
                 lines += checker.output_difference(example,
                         doctestfailure.got, REPORT_UDIFF).split("\n")
@@ -59,29 +79,48 @@ class DoctestItem(pytest.Item):
                 inner_excinfo = py.code.ExceptionInfo(excinfo.value.exc_info)
                 lines += ["UNEXPECTED EXCEPTION: %s" %
                             repr(inner_excinfo.value)]
-                lines += py.std.traceback.format_exception(*excinfo.value.exc_info)
+                lines += traceback.format_exception(*excinfo.value.exc_info)
             return ReprFailDoctest(reprlocation, lines)
         else:
             return super(DoctestItem, self).repr_failure(excinfo)
 
     def reportinfo(self):
-        return self.fspath, None, "[doctest]"
+        return self.fspath, None, "[doctest] %s" % self.name
 
 class DoctestTextfile(DoctestItem, pytest.File):
     def runtest(self):
-        doctest = py.std.doctest
+        import doctest
+        # satisfy `FixtureRequest` constructor...
+        self.funcargs = {}
+        fm = self.session._fixturemanager
+        def func():
+            pass
+        self._fixtureinfo = fm.getfixtureinfo(node=self, func=func,
+                                              cls=None, funcargs=False)
+        fixture_request = FixtureRequest(self)
+        fixture_request._fillfixtures()
         failed, tot = doctest.testfile(
             str(self.fspath), module_relative=False,
             optionflags=doctest.ELLIPSIS,
+            extraglobs=dict(getfixture=fixture_request.getfuncargvalue),
             raise_on_error=True, verbose=0)
 
-class DoctestModule(DoctestItem, pytest.File):
-    def runtest(self):
-        doctest = py.std.doctest
+class DoctestModule(pytest.File):
+    def collect(self):
+        import doctest
         if self.fspath.basename == "conftest.py":
             module = self.config._conftest.importconftest(self.fspath)
         else:
             module = self.fspath.pyimport()
-        failed, tot = doctest.testmod(
-            module, raise_on_error=True, verbose=0,
-            optionflags=doctest.ELLIPSIS)
+        # satisfy `FixtureRequest` constructor...
+        self.funcargs = {}
+        self._fixtureinfo = FuncFixtureInfo((), [], {})
+        fixture_request = FixtureRequest(self)
+        doctest_globals = dict(getfixture=fixture_request.getfuncargvalue)
+        # uses internal doctest module parsing mechanism
+        finder = doctest.DocTestFinder()
+        runner = doctest.DebugRunner(verbose=0, optionflags=doctest.ELLIPSIS)
+        for test in finder.find(module, module.__name__,
+                                extraglobs=doctest_globals):
+            if test.examples: # skip empty doctests
+                yield DoctestItem(test.name, self, runner, test)

_pytest/genscript.py

@@ -1,8 +1,16 @@
-""" generate a single-file self-contained version of py.test """
+""" generate a single-file self-contained version of pytest """
+import os
+import sys
+import pkgutil
+
 import py
 
+import _pytest
+
+
+
 def find_toplevel(name):
-    for syspath in py.std.sys.path:
+    for syspath in sys.path:
         base = py.path.local(syspath)
         lib = base/name
         if lib.check(dir=1):
@@ -28,9 +36,10 @@ def pkg_to_mapping(name):
     return name2src
 
 def compress_mapping(mapping):
-    data = py.std.pickle.dumps(mapping, 2)
-    data = py.std.zlib.compress(data, 9)
-    data = py.std.base64.encodestring(data)
+    import base64, pickle, zlib
+    data = pickle.dumps(mapping, 2)
+    data = zlib.compress(data, 9)
+    data = base64.encodestring(data)
     data = data.decode('ascii')
     return data
 
@@ -54,16 +63,65 @@ def pytest_addoption(parser):
     group = parser.getgroup("debugconfig")
     group.addoption("--genscript", action="store", default=None,
         dest="genscript", metavar="path",
-        help="create standalone py.test script at given target path.")
+        help="create standalone pytest script at given target path.")
 
 def pytest_cmdline_main(config):
     genscript = config.getvalue("genscript")
     if genscript:
+        tw = py.io.TerminalWriter()
+        deps =  ['py', '_pytest', 'pytest']
+        if sys.version_info < (2,7):
+            deps.append("argparse")
+            tw.line("generated script will run on python2.6-python3.3++")
+        else:
+            tw.line("WARNING: generated script will not run on python2.6 "
+                    "due to 'argparse' dependency. Use python2.6 "
+                    "to generate a python2.6 compatible script", red=True)
         script = generate_script(
-            'import py; raise SystemExit(py.test.cmdline.main())',
-            ['py', '_pytest', 'pytest'],
+            'import pytest; raise SystemExit(pytest.cmdline.main())',
+            deps,
         )
-
         genscript = py.path.local(genscript)
         genscript.write(script)
+        tw.line("generated pytest standalone script: %s" % genscript,
+                bold=True)
         return 0
+
+
+def pytest_namespace():
+    return {'freeze_includes': freeze_includes}
+
+
+def freeze_includes():
+    """
+    Returns a list of module names used by py.test that should be
+    included by cx_freeze.
+    """
+    result = list(_iter_all_modules(py))
+    result += list(_iter_all_modules(_pytest))
+    return result
+
+
+def _iter_all_modules(package, prefix=''):
+    """
+    Iterates over the names of all modules that can be found in the given
+    package, recursively.
+
+    Example:
+        _iter_all_modules(_pytest) ->
+            ['_pytest.assertion.newinterpret',
+             '_pytest.capture',
+             '_pytest.core',
+             ...
+            ]
+    """
+    if type(package) is not str:
+        path, prefix = package.__path__[0], package.__name__ + '.'
+    else:
+        path = package
+    for _, name, is_package in pkgutil.iter_modules([path]):
+        if is_package:
+            for m in _iter_all_modules(os.path.join(path, name), prefix=name + '.'):
+                yield prefix + m
+        else:
+            yield prefix + name

_pytest/helpconfig.py

@@ -12,9 +12,11 @@ def pytest_addoption(parser):
             help="show help message and configuration info")
     group._addoption('-p', action="append", dest="plugins", default = [],
                metavar="name",
-               help="early-load given plugin (multi-allowed).")
-    group.addoption('--traceconfig',
-               action="store_true", dest="traceconfig", default=False,
+               help="early-load given plugin (multi-allowed). "
+                    "To avoid loading of plugins, use the `no:` prefix, e.g. "
+                    "`no:doctest`.")
+    group.addoption('--traceconfig', '--trace-config',
+               action="store_true", default=False,
                help="trace considerations of conftest.py files."),
     group.addoption('--debug',
                action="store_true", dest="debug", default=False,
@@ -46,7 +48,7 @@ def pytest_unconfigure(config):
 def pytest_cmdline_main(config):
     if config.option.version:
         p = py.path.local(pytest.__file__)
-        sys.stderr.write("This is py.test version %s, imported from %s\n" %
+        sys.stderr.write("This is pytest version %s, imported from %s\n" %
             (pytest.__version__, p))
         plugininfo = getpluginversioninfo(config)
         if plugininfo:
@@ -54,9 +56,9 @@ def pytest_cmdline_main(config):
                 sys.stderr.write(line + "\n")
         return 0
     elif config.option.help:
-        config.pluginmanager.do_configure(config)
+        config.do_configure()
         showhelp(config)
-        config.pluginmanager.do_unconfigure(config)
+        config.do_unconfigure()
         return 0
 
 def showhelp(config):
@@ -79,16 +81,14 @@ def showhelp(config):
 
     tw.line() ; tw.line()
     #tw.sep("=")
+    tw.line("to see available markers type: py.test --markers")
+    tw.line("to see available fixtures type: py.test --fixtures")
+    tw.line("(shown according to specified file_or_dir or current dir "
+            "if not specified)")
+    for warning in config.pluginmanager._warnings:
+        tw.line("warning: %s" % (warning,), red=True)
     return
 
-    tw.line("conftest.py options:")
-    tw.line()
-    conftestitems = sorted(config._parser._conftestdict.items())
-    for name, help in conftest_options + conftestitems:
-        line = "   %-15s  %s" %(name, help)
-        tw.line(line[:tw.fullwidth])
-    tw.line()
-    #tw.sep( "=")
 
 conftest_options = [
     ('pytest_plugins', 'list of plugin names to load'),
@@ -117,7 +117,6 @@ def pytest_report_header(config):
 
     if config.option.traceconfig:
         lines.append("active plugins:")
-        plugins = []
         items = config.pluginmanager._name2plugin.items()
         for name, plugin in items:
             if hasattr(plugin, '__file__'):

_pytest/hookspec.py

@@ -11,8 +11,8 @@ def pytest_addhooks(pluginmanager):
 
 def pytest_namespace():
     """return dict of name->object to be made globally available in
-    the py.test/pytest namespace.  This hook is called before command
-    line options are parsed.
+    the pytest namespace.  This hook is called before command line options
+    are parsed.
     """
 
 def pytest_cmdline_parse(pluginmanager, args):
@@ -20,11 +20,31 @@ def pytest_cmdline_parse(pluginmanager, args):
 pytest_cmdline_parse.firstresult = True
 
 def pytest_cmdline_preparse(config, args):
-    """modify command line arguments before option parsing. """
+    """(deprecated) modify command line arguments before option parsing. """
 
 def pytest_addoption(parser):
-    """add optparse-style options and ini-style config values via calls
-    to ``parser.addoption`` and ``parser.addini(...)``.
+    """register argparse-style options and ini-style config values.
+
+    This function must be implemented in a :ref:`plugin <pluginorder>` and is
+    called once at the beginning of a test run.
+
+    :arg parser: To add command line options, call
+        :py:func:`parser.addoption(...) <_pytest.config.Parser.addoption>`.
+        To add ini-file values call :py:func:`parser.addini(...)
+        <_pytest.config.Parser.addini>`.
+
+    Options can later be accessed through the
+    :py:class:`config <_pytest.config.Config>` object, respectively:
+
+    - :py:func:`config.getoption(name) <_pytest.config.Config.getoption>` to
+      retrieve the value of a command line option.
+
+    - :py:func:`config.getini(name) <_pytest.config.Config.getini>` to retrieve
+      a value read from an ini-style file.
+
+    The config object is passed around on many internal objects via the ``.config``
+    attribute or can be retrieved as the ``pytestconfig`` fixture or accessed
+    via (deprecated) ``pytest.config``.
     """
 
 def pytest_cmdline_main(config):
@@ -32,8 +52,12 @@ def pytest_cmdline_main(config):
     implementation will invoke the configure hooks and runtest_mainloop. """
 pytest_cmdline_main.firstresult = True
 
+def pytest_load_initial_conftests(args, early_config, parser):
+    """ implements the loading of initial conftest files ahead
+    of command line option parsing. """
+
 def pytest_configure(config):
-    """ called after command line options have been parsed.
+    """ called after command line options have been parsed
         and all plugins and initial conftest files been loaded.
     """
 
@@ -121,16 +145,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 nextitem: 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 +169,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 nextitem: 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 +189,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
 # -------------------------------------------------------------------------
@@ -188,7 +217,7 @@ def pytest_assertrepr_compare(config, op, left, right):
 # hooks for influencing reporting (invoked from _pytest_terminal)
 # -------------------------------------------------------------------------
 
-def pytest_report_header(config):
+def pytest_report_header(config, startdir):
     """ return a string to be displayed as header info for terminal reporting."""
 
 def pytest_report_teststatus(report):
@@ -196,7 +225,12 @@ def pytest_report_teststatus(report):
 pytest_report_teststatus.firstresult = True
 
 def pytest_terminal_summary(terminalreporter):
-    """ add additional section in terminal summary reporting. """
+    """ add additional section in terminal summary reporting.  """
+
+def pytest_logwarning(message, code, nodeid, fslocation):
+    """ process a warning specified by a message, a code string,
+    a nodeid and fslocation (both of which may be None
+    if the warning is not tied to a partilar node/location)."""
 
 # -------------------------------------------------------------------------
 # doctest hooks
@@ -211,13 +245,22 @@ pytest_doctest_prepare_content.firstresult = True
 # -------------------------------------------------------------------------
 
 def pytest_plugin_registered(plugin, manager):
-    """ a new py lib plugin got registered. """
+    """ a new pytest plugin got registered. """
 
-def pytest_plugin_unregistered(plugin):
-    """ a py lib plugin got unregistered. """
-
-def pytest_internalerror(excrepr):
+def pytest_internalerror(excrepr, excinfo):
     """ called for internal errors. """
 
 def pytest_keyboard_interrupt(excinfo):
     """ called for keyboard interrupt. """
+
+def pytest_exception_interact(node, call, report):
+    """ (experimental, new in 2.4) called when
+    an exception was raised which can potentially be
+    interactively handled.
+
+    This hook is only called if an exception was raised
+    that is not an internal exception like "skip.Exception".
+    """
+
+def pytest_enter_pdb():
+    """ called upon pdb.set_trace()"""

_pytest/impl

@@ -0,0 +1,254 @@
+Sorting per-resource
+-----------------------------
+
+for any given set of items:
+
+- collect items per session-scoped parametrized funcarg
+- re-order until items no parametrizations are mixed
+
+  examples:
+
+        test()
+        test1(s1)
+        test1(s2)     
+        test2()
+        test3(s1)
+        test3(s2)
+
+  gets sorted to:
+
+        test()
+        test2()
+        test1(s1)
+        test3(s1)
+        test1(s2)
+        test3(s2)
+ 
+
+the new @setup functions 
+--------------------------------------
+
+Consider a given @setup-marked function::
+
+    @pytest.mark.setup(maxscope=SCOPE)
+    def mysetup(request, arg1, arg2, ...)
+        ...
+        request.addfinalizer(fin)
+        ...
+
+then FUNCARGSET denotes the set of (arg1, arg2, ...) funcargs and
+all of its dependent funcargs.  The mysetup function will execute
+for any matching test item once per scope.  
+
+The scope is determined as the minimum scope of all scopes of the args
+in FUNCARGSET and the given "maxscope". 
+
+If mysetup has been called and no finalizers have been called it is
+called "active".
+
+Furthermore the following rules apply:
+
+- if an arg value in FUNCARGSET is about to be torn down, the 
+  mysetup-registered finalizers will execute as well.
+
+- There will never be two active mysetup invocations.
+
+Example 1, session scope::
+
+    @pytest.mark.funcarg(scope="session", params=[1,2])
+    def db(request):
+        request.addfinalizer(db_finalize)
+
+    @pytest.mark.setup
+    def mysetup(request, db):
+        request.addfinalizer(mysetup_finalize)
+        ...
+
+And a given test module:
+
+    def test_something():
+        ...
+    def test_otherthing():
+        pass
+
+Here is what happens::
+
+    db(request) executes with request.param == 1
+        mysetup(request, db) executes
+            test_something() executes
+            test_otherthing() executes
+            mysetup_finalize() executes
+    db_finalize() executes
+    db(request) executes with request.param == 2
+        mysetup(request, db) executes
+            test_something() executes
+            test_otherthing() executes
+        mysetup_finalize() executes
+    db_finalize() executes
+
+Example 2, session/function scope::
+
+    @pytest.mark.funcarg(scope="session", params=[1,2])
+    def db(request):
+        request.addfinalizer(db_finalize)
+
+    @pytest.mark.setup(scope="function")
+    def mysetup(request, db):
+        ...
+        request.addfinalizer(mysetup_finalize)
+        ...
+
+And a given test module:
+
+    def test_something():
+        ...
+    def test_otherthing():
+        pass
+
+Here is what happens::
+
+    db(request) executes with request.param == 1
+        mysetup(request, db) executes
+            test_something() executes
+        mysetup_finalize() executes
+        mysetup(request, db) executes
+            test_otherthing() executes
+        mysetup_finalize() executes
+    db_finalize() executes
+    db(request) executes with request.param == 2
+        mysetup(request, db) executes
+            test_something() executes
+        mysetup_finalize() executes
+        mysetup(request, db) executes
+            test_otherthing() executes
+        mysetup_finalize() executes
+    db_finalize() executes
+
+
+Example 3 - funcargs session-mix
+----------------------------------------
+
+Similar with funcargs, an example::
+
+    @pytest.mark.funcarg(scope="session", params=[1,2])
+    def db(request):
+        request.addfinalizer(db_finalize)
+
+    @pytest.mark.funcarg(scope="function")
+    def table(request, db):
+        ...
+        request.addfinalizer(table_finalize)
+        ...
+
+And a given test module:
+
+    def test_something(table):
+        ...
+    def test_otherthing(table):
+        pass
+    def test_thirdthing():
+        pass
+
+Here is what happens::
+
+    db(request) executes with param == 1
+        table(request, db)
+            test_something(table)
+        table_finalize()
+        table(request, db)
+            test_otherthing(table)
+        table_finalize()
+    db_finalize
+    db(request) executes with param == 2
+        table(request, db)
+            test_something(table)
+        table_finalize()
+        table(request, db)
+            test_otherthing(table)
+        table_finalize()
+    db_finalize
+    test_thirdthing()
+    
+Data structures
+--------------------
+
+pytest internally maintains a dict of active funcargs with cache, param,
+finalizer, (scopeitem?) information:
+
+    active_funcargs = dict()
+
+if a parametrized "db" is activated:
+    
+    active_funcargs["db"] = FuncargInfo(dbvalue, paramindex, 
+                                        FuncargFinalize(...), scopeitem)
+
+if a test is torn down and the next test requires a differently 
+parametrized "db":
+
+    for argname in item.callspec.params:
+        if argname in active_funcargs:
+            funcarginfo = active_funcargs[argname]
+            if funcarginfo.param != item.callspec.params[argname]:
+                funcarginfo.callfinalizer()
+                del node2funcarg[funcarginfo.scopeitem]
+                del active_funcargs[argname]
+    nodes_to_be_torn_down = ...
+    for node in nodes_to_be_torn_down:
+        if node in node2funcarg:
+            argname = node2funcarg[node]
+            active_funcargs[argname].callfinalizer()
+            del node2funcarg[node]
+            del active_funcargs[argname]
+
+if a test is setup requiring a "db" funcarg:
+
+    if "db" in active_funcargs:
+        return active_funcargs["db"][0]
+    funcarginfo = setup_funcarg()
+    active_funcargs["db"] = funcarginfo
+    node2funcarg[funcarginfo.scopeitem] = "db"
+
+Implementation plan for resources
+------------------------------------------
+
+1. Revert FuncargRequest to the old form, unmerge item/request
+   (done)
+2. make funcarg factories be discovered at collection time
+3. Introduce funcarg marker
+4. Introduce funcarg scope parameter
+5. Introduce funcarg parametrize parameter
+6. make setup functions be discovered at collection time
+7. (Introduce a pytest_fixture_protocol/setup_funcargs hook)
+
+methods and data structures
+--------------------------------
+
+A FuncarcManager holds all information about funcarg definitions
+including parametrization and scope definitions.  It implements
+a pytest_generate_tests hook which performs parametrization as appropriate.
+
+as a simple example, let's consider a tree where a test function requires
+a "abc" funcarg and its factory defines it as parametrized and scoped
+for Modules.  When collections hits the function item, it creates
+the metafunc object, and calls funcargdb.pytest_generate_tests(metafunc)
+which looks up available funcarg factories and their scope and parametrization.
+This information is equivalent to what can be provided today directly
+at the function site and it should thus be relatively straight forward
+to implement the additional way of defining parametrization/scoping.
+
+conftest loading:
+    each funcarg-factory will populate the session.funcargmanager
+
+When a test item is collected, it grows a dictionary 
+(funcargname2factorycalllist).  A factory lookup is performed 
+for each required funcarg.  The resulting factory call is stored 
+with the item.  If a function is parametrized multiple items are 
+created with respective factory calls. Else if a factory is parametrized
+multiple items and calls to the factory function are created as well.
+
+At setup time, an item populates a funcargs mapping, mapping names
+to values.  If a value is funcarg factories are queried for a given item
+test functions and setup functions are put in a class
+which looks up required funcarg factories.
+
+

_pytest/junitxml.py

@@ -2,57 +2,68 @@
 
 Based on initial code from Ross Lawley.
 """
-
 import py
 import os
 import re
 import sys
 import time
 
-
 # Python 2.X and 3.X compatibility
-try:
-    unichr(65)
-except NameError:
+if sys.version_info[0] < 3:
+    from codecs import open
+else:
     unichr = chr
-try:
-    unicode('A')
-except NameError:
     unicode = str
-try:
-    long(1)
-except NameError:
     long = int
 
+class Junit(py.xml.Namespace):
+    pass
+
 
 # We need to get the subset of the invalid unicode ranges according to
 # XML 1.0 which are valid in this python build.  Hence we calculate
 # this dynamically instead of hardcoding it.  The spec range of valid
 # chars is: Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
 #                    | [#x10000-#x10FFFF]
-_illegal_unichrs = [(0x00, 0x08), (0x0B, 0x0C), (0x0E, 0x19),
-                   (0xD800, 0xDFFF), (0xFDD0, 0xFFFF)]
-_illegal_ranges = [unicode("%s-%s") % (unichr(low), unichr(high))
-                  for (low, high) in _illegal_unichrs
+_legal_chars = (0x09, 0x0A, 0x0d)
+_legal_ranges = (
+    (0x20, 0x7E),
+    (0x80, 0xD7FF),
+    (0xE000, 0xFFFD),
+    (0x10000, 0x10FFFF),
+)
+_legal_xml_re = [unicode("%s-%s") % (unichr(low), unichr(high))
+                  for (low, high) in _legal_ranges
                   if low < sys.maxunicode]
-illegal_xml_re = re.compile(unicode('[%s]') %
-                            unicode('').join(_illegal_ranges))
-del _illegal_unichrs
-del _illegal_ranges
+_legal_xml_re = [unichr(x) for x in _legal_chars] + _legal_xml_re
+illegal_xml_re = re.compile(unicode('[^%s]') %
+                            unicode('').join(_legal_xml_re))
+del _legal_chars
+del _legal_ranges
+del _legal_xml_re
 
+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 py.xml.raw(illegal_xml_re.sub(repl, py.xml.escape(arg)))
 
 def pytest_addoption(parser):
     group = parser.getgroup("terminal reporting")
-    group.addoption('--junitxml', action="store", dest="xmlpath",
-           metavar="path", default=None,
+    group.addoption('--junitxml', '--junit-xml', action="store",
+           dest="xmlpath", metavar="path", default=None,
            help="create junit-xml style report file at given path.")
-    group.addoption('--junitprefix', action="store", dest="junitprefix",
+    group.addoption('--junitprefix', '--junit-prefix', action="store",
            metavar="str", default=None,
            help="prepend prefix to classnames in junit-xml output")
 
 def pytest_configure(config):
     xmlpath = config.option.xmlpath
-    if xmlpath:
+    # prevent opening xmllog on slave nodes (xdist)
+    if xmlpath and not hasattr(config, 'slaveinput'):
         config._xml = LogXML(xmlpath, config.option.junitprefix)
         config.pluginmanager.register(config._xml)
 
@@ -63,157 +74,145 @@ def pytest_unconfigure(config):
         config.pluginmanager.unregister(xml)
 
 
+def mangle_testnames(names):
+    names = [x.replace(".py", "") for x in names if x != '()']
+    names[0] = names[0].replace("/", '.')
+    return names
+
 class LogXML(object):
     def __init__(self, logfile, prefix):
         logfile = os.path.expanduser(os.path.expandvars(logfile))
-        self.logfile = os.path.normpath(logfile)
+        self.logfile = os.path.normpath(os.path.abspath(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 != "()"]
+        names = mangle_testnames(report.nodeid.split("::"))
         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=bin_xml_escape(names[-1]),
+            time=getattr(report, 'duration', 0)
+        ))
 
-    def _closetestcase(self):
-        self.test_logs.append("</testcase>")
+    def _write_captured_output(self, report):
+        for capname in ('out', 'err'):
+            allcontent = ""
+            for name, content in report.get_sections("Captured std%s" %
+                                                    capname):
+                allcontent += content
+            if allcontent:
+                tag = getattr(Junit, 'system-'+capname)
+                self.append(tag(bin_xml_escape(allcontent)))
 
-    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()
+        self._write_captured_output(report)
 
     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"/>')
+        if hasattr(report, "wasxfail"):
+            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)
-            for name in ('out', 'err'):
-                content = sec.get("Captured std%s" % name)
-                if content:
-                    self.appendlog(
-                        "<system-%s>%%s</system-%s>" % (name, name), content)
+            fail = Junit.failure(message="test failure")
+            fail.append(bin_xml_escape(report.longrepr))
+            self.append(fail)
             self.failed += 1
-        self._closetestcase()
+        self._write_captured_output(report)
 
-    def append_collect_failure(self, report):
-        self._opentestcase(report)
+    def append_collect_error(self, report):
         #msg = str(report.longrepr.reprtraceback.extraline)
-        self.appendlog('<failure message="collection failure">%s</failure>',
-            report.longrepr)
-        self._closetestcase()
+        self.append(Junit.error(bin_xml_escape(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(bin_xml_escape(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(bin_xml_escape(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'])
+        if hasattr(report, "wasxfail"):
+            self.append(Junit.skipped(bin_xml_escape(report.wasxfail),
+                                      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()
+                skipreason = bin_xml_escape(skipreason[9:])
+            self.append(
+                Junit.skipped("%s:%s: %s" % (filename, lineno, skipreason),
+                              type="pytest.skip",
+                              message=skipreason
+                ))
         self.skipped += 1
+        self._write_captured_output(report)
 
     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)
+                self.append_collect_error(report)
             else:
                 self.append_collect_skipped(report)
 
     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)
+        data = bin_xml_escape(excrepr)
+        self.tests.append(
+            Junit.testcase(
+                    Junit.error(data, message="internal error"),
+                    classname="pytest",
+                    name="internal"))
 
-    def pytest_sessionstart(self, session):
+    def pytest_sessionstart(self):
         self.suite_start_time = time.time()
 
-    def pytest_sessionfinish(self, session, exitstatus, __multicall__):
-        if py.std.sys.version_info[0] < 3:
-            logfile = py.std.codecs.open(self.logfile, 'w', encoding='utf-8')
-        else:
-            logfile = open(self.logfile, 'w', encoding='utf-8')
-
+    def pytest_sessionfinish(self):
+        logfile = open(self.logfile, 'w', encoding='utf-8')
         suite_stop_time = time.time()
         suite_time_delta = suite_stop_time - self.suite_start_time
         numtests = self.passed + self.failed
+
         logfile.write('<?xml version="1.0" encoding="utf-8"?>')
-        logfile.write('<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="pytest",
+            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

@@ -1,8 +1,16 @@
 """ core implementation of testing process: init, session, runtest loop. """
+import re
 
 import py
 import pytest, _pytest
 import os, sys, imp
+try:
+    from collections import MutableMapping as MappingMixin
+except ImportError:
+    from UserDict import DictMixin as MappingMixin
+
+from _pytest.runner import collect_one_node
+
 tracebackcutdir = py.path.local(_pytest.__file__).dirpath()
 
 # exitcodes for the command line
@@ -10,12 +18,13 @@ EXIT_OK = 0
 EXIT_TESTSFAILED = 1
 EXIT_INTERRUPTED = 2
 EXIT_INTERNALERROR = 3
+EXIT_USAGEERROR = 4
 
-name_re = py.std.re.compile("^[a-zA-Z_]\w*$")
+name_re = re.compile("^[a-zA-Z_]\w*$")
 
 def pytest_addoption(parser):
     parser.addini("norecursedirs", "directory patterns to avoid for recursion",
-        type="args", default=('.*', 'CVS', '_darcs', '{arch}'))
+        type="args", default=('.*', 'CVS', '_darcs', '{arch}', '*.egg'))
     #parser.addini("dirpatterns",
     #    "patterns specifying possible locations of test files",
     #    type="linelist", default=["**/test_*.txt",
@@ -26,20 +35,22 @@ def pytest_addoption(parser):
                dest="exitfirst",
                help="exit instantly on first error or failed test."),
     group._addoption('--maxfail', metavar="num",
-               action="store", type="int", dest="maxfail", default=0,
+               action="store", type=int, dest="maxfail", default=0,
                help="exit after first num failures or errors.")
-
     group._addoption('--strict', action="store_true",
                help="run pytest in strict mode, warnings become errors.")
+    group._addoption("-c", metavar="file", type=str, dest="inifilename",
+               help="load configuration from `file` instead of trying to locate one of the implicit configuration files.")
 
     group = parser.getgroup("collect", "collection")
-    group.addoption('--collectonly',
-        action="store_true", dest="collectonly",
+    group.addoption('--collectonly', '--collect-only', action="store_true",
         help="only collect tests, don't execute them."),
     group.addoption('--pyargs', action="store_true",
         help="try to interpret all arguments as python packages.")
     group.addoption("--ignore", action="append", metavar="path",
         help="ignore path during collection (multi-allowed).")
+    # when changing this to --conf-cut-dir, config.py Conftest.setinitial
+    # needs upgrading as well
     group.addoption('--confcutdir', dest="confcutdir", default=None,
         metavar="dir",
         help="only load conftest.py's relative to specified dir.")
@@ -55,7 +66,7 @@ def pytest_namespace():
     return dict(collect=collect)
 
 def pytest_configure(config):
-    py.test.config = config # compatibiltiy
+    pytest.config = config # compatibiltiy
     if config.option.exitfirst:
         config.option.maxfail = 1
 
@@ -65,30 +76,40 @@ def wrap_session(config, doit):
     session.exitstatus = EXIT_OK
     initstate = 0
     try:
-        config.pluginmanager.do_configure(config)
-        initstate = 1
-        config.hook.pytest_sessionstart(session=session)
-        initstate = 2
-        doit(config, session)
-    except pytest.UsageError:
-        raise
-    except KeyboardInterrupt:
-        excinfo = py.code.ExceptionInfo()
-        config.hook.pytest_keyboard_interrupt(excinfo=excinfo)
-        session.exitstatus = EXIT_INTERRUPTED
-    except:
-        excinfo = py.code.ExceptionInfo()
-        config.pluginmanager.notify_exception(excinfo, config.option)
-        session.exitstatus = EXIT_INTERNALERROR
-        if excinfo.errisinstance(SystemExit):
-            sys.stderr.write("mainloop: caught Spurious SystemExit!\n")
-    if initstate >= 2:
-        config.hook.pytest_sessionfinish(session=session,
-            exitstatus=session.exitstatus or (session._testsfailed and 1))
-    if not session.exitstatus and session._testsfailed:
-        session.exitstatus = EXIT_TESTSFAILED
-    if initstate >= 1:
-        config.pluginmanager.do_unconfigure(config)
+        try:
+            config.do_configure()
+            initstate = 1
+            config.hook.pytest_sessionstart(session=session)
+            initstate = 2
+            doit(config, session)
+        except pytest.UsageError:
+            args = sys.exc_info()[1].args
+            for msg in args:
+                sys.stderr.write("ERROR: %s\n" %(msg,))
+            session.exitstatus = EXIT_USAGEERROR
+        except KeyboardInterrupt:
+            excinfo = py.code.ExceptionInfo()
+            config.hook.pytest_keyboard_interrupt(excinfo=excinfo)
+            session.exitstatus = EXIT_INTERRUPTED
+        except:
+            excinfo = py.code.ExceptionInfo()
+            config.notify_exception(excinfo, config.option)
+            session.exitstatus = EXIT_INTERNALERROR
+            if excinfo.errisinstance(SystemExit):
+                sys.stderr.write("mainloop: caught Spurious SystemExit!\n")
+        else:
+            if session._testsfailed:
+                session.exitstatus = EXIT_TESTSFAILED
+    finally:
+        excinfo = None  # Explicitly break reference cycle.
+        session.startdir.chdir()
+        if initstate >= 2:
+            config.hook.pytest_sessionfinish(
+                session=session,
+                exitstatus=session.exitstatus)
+        if initstate >= 1:
+            config.do_unconfigure()
+        config.pluginmanager.ensure_shutdown()
     return session.exitstatus
 
 def pytest_cmdline_main(config):
@@ -106,8 +127,19 @@ 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)
+
+    def getnextitem(i):
+        # this is a function to avoid python2
+        # keeping sys.exc_info set when calling into a test
+        # python2 keeps sys.exc_info till the frame is left
+        try:
+            return session.items[i+1]
+        except IndexError:
+            return None
+
+    for i, item in enumerate(session.items):
+        nextitem = getnextitem(i)
+        item.config.hook.pytest_runtest_protocol(item=item, nextitem=nextitem)
         if session.shouldstop:
             raise session.Interrupted(session.shouldstop)
     return True
@@ -116,17 +148,20 @@ def pytest_ignore_collect(path, config):
     p = path.dirpath()
     ignore_paths = config._getconftest_pathlist("collect_ignore", path=p)
     ignore_paths = ignore_paths or []
-    excludeopt = config.getvalue("ignore")
+    excludeopt = config.getoption("ignore")
     if excludeopt:
         ignore_paths.extend([py.path.local(x) for x in excludeopt])
     return path in ignore_paths
 
-class HookProxy:
+class HookProxy(object):
     def __init__(self, fspath, config):
         self.fspath = fspath
         self.config = config
+
     def __getattr__(self, name):
-        hookmethod = getattr(self.config.hook, name)
+        config = object.__getattribute__(self, "config")
+        hookmethod = getattr(config.hook, name)
+
         def call_matching_hooks(**kwargs):
             plugins = self.config._getmatchingplugins(self.fspath)
             return hookmethod.pcall(plugins, **kwargs)
@@ -134,31 +169,86 @@ class HookProxy:
 
 def compatproperty(name):
     def fget(self):
+        # deprecated - use pytest.name
         return getattr(pytest, name)
-    return property(fget, None, None,
-        "deprecated attribute %r, use pytest.%s" % (name,name))
+
+    return property(fget)
+
+class NodeKeywords(MappingMixin):
+    def __init__(self, node):
+        self.node = node
+        self.parent = node.parent
+        self._markers = {node.name: True}
+
+    def __getitem__(self, key):
+        try:
+            return self._markers[key]
+        except KeyError:
+            if self.parent is None:
+                raise
+            return self.parent.keywords[key]
+
+    def __setitem__(self, key, value):
+        self._markers[key] = value
+
+    def __delitem__(self, key):
+        raise ValueError("cannot delete key in keywords dict")
+
+    def __iter__(self):
+        seen = set(self._markers)
+        if self.parent is not None:
+            seen.update(self.parent.keywords)
+        return iter(seen)
+
+    def __len__(self):
+        return len(self.__iter__())
+
+    def keys(self):
+        return list(self)
+
+    def __repr__(self):
+        return "<NodeKeywords for node %s>" % (self.node, )
+
 
 class Node(object):
-    """ base class for all Nodes in the collection tree.
+    """ base class for Collector and Item the test collection tree.
     Collector subclasses have children, Items are terminal nodes."""
 
     def __init__(self, name, parent=None, config=None, session=None):
-        #: a unique name with the scope of the parent
+        #: a unique name within the scope of the parent node
         self.name = name
 
         #: the parent collector node.
         self.parent = parent
 
-        #: the test config object
+        #: the pytest config object
         self.config = config or parent.config
 
-        #: the collection this node is part of
+        #: the session this node is part of
         self.session = session or parent.session
 
-        #: filesystem path where this node was collected from
+        #: filesystem path where this node was collected from (can be None)
         self.fspath = getattr(parent, 'fspath', None)
-        self.ihook = self.session.gethookproxy(self.fspath)
-        self.keywords = {self.name: True}
+
+        #: keywords/markers collected from all scopes
+        self.keywords = NodeKeywords(self)
+
+        #: allow adding of extra keywords to use for matching
+        self.extra_keyword_matches = set()
+
+        # used for storing artificial fixturedefs for direct parametrization
+        self._name2pseudofixturedef = {}
+
+        #self.extrainit()
+
+    @property
+    def ihook(self):
+        """ fspath sensitive hook proxy used to call pytest hooks"""
+        return self.session.gethookproxy(self.fspath)
+
+    #def extrainit(self):
+    #    """"extra initialization after Node is initialized.  Implemented
+    #    by some subclasses. """
 
     Module = compatproperty("Module")
     Class = compatproperty("Class")
@@ -176,11 +266,27 @@ class Node(object):
         return cls
 
     def __repr__(self):
-        return "<%s %r>" %(self.__class__.__name__, getattr(self, 'name', None))
+        return "<%s %r>" %(self.__class__.__name__,
+                           getattr(self, 'name', None))
+
+    def warn(self, code, message):
+        """ generate a warning with the given code and message for this
+        item. """
+        assert isinstance(code, str)
+        fslocation = getattr(self, "location", None)
+        if fslocation is None:
+            fslocation = getattr(self, "fspath", None)
+        else:
+            fslocation = "%s:%s" % fslocation[:2]
+
+        self.ihook.pytest_logwarning(code=code, message=message,
+                                     nodeid=self.nodeid,
+                                     fslocation=fslocation)
 
     # methods for ordering nodes
     @property
     def nodeid(self):
+        """ a ::-separated string denoting its collection tree address. """
         try:
             return self._nodeid
         except AttributeError:
@@ -190,17 +296,8 @@ class Node(object):
     def _makeid(self):
         return self.parent.nodeid + "::" + self.name
 
-    def __eq__(self, other):
-        if not isinstance(other, Node):
-            return False
-        return self.__class__ == other.__class__ and \
-               self.name == other.name and self.parent == other.parent
-
-    def __ne__(self, other):
-        return not self == other
-
     def __hash__(self):
-        return hash((self.name, self.parent))
+        return hash(self.nodeid)
 
     def setup(self):
         pass
@@ -220,7 +317,7 @@ class Node(object):
         except py.builtin._sysex:
             raise
         except:
-            failure = py.std.sys.exc_info()
+            failure = sys.exc_info()
             setattr(self, exattrname, failure)
             raise
         setattr(self, attrname, res)
@@ -229,13 +326,42 @@ 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 add_marker(self, marker):
+        """ dynamically add a marker object to the node.
+
+        ``marker`` can be a string or pytest.mark.* instance.
+        """
+        from _pytest.mark import MarkDecorator
+        if isinstance(marker, py.builtin._basestring):
+            marker = MarkDecorator(marker)
+        elif not isinstance(marker, MarkDecorator):
+            raise ValueError("is not a string or pytest.mark.* Marker")
+        self.keywords[marker.name] = marker
+
+    def get_marker(self, name):
+        """ get a marker object from this node or None if
+        the node doesn't have a marker with that name. """
+        val = self.keywords.get(name, None)
+        if val is not None:
+            from _pytest.mark import MarkInfo, MarkDecorator
+            if isinstance(val, (MarkDecorator, MarkInfo)):
+                return val
+
+    def listextrakeywords(self):
+        """ Return a set of all extra keywords in self and any parents."""
+        extra_keywords = set()
+        item = self
+        for item in self.listchain():
+            extra_keywords.update(item.extra_keyword_matches)
+        return extra_keywords
 
     def listnames(self):
         return [x.name for x in self.listchain()]
@@ -243,7 +369,17 @@ class Node(object):
     def getplugins(self):
         return self.config._getmatchingplugins(self.fspath)
 
+    def addfinalizer(self, fin):
+        """ register a function to be called when this node is finalized.
+
+        This method can only be called when this node is active
+        in a setup chain, for example during self.setup().
+        """
+        self.session._setupstate.addfinalizer(fin, self)
+
     def getparent(self, cls):
+        """ get the next parent node (including ourself)
+        which is an instance of the given class"""
         current = self
         while current and not isinstance(current, cls):
             current = current.parent
@@ -253,20 +389,27 @@ class Node(object):
         pass
 
     def _repr_failure_py(self, excinfo, style=None):
+        fm = self.session._fixturemanager
+        if excinfo.errisinstance(fm.FixtureLookupError):
+            return excinfo.value.formatrepr()
+        tbfilter = True
         if self.config.option.fulltrace:
             style="long"
         else:
             self._prunetraceback(excinfo)
-        # XXX should excinfo.getrepr record all data and toterminal()
-        # process it?
+            tbfilter = False  # prunetraceback already does it
+            if style == "auto":
+                style = "long"
+        # XXX should excinfo.getrepr record all data and toterminal() process it?
         if style is None:
             if self.config.option.tbstyle == "short":
                 style = "short"
             else:
                 style = "long"
+
         return excinfo.getrepr(funcargs=True,
                                showlocals=self.config.option.showlocals,
-                               style=style)
+                               style=style, tbfilter=tbfilter)
 
     repr_failure = _repr_failure_py
 
@@ -274,6 +417,7 @@ class Collector(Node):
     """ Collector instances create children through collect()
         and thus iteratively build a tree.
     """
+
     class CollectError(Exception):
         """ an error during collection, contains a custom message. """
 
@@ -296,7 +440,6 @@ class Collector(Node):
 
     def _prunetraceback(self, excinfo):
         if hasattr(self, 'fspath'):
-            path = self.fspath
             traceback = excinfo.traceback
             ntraceback = traceback.cut(path=self.fspath)
             if ntraceback == traceback:
@@ -332,6 +475,14 @@ class Item(Node):
     """
     nextitem = None
 
+    def __init__(self, name, parent=None, config=None, session=None):
+        super(Item, self).__init__(name, parent, config, session)
+        self._report_sections = []
+
+    def add_report_section(self, when, key, content):
+        if content:
+            self._report_sections.append((when, key, content))
+
     def reportinfo(self):
         return self.fspath, None, ""
 
@@ -361,20 +512,21 @@ class Session(FSCollector):
         __module__ = 'builtins' # for py3
 
     def __init__(self, config):
-        super(Session, self).__init__(py.path.local(), parent=None,
-            config=config, session=self)
-        assert self.config.pluginmanager.register(self, name="session", prepend=True)
+        FSCollector.__init__(self, py.path.local(), parent=None,
+                             config=config, session=self)
+        self.config.pluginmanager.register(self, name="session", prepend=True)
         self._testsfailed = 0
         self.shouldstop = False
         self.trace = config.trace.root.get("collection")
         self._norecursepatterns = config.getini("norecursedirs")
+        self.startdir = py.path.local()
 
     def pytest_collectstart(self):
         if self.shouldstop:
             raise self.Interrupted(self.shouldstop)
 
     def pytest_runtest_logreport(self, report):
-        if report.failed and 'xfail' not in getattr(report, 'keywords', []):
+        if report.failed and not hasattr(report, 'wasxfail'):
             self._testsfailed += 1
             maxfail = self.config.getvalue("maxfail")
             if maxfail and self._testsfailed >= maxfail:
@@ -406,22 +558,24 @@ 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)
             self._initialpaths.add(parts[0])
-        self.ihook.pytest_collectstart(collector=self)
-        rep = self.ihook.pytest_make_collect_report(collector=self)
+        rep = collect_one_node(self)
         self.ihook.pytest_collectreport(report=rep)
         self.trace.root.indent -= 1
         if self._notfound:
+            errors = []
             for arg, exc in self._notfound:
                 line = "(no name %r in any of %r)" % (arg, exc.args[0])
-                raise pytest.UsageError("not found: %s\n%s" %(arg, line))
+                errors.append("not found: %s\n%s" % (arg, line))
+                #XXX: test this
+            raise pytest.UsageError(*errors)
         if not genitems:
             return rep.result
         else:
-            self.items = items = []
             if rep.passed:
                 for node in rep.result:
                     self.items.extend(self.genitems(node))
@@ -439,8 +593,7 @@ class Session(FSCollector):
                 # we are inside a make_report hook so
                 # we cannot directly pass through the exception
                 self._notfound.append((arg, sys.exc_info()[1]))
-                self.trace.root.indent -= 1
-                break
+
             self.trace.root.indent -= 1
 
     def _collect(self, arg):
@@ -449,7 +602,7 @@ class Session(FSCollector):
         if path.check(dir=1):
             assert not names, "invalid arg %r" %(arg,)
             for path in path.visit(fil=lambda x: x.check(file=1),
-                rec=self._recurse, bf=True, sort=True):
+                                   rec=self._recurse, bf=True, sort=True):
                 for x in self._collectfile(path):
                     yield x
         else:
@@ -461,13 +614,13 @@ class Session(FSCollector):
         ihook = self.gethookproxy(path)
         if not self.isinitpath(path):
             if ihook.pytest_ignore_collect(path=path, config=self.config):
-               return ()
+                return ()
         return ihook.pytest_collect_file(path=path, parent=self)
 
     def _recurse(self, path):
         ihook = self.gethookproxy(path.dirpath())
         if ihook.pytest_ignore_collect(path=path, config=self.config):
-           return
+            return
         for pat in self._norecursepatterns:
             if path.check(fnmatch=pat):
                 return False
@@ -541,8 +694,7 @@ class Session(FSCollector):
                     resultnodes.append(node)
                 continue
             assert isinstance(node, pytest.Collector)
-            node.ihook.pytest_collectstart(collector=node)
-            rep = node.ihook.pytest_make_collect_report(collector=node)
+            rep = collect_one_node(node)
             if rep.passed:
                 has_matched = False
                 for x in rep.result:
@@ -563,10 +715,11 @@ class Session(FSCollector):
             yield node
         else:
             assert isinstance(node, pytest.Collector)
-            node.ihook.pytest_collectstart(collector=node)
-            rep = node.ihook.pytest_make_collect_report(collector=node)
+            rep = collect_one_node(node)
             if rep.passed:
                 for subnode in rep.result:
                     for x in self.genitems(subnode):
                         yield x
             node.ihook.pytest_collectreport(report=rep)
+
+

_pytest/mark.py

@@ -1,43 +1,56 @@
 """ generic mechanism for marking and selecting python functions. """
-import pytest, py
+import py
+
 
 def pytest_namespace():
     return {'mark': MarkGenerator()}
 
+
 def pytest_addoption(parser):
     group = parser.getgroup("general")
-    group._addoption('-k',
-        action="store", dest="keyword", default='', metavar="KEYWORDEXPR",
-        help="only run tests which match given keyword expression.  "
-             "An expression consists of space-separated terms. "
-             "Each term must match. Precede a term with '-' to negate. "
-             "Terminate expression with ':' to make the first match match "
-             "all subsequent tests (usually file-order). ")
+    group._addoption(
+        '-k',
+        action="store", dest="keyword", default='', metavar="EXPRESSION",
+        help="only run tests which match the given substring expression. "
+             "An expression is a python evaluatable expression "
+             "where all names are substring-matched against test names "
+             "and their parent classes. Example: -k 'test_method or test "
+             "other' matches all test functions and classes whose name "
+             "contains 'test_method' or 'test_other'. "
+             "Additionally keywords are matched to classes and functions "
+             "containing extra names in their 'extra_keyword_matches' set, "
+             "as well as functions which have names assigned directly to them."
+    )
 
-    group._addoption("-m",
+    group._addoption(
+        "-m",
         action="store", dest="markexpr", default="", metavar="MARKEXPR",
         help="only run tests matching given mark expression.  "
              "example: -m 'mark1 and not mark2'."
-             )
+    )
 
-    group.addoption("--markers", action="store_true", help=
-        "show markers (builtin, plugin and per-project ones).")
+    group.addoption(
+        "--markers", action="store_true",
+        help="show markers (builtin, plugin and per-project ones)."
+    )
 
     parser.addini("markers", "markers for test functions", 'linelist')
 
+
 def pytest_cmdline_main(config):
     if config.option.markers:
-        config.pluginmanager.do_configure(config)
+        config.do_configure()
         tw = py.io.TerminalWriter()
         for line in config.getini("markers"):
             name, rest = line.split(":", 1)
-            tw.write("@pytest.mark.%s:" %  name, bold=True)
+            tw.write("@pytest.mark.%s:" % name, bold=True)
             tw.line(rest)
             tw.line()
-        config.pluginmanager.do_unconfigure(config)
+        config.do_unconfigure()
         return 0
 pytest_cmdline_main.tryfirst = True
 
+
 def pytest_collection_modifyitems(items, config):
     keywordexpr = config.option.keyword
     matchexpr = config.option.markexpr
@@ -51,7 +64,7 @@ def pytest_collection_modifyitems(items, config):
     remaining = []
     deselected = []
     for colitem in items:
-        if keywordexpr and skipbykeyword(colitem, keywordexpr):
+        if keywordexpr and not matchkeyword(colitem, keywordexpr):
             deselected.append(colitem)
         else:
             if selectuntil:
@@ -66,57 +79,88 @@ def pytest_collection_modifyitems(items, config):
         config.hook.pytest_deselected(items=deselected)
         items[:] = remaining
 
-class BoolDict:
-    def __init__(self, mydict):
-        self._mydict = mydict
-    def __getitem__(self, name):
-        return name in self._mydict
 
-def matchmark(colitem, matchexpr):
-    return eval(matchexpr, {}, BoolDict(colitem.obj.__dict__))
+class MarkMapping:
+    """Provides a local mapping for markers where item access
+    resolves to True if the marker is present. """
+    def __init__(self, keywords):
+        mymarks = set()
+        for key, value in keywords.items():
+            if isinstance(value, MarkInfo) or isinstance(value, MarkDecorator):
+                mymarks.add(key)
+        self._mymarks = mymarks
+
+    def __getitem__(self, name):
+        return name in self._mymarks
+
+
+class KeywordMapping:
+    """Provides a local mapping for keywords.
+    Given a list of names, map any substring of one of these names to True.
+    """
+    def __init__(self, names):
+        self._names = names
+
+    def __getitem__(self, subname):
+        for name in self._names:
+            if subname in name:
+                return True
+        return False
+
+
+def matchmark(colitem, markexpr):
+    """Tries to match on any marker names, attached to the given colitem."""
+    return eval(markexpr, {}, MarkMapping(colitem.keywords))
+
+
+def matchkeyword(colitem, keywordexpr):
+    """Tries to match given keyword expression to given collector item.
+
+    Will match on the name of colitem, including the names of its parents.
+    Only matches names of items which are either a :class:`Class` or a
+    :class:`Function`.
+    Additionally, matches on names in the 'extra_keyword_matches' set of
+    any item, as well as names directly assigned to test functions.
+    """
+    keywordexpr = keywordexpr.replace("-", "not ")
+    mapped_names = set()
+
+    # Add the names of the current item and any parent items
+    import pytest
+    for item in colitem.listchain():
+        if not isinstance(item, pytest.Instance):
+            mapped_names.add(item.name)
+
+    # Add the names added as extra keywords to current or parent items
+    for name in colitem.listextrakeywords():
+        mapped_names.add(name)
+
+    # Add the names attached to the current function through direct assignment
+    if hasattr(colitem, 'function'):
+        for name in colitem.function.__dict__:
+            mapped_names.add(name)
+
+    mapping = KeywordMapping(mapped_names)
+    if " " not in keywordexpr:
+        # special case to allow for simple "-k pass" and "-k 1.3"
+        return mapping[keywordexpr]
+    elif keywordexpr.startswith("not ") and " " not in keywordexpr[4:]:
+        return not mapping[keywordexpr[4:]]
+    return eval(keywordexpr, {}, mapping)
+
 
 def pytest_configure(config):
+    import pytest
     if config.option.strict:
         pytest.mark._config = config
 
-def skipbykeyword(colitem, keywordexpr):
-    """ return True if they given keyword expression means to
-        skip this collector/item.
-    """
-    if not keywordexpr:
-        return
-
-    itemkeywords = getkeywords(colitem)
-    for key in filter(None, keywordexpr.split()):
-        eor = key[:1] == '-'
-        if eor:
-            key = key[1:]
-        if not (eor ^ matchonekeyword(key, itemkeywords)):
-            return True
-
-def getkeywords(node):
-    keywords = {}
-    while node is not None:
-        keywords.update(node.keywords)
-        node = node.parent
-    return keywords
-
-
-def matchonekeyword(key, itemkeywords):
-    for elem in key.split("."):
-        for kw in itemkeywords:
-            if elem in kw:
-                break
-        else:
-            return False
-    return True
 
 class MarkGenerator:
     """ Factory for :class:`MarkDecorator` objects - exposed as
-    a ``py.test.mark`` singleton instance.  Example::
+    a ``pytest.mark`` singleton instance.  Example::
 
          import py
-         @py.test.mark.slowtest
+         @pytest.mark.slowtest
          def test_function():
             pass
 
@@ -125,7 +169,7 @@ class MarkGenerator:
 
     def __getattr__(self, name):
         if name[0] == "_":
-            raise AttributeError(name)
+            raise AttributeError("Marker name must NOT start with underscore")
         if hasattr(self, '_config'):
             self._check(name)
         return MarkDecorator(name)
@@ -144,60 +188,88 @@ class MarkGenerator:
         if name not in self._markers:
             raise AttributeError("%r not a registered marker" % (name,))
 
+def istestfunc(func):
+    return hasattr(func, "__call__") and \
+        getattr(func, "__name__", "<lambda>") != "<lambda>"
+
 class MarkDecorator:
     """ A decorator for test functions and test classes.  When applied
     it will create :class:`MarkInfo` objects which may be
     :ref:`retrieved by hooks as item keywords <excontrolskip>`.
     MarkDecorator instances are often created like this::
 
-        mark1 = py.test.mark.NAME              # simple MarkDecorator
-        mark2 = py.test.mark.NAME(name1=value) # parametrized MarkDecorator
+        mark1 = pytest.mark.NAME              # simple MarkDecorator
+        mark2 = pytest.mark.NAME(name1=value) # parametrized MarkDecorator
 
     and can then be applied as decorators to test functions::
 
         @mark2
         def test_function():
             pass
+
+    When a MarkDecorator instance is called it does the following:
+      1. If called with a single class as its only positional argument and no
+         additional keyword arguments, it attaches itself to the class so it
+         gets applied automatically to all test cases found in that class.
+      2. If called with a single function as its only positional argument and
+         no additional keyword arguments, it attaches a MarkInfo object to the
+         function, containing all the arguments already stored internally in
+         the MarkDecorator.
+      3. When called in any other case, it performs a 'fake construction' call,
+         i.e. it returns a new MarkDecorator instance with the original
+         MarkDecorator's content updated with the arguments passed to this
+         call.
+
+    Note: The rules above prevent MarkDecorator objects from storing only a
+    single function or class reference as their positional argument with no
+    additional keyword or positional arguments.
+
     """
     def __init__(self, name, args=None, kwargs=None):
-        self.markname = name
+        self.name = name
         self.args = args or ()
         self.kwargs = kwargs or {}
 
+    @property
+    def markname(self):
+        return self.name # for backward-compat (2.4.1 had this attr)
+
     def __repr__(self):
         d = self.__dict__.copy()
-        name = d.pop('markname')
-        return "<MarkDecorator %r %r>" %(name, d)
+        name = d.pop('name')
+        return "<MarkDecorator %r %r>" % (name, d)
 
     def __call__(self, *args, **kwargs):
         """ if passed a single callable argument: decorate it with mark info.
             otherwise add *args/**kwargs in-place to mark information. """
-        if args:
+        if args and not kwargs:
             func = args[0]
-            if len(args) == 1 and hasattr(func, '__call__') or \
-               hasattr(func, '__bases__'):
+            if len(args) == 1 and (istestfunc(func) or
+                                   hasattr(func, '__bases__')):
                 if hasattr(func, '__bases__'):
                     if hasattr(func, 'pytestmark'):
                         l = func.pytestmark
                         if not isinstance(l, list):
-                           func.pytestmark = [l, self]
+                            func.pytestmark = [l, self]
                         else:
-                           l.append(self)
+                            l.append(self)
                     else:
-                       func.pytestmark = [self]
+                        func.pytestmark = [self]
                 else:
-                    holder = getattr(func, self.markname, None)
+                    holder = getattr(func, self.name, None)
                     if holder is None:
-                        holder = MarkInfo(self.markname, self.args, self.kwargs)
-                        setattr(func, self.markname, holder)
+                        holder = MarkInfo(
+                            self.name, self.args, self.kwargs
+                        )
+                        setattr(func, self.name, 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)
         args = self.args + args
-        return self.__class__(self.markname, args=args, kwargs=kw)
+        return self.__class__(self.name, args=args, kwargs=kw)
+
 
 class MarkInfo:
     """ Marking object created by :class:`MarkDecorator` instances. """
@@ -208,27 +280,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)
+            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

@@ -1,6 +1,7 @@
 """ monkeypatching and mocking functionality.  """
 
 import os, sys
+from py.builtin import _basestring
 
 def pytest_funcarg__monkeypatch(request):
     """The returned ``monkeypatch`` funcarg provides these
@@ -13,6 +14,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``
@@ -23,32 +25,114 @@ def pytest_funcarg__monkeypatch(request):
     request.addfinalizer(mpatch.undo)
     return mpatch
 
-notset = object()
+
+
+def derive_importpath(import_path):
+    import pytest
+    if not isinstance(import_path, _basestring) or "." not in import_path:
+        raise TypeError("must be absolute import path string, not %r" %
+                        (import_path,))
+    rest = []
+    target = import_path
+    while target:
+        try:
+            obj = __import__(target, None, None, "__doc__")
+        except ImportError:
+            if "." not in target:
+                __tracebackhide__ = True
+                pytest.fail("could not import any sub part: %s" %
+                            import_path)
+            target, name = target.rsplit(".", 1)
+            rest.append(name)
+        else:
+            assert rest
+            try:
+                while len(rest) > 1:
+                    attr = rest.pop()
+                    obj = getattr(obj, attr)
+                attr = rest[0]
+                getattr(obj, attr)
+            except AttributeError:
+                __tracebackhide__ = True
+                pytest.fail("object %r has no attribute %r" % (obj, attr))
+            return attr, obj
+
+
+
+class Notset:
+    def __repr__(self):
+        return "<notset>"
+
+notset = Notset()
 
 class monkeypatch:
     """ object keeping a record of setattr/item/env/syspath changes. """
     def __init__(self):
         self._setattr = []
         self._setitem = []
+        self._cwd = None
 
-    def setattr(self, obj, name, value, raising=True):
-        """ set attribute ``name`` on ``obj`` to ``value``, by default
-        raise AttributeEror if the attribute did not exist. """
-        oldval = getattr(obj, name, notset)
+    def setattr(self, target, name, value=notset, raising=True):
+        """ set attribute value on target, memorizing the old value.
+        By default raise AttributeError if the attribute did not exist.
+
+        For convenience you can specify a string as ``target`` which
+        will be interpreted as a dotted import path, with the last part
+        being the attribute name.  Example:
+        ``monkeypatch.setattr("os.getcwd", lambda x: "/")``
+        would set the ``getcwd`` function of the ``os`` module.
+
+        The ``raising`` value determines if the setattr should fail
+        if the attribute is not already present (defaults to True
+        which means it will raise).
+        """
+        __tracebackhide__ = True
+        import inspect
+
+        if value is notset:
+            if not isinstance(target, _basestring):
+                raise TypeError("use setattr(target, name, value) or "
+                   "setattr(target, value) with target being a dotted "
+                   "import string")
+            value = name
+            name, target = derive_importpath(target)
+
+        oldval = getattr(target, name, notset)
         if raising and oldval is notset:
-            raise AttributeError("%r has no attribute %r" %(obj, name))
-        self._setattr.insert(0, (obj, name, oldval))
-        setattr(obj, name, value)
+            raise AttributeError("%r has no attribute %r" %(target, name))
 
-    def delattr(self, obj, name, raising=True):
-        """ delete attribute ``name`` from ``obj``, by default raise
-        AttributeError it the attribute did not previously exist. """
-        if not hasattr(obj, name):
+        # avoid class descriptors like staticmethod/classmethod
+        if inspect.isclass(target):
+            oldval = target.__dict__.get(name, notset)
+        self._setattr.insert(0, (target, name, oldval))
+        setattr(target, name, value)
+
+    def delattr(self, target, name=notset, raising=True):
+        """ delete attribute ``name`` from ``target``, by default raise
+        AttributeError it the attribute did not previously exist.
+
+        If no ``name`` is specified and ``target`` is a string
+        it will be interpreted as a dotted import path with the
+        last part being the attribute name.
+
+        If raising is set to false, the attribute is allowed to not
+        pre-exist.
+        """
+        __tracebackhide__ = True
+        if name is notset:
+            if not isinstance(target, _basestring):
+                raise TypeError("use delattr(target, name) or "
+                                "delattr(target) with target being a dotted "
+                                "import string")
+            name, target = derive_importpath(target)
+
+        if not hasattr(target, name):
             if raising:
                 raise AttributeError(name)
         else:
-            self._setattr.insert(0, (obj, name, getattr(obj, name, notset)))
-            delattr(obj, name)
+            self._setattr.insert(0, (target, name,
+                                     getattr(target, name, notset)))
+            delattr(target, name)
 
     def setitem(self, dic, name, value):
         """ set dictionary entry ``name`` to value. """
@@ -83,6 +167,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 +190,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/nose.py

@@ -1,21 +1,32 @@
 """ run test suites written for nose. """
 
-import pytest, py
-import inspect
 import sys
 
+import py
+import pytest
+from _pytest import unittest
+
+
+def get_skip_exceptions():
+    skip_classes = set()
+    for module_name in ('unittest', 'unittest2', 'nose'):
+        mod = sys.modules.get(module_name)
+        if hasattr(mod, 'SkipTest'):
+            skip_classes.add(mod.SkipTest)
+    return tuple(skip_classes)
+
+
 def pytest_runtest_makereport(__multicall__, item, call):
-    SkipTest = getattr(sys.modules.get('nose', None), 'SkipTest', None)
-    if SkipTest:
-        if call.excinfo and call.excinfo.errisinstance(SkipTest):
-            # let's substitute the excinfo with a py.test.skip one
-            call2 = call.__class__(lambda: py.test.skip(str(call.excinfo.value)), call.when)
-            call.excinfo = call2.excinfo
+    if call.excinfo and call.excinfo.errisinstance(get_skip_exceptions()):
+        # let's substitute the excinfo with a pytest.skip one
+        call2 = call.__class__(lambda:
+                    pytest.skip(str(call.excinfo.value)), call.when)
+        call.excinfo = call2.excinfo
 
 
 @pytest.mark.trylast
 def pytest_runtest_setup(item):
-    if isinstance(item, (pytest.Function)):
+    if is_potential_nosetest(item):
         if isinstance(item.parent, pytest.Generator):
             gen = item.parent
             if not hasattr(gen, '_nosegensetup'):
@@ -26,22 +37,34 @@ def pytest_runtest_setup(item):
         if not call_optional(item.obj, 'setup'):
             # call module level setup if there is no object level one
             call_optional(item.parent.obj, 'setup')
+        #XXX this implies we only call teardown when setup worked
+        item.session._setupstate.addfinalizer((lambda: teardown_nose(item)), item)
 
-def pytest_runtest_teardown(item):
-    if isinstance(item, pytest.Function):
+def teardown_nose(item):
+    if is_potential_nosetest(item):
         if not call_optional(item.obj, 'teardown'):
             call_optional(item.parent.obj, 'teardown')
         #if hasattr(item.parent, '_nosegensetup'):
         #    #call_optional(item._nosegensetup, 'teardown')
         #    del item.parent._nosegensetup
 
+
 def pytest_make_collect_report(collector):
     if isinstance(collector, pytest.Generator):
         call_optional(collector.obj, 'setup')
 
+
+def is_potential_nosetest(item):
+    # extra check needed since we do not do nose style setup/teardown
+    # on direct unittest style classes
+    return isinstance(item, pytest.Function) and \
+        not isinstance(item, unittest.TestCaseFunction)
+
+
 def call_optional(obj, name):
     method = getattr(obj, name, None)
-    if method:
+    isfixture = hasattr(method, "_pytestfixturefunction")
+    if method is not None and not isfixture and py.builtin.callable(method):
         # If there's any problems allow the exception to raise rather than
         # silently ignoring them
         method()

_pytest/pastebin.py

@@ -2,7 +2,7 @@
 import py, sys
 
 class url:
-    base = "http://paste.pocoo.org"
+    base = "http://bpaste.net"
     xmlrpc = base + "/xmlrpc/"
     show = base + "/show/"
 
@@ -10,8 +10,8 @@ def pytest_addoption(parser):
     group = parser.getgroup("terminal reporting")
     group._addoption('--pastebin', metavar="mode",
         action='store', dest="pastebin", default=None,
-        type="choice", choices=['failed', 'all'],
-        help="send failed|all info to Pocoo pastebin service.")
+        choices=['failed', 'all'],
+        help="send failed|all info to bpaste.net pastebin service.")
 
 def pytest_configure(__multicall__, config):
     import tempfile

_pytest/pdb.py

@@ -1,8 +1,12 @@
 """ interactive debugging with PDB, the Python Debugger. """
-
-import pytest, py
+from __future__ import absolute_import
+import pdb
 import sys
 
+import pytest
+import py
+
+
 def pytest_addoption(parser):
     group = parser.getgroup("general")
     group._addoption('--pdb',
@@ -16,79 +20,85 @@ def pytest_configure(config):
     if config.getvalue("usepdb"):
         config.pluginmanager.register(PdbInvoke(), 'pdbinvoke')
 
+    old = (pdb.set_trace, pytestPDB._pluginmanager)
+    def fin():
+        pdb.set_trace, pytestPDB._pluginmanager = old
+    pdb.set_trace = pytest.set_trace
+    pytestPDB._pluginmanager = config.pluginmanager
+    config._cleanup.append(fin)
+
 class pytestPDB:
     """ Pseudo PDB that defers to the real pdb. """
-    item = None
-    collector = None
+    _pluginmanager = None
 
     def set_trace(self):
         """ invoke PDB set_trace debugging, dropping any IO capturing. """
         frame = sys._getframe().f_back
-        item = self.item or self.collector
-
-        if item is not None:
-            capman = item.config.pluginmanager.getplugin("capturemanager")
-            out, err = capman.suspendcapture()
-            if hasattr(item, 'outerr'):
-                item.outerr = (item.outerr[0] + out, item.outerr[1] + err)
+        capman = None
+        if self._pluginmanager is not None:
+            capman = self._pluginmanager.getplugin("capturemanager")
+            if capman:
+                capman.suspendcapture(in_=True)
             tw = py.io.TerminalWriter()
             tw.line()
             tw.sep(">", "PDB set_trace (IO-capturing turned off)")
-        py.std.pdb.Pdb().set_trace(frame)
+            self._pluginmanager.hook.pytest_enter_pdb()
+        pdb.Pdb().set_trace(frame)
 
-def pdbitem(item):
-    pytestPDB.item = item
-pytest_runtest_setup = pytest_runtest_call = pytest_runtest_teardown = pdbitem
 
-@pytest.mark.tryfirst
-def pytest_make_collect_report(__multicall__, collector):
-    try:
-        pytestPDB.collector = collector
-        return __multicall__.execute()
-    finally:
-        pytestPDB.collector = None
-
-def pytest_runtest_makereport():
-    pytestPDB.item = None
-    
 class PdbInvoke:
-    @pytest.mark.tryfirst
-    def pytest_runtest_makereport(self, item, call, __multicall__):
-        rep = __multicall__.execute()
-        if not call.excinfo or \
-            call.excinfo.errisinstance(pytest.skip.Exception) or \
-            call.excinfo.errisinstance(py.std.bdb.BdbQuit):
-            return rep
-        if "xfail" in rep.keywords:
-            return rep
-        # we assume that the above execute() suspended capturing
-        # XXX we re-use the TerminalReporter's terminalwriter
-        # because this seems to avoid some encoding related troubles
-        # for not completely clear reasons.
-        tw = item.config.pluginmanager.getplugin("terminalreporter")._tw
-        tw.line()
-        tw.sep(">", "traceback")
-        rep.toterminal(tw)
-        tw.sep(">", "entering PDB")
-        # A doctest.UnexpectedException is not useful for post_mortem.
-        # Use the underlying exception instead:
-        if isinstance(call.excinfo.value, py.std.doctest.UnexpectedException):
-            tb = call.excinfo.value.exc_info[2]
-        else:
-            tb = call.excinfo._excinfo[2]
+    def pytest_exception_interact(self, node, call, report):
+        capman = node.config.pluginmanager.getplugin("capturemanager")
+        if capman:
+            capman.suspendcapture(in_=True)
+        _enter_pdb(node, call.excinfo, report)
+
+    def pytest_internalerror(self, excrepr, excinfo):
+        for line in str(excrepr).split("\n"):
+            sys.stderr.write("INTERNALERROR> %s\n" %line)
+            sys.stderr.flush()
+        tb = _postmortem_traceback(excinfo)
         post_mortem(tb)
-        rep._pdbshown = True
-        return rep
+
+
+def _enter_pdb(node, excinfo, rep):
+    # XXX we re-use the TerminalReporter's terminalwriter
+    # because this seems to avoid some encoding related troubles
+    # for not completely clear reasons.
+    tw = node.config.pluginmanager.getplugin("terminalreporter")._tw
+    tw.line()
+    tw.sep(">", "traceback")
+    rep.toterminal(tw)
+    tw.sep(">", "entering PDB")
+    tb = _postmortem_traceback(excinfo)
+    post_mortem(tb)
+    rep._pdbshown = True
+    return rep
+
+
+def _postmortem_traceback(excinfo):
+    # A doctest.UnexpectedException is not useful for post_mortem.
+    # Use the underlying exception instead:
+    from doctest import UnexpectedException
+    if isinstance(excinfo.value, UnexpectedException):
+        return excinfo.value.exc_info[2]
+    else:
+        return excinfo._excinfo[2]
+
+
+def _find_last_non_hidden_frame(stack):
+    i = max(0, len(stack) - 1)
+    while i and stack[i][0].f_locals.get("__tracebackhide__", False):
+        i -= 1
+    return i
+
 
 def post_mortem(t):
-    pdb = py.std.pdb
     class Pdb(pdb.Pdb):
         def get_stack(self, f, t):
             stack, i = pdb.Pdb.get_stack(self, f, t)
             if f is None:
-                i = max(0, len(stack) - 1)
-                while i and stack[i][0].f_locals.get("__tracebackhide__", False):
-                    i-=1
+                i = _find_last_non_hidden_frame(stack)
             return stack, i
     p = Pdb()
     p.reset()

_pytest/pytester.py

@@ -1,15 +1,27 @@
-""" (disabled by default) support for testing py.test and py.test plugins. """
-
-import py, pytest
-import sys, os
-import re
+""" (disabled by default) support for testing pytest and pytest plugins. """
 import inspect
+import sys
+import os
+import codecs
+import re
 import time
+import platform
 from fnmatch import fnmatch
-from _pytest.main import Session, EXIT_OK
+import subprocess
+
+import py
+import pytest
 from py.builtin import print_
 from _pytest.core import HookRelay
 
+from _pytest.main import Session, EXIT_OK
+
+
+def get_public_names(l):
+    """Only return names from iterator l without a leading underscore."""
+    return [x for x in l if x[0] != "_"]
+
+
 def pytest_addoption(parser):
     group = parser.getgroup("pylib")
     group.addoption('--no-tools-on-path',
@@ -20,7 +32,6 @@ def pytest_addoption(parser):
 def pytest_configure(config):
     # This might be called multiple times. Only take the first.
     global _pytest_fullpath
-    import pytest
     try:
         _pytest_fullpath
     except NameError:
@@ -76,15 +87,16 @@ class HookRecorder:
 
     def finish_recording(self):
         for recorder in self._recorders.values():
-            self._pluginmanager.unregister(recorder)
+            if self._pluginmanager.isregistered(recorder):
+                self._pluginmanager.unregister(recorder)
         self._recorders.clear()
 
     def _makecallparser(self, method):
         name = method.__name__
-        args, varargs, varkw, default = py.std.inspect.getargspec(method)
+        args, varargs, varkw, default = inspect.getargspec(method)
         if not args or args[0] != "self":
             args.insert(0, 'self')
-        fspec = py.std.inspect.formatargspec(args, varargs, varkw, default)
+        fspec = inspect.formatargspec(args, varargs, varkw, default)
         # we use exec because we want to have early type
         # errors on wrong input arguments, using
         # *args/**kwargs delays this and gives errors
@@ -114,10 +126,9 @@ class HookRecorder:
 
     def contains(self, entries):
         __tracebackhide__ = True
-        from py.builtin import print_
         i = 0
         entries = list(entries)
-        backlocals = py.std.sys._getframe(1).f_locals
+        backlocals = sys._getframe(1).f_locals
         while entries:
             name, check = entries.pop(0)
             for ind, call in enumerate(self.calls[i:]):
@@ -132,7 +143,7 @@ class HookRecorder:
                     break
                 print_("NONAMEMATCH", name, "with", call)
             else:
-                py.test.fail("could not find %r check %r" % (name, check))
+                pytest.fail("could not find %r check %r" % (name, check))
 
     def popcall(self, name):
         __tracebackhide__ = True
@@ -142,7 +153,7 @@ class HookRecorder:
                 return call
         lines = ["could not find call %r, in:" % (name,)]
         lines.extend(["  %s" % str(x) for x in self.calls])
-        py.test.fail("\n".join(lines))
+        pytest.fail("\n".join(lines))
 
     def getcall(self, name):
         l = self.getcalls(name)
@@ -194,10 +205,7 @@ class TmpTestdir:
             except py.error.EEXIST:
                 continue
             break
-        # we need to create another subdir
-        # because Directory.collect() currently loads
-        # conftest.py from sibling directories
-        self.tmpdir = tmpdir.mkdir(name)
+        self.tmpdir = tmpdir
         self.plugins = []
         self._syspathremove = []
         self.chdir() # always chdir
@@ -208,7 +216,7 @@ class TmpTestdir:
 
     def finalize(self):
         for p in self._syspathremove:
-            py.std.sys.path.remove(p)
+            sys.path.remove(p)
         if hasattr(self, '_olddir'):
             self._olddir.chdir()
         # delete modules that have been loaded from tmpdir
@@ -244,8 +252,16 @@ class TmpTestdir:
         ret = None
         for name, value in items:
             p = self.tmpdir.join(name).new(ext=ext)
-            source = py.builtin._totext(py.code.Source(value)).lstrip()
-            p.write(source.encode("utf-8"), "wb")
+            source = py.code.Source(value)
+            def my_totext(s, encoding="utf-8"):
+                if py.builtin._isbytes(s):
+                    s = py.builtin._totext(s, encoding=encoding)
+                return s
+            source_unicode = "\n".join([my_totext(line) for line in source.lines])
+            source = py.builtin._totext(source_unicode)
+            content = source.strip().encode("utf-8") # + "\n"
+            #content = content.rstrip() + "\n"
+            p.write(content, "wb")
             if ret is None:
                 ret = p
         return ret
@@ -254,9 +270,6 @@ class TmpTestdir:
     def makefile(self, ext, *args, **kwargs):
         return self._makefile(ext, args, kwargs)
 
-    def makeini(self, source):
-        return self.makefile('cfg', setup=source)
-
     def makeconftest(self, source):
         return self.makepyfile(conftest=source)
 
@@ -276,7 +289,7 @@ class TmpTestdir:
     def syspathinsert(self, path=None):
         if path is None:
             path = self.tmpdir
-        py.std.sys.path.insert(0, str(path))
+        sys.path.insert(0, str(path))
         self._syspathremove.append(str(path))
 
     def mkdir(self, name):
@@ -318,7 +331,7 @@ class TmpTestdir:
         # used from runner functional tests
         item = self.getitem(source)
         # the test class where we are called from wants to provide the runner
-        testclassinstance = py.builtin._getimself(self.request.function)
+        testclassinstance = self.request.instance
         runner = testclassinstance.getrunner()
         return runner(item)
 
@@ -355,7 +368,7 @@ class TmpTestdir:
         if not plugins:
             plugins = []
         plugins.append(Collect())
-        ret = self.pytestmain(list(args), plugins=[Collect()])
+        ret = pytest.main(list(args), plugins=plugins)
         reprec = rec[0]
         reprec.ret = ret
         assert len(rec) == 1
@@ -368,30 +381,33 @@ class TmpTestdir:
                 break
         else:
             args.append("--basetemp=%s" % self.tmpdir.dirpath('basetemp'))
-        import _pytest.core
-        config = _pytest.core._prepareconfig(args, self.plugins)
-        # the in-process pytest invocation needs to avoid leaking FDs
-        # so we register a "reset_capturings" callmon the capturing manager
-        # and make sure it gets called
-        config._cleanup.append(
-            config.pluginmanager.getplugin("capturemanager").reset_capturings)
         import _pytest.config
-        self.request.addfinalizer(
-            lambda: _pytest.config.pytest_unconfigure(config))
+        config = _pytest.config._prepareconfig(args, self.plugins)
+        # we don't know what the test will do with this half-setup config
+        # object and thus we make sure it gets unconfigured properly in any
+        # case (otherwise capturing could still be active, for example)
+        def ensure_unconfigure():
+            if hasattr(config.pluginmanager, "_config"):
+                config.pluginmanager.do_unconfigure(config)
+            config.pluginmanager.ensure_shutdown()
+
+        self.request.addfinalizer(ensure_unconfigure)
         return config
 
     def parseconfigure(self, *args):
         config = self.parseconfig(*args)
-        config.pluginmanager.do_configure(config)
+        config.do_configure()
         self.request.addfinalizer(lambda:
-        config.pluginmanager.do_unconfigure(config))
+        config.do_unconfigure())
         return config
 
     def getitem(self,  source, funcname="test_func"):
-        for item in self.getitems(source):
+        items = self.getitems(source)
+        for item in items:
             if item.name == funcname:
                 return item
-        assert 0, "%r item not found in module:\n%s" %(funcname, source)
+        assert 0, "%r item not found in module:\n%s\nitems: %s" %(
+                  funcname, source, items)
 
     def getitems(self,  source):
         modcol = self.getmodulecol(source)
@@ -416,19 +432,8 @@ class TmpTestdir:
         env['PYTHONPATH'] = os.pathsep.join(filter(None, [
             str(os.getcwd()), env.get('PYTHONPATH', '')]))
         kw['env'] = env
-        #print "env", env
-        return py.std.subprocess.Popen(cmdargs, stdout=stdout, stderr=stderr, **kw)
-
-    def pytestmain(self, *args, **kwargs):
-        class ResetCapturing:
-            @pytest.mark.trylast
-            def pytest_unconfigure(self, config):
-                capman = config.pluginmanager.getplugin("capturemanager")
-                capman.reset_capturings()
-        plugins = kwargs.setdefault("plugins", [])
-        rc = ResetCapturing()
-        plugins.append(rc)
-        return pytest.main(*args, **kwargs)
+        return subprocess.Popen(cmdargs,
+                                stdout=stdout, stderr=stderr, **kw)
 
     def run(self, *cmdargs):
         return self._run(*cmdargs)
@@ -438,40 +443,47 @@ class TmpTestdir:
         p1 = self.tmpdir.join("stdout")
         p2 = self.tmpdir.join("stderr")
         print_("running", cmdargs, "curdir=", py.path.local())
-        f1 = p1.open("wb")
-        f2 = p2.open("wb")
-        now = time.time()
-        popen = self.popen(cmdargs, stdout=f1, stderr=f2,
-            close_fds=(sys.platform != "win32"))
-        ret = popen.wait()
-        f1.close()
-        f2.close()
-        out = p1.read("rb")
-        out = getdecoded(out).splitlines()
-        err = p2.read("rb")
-        err = getdecoded(err).splitlines()
-        def dump_lines(lines, fp):
-            try:
-                for line in lines:
-                    py.builtin.print_(line, file=fp)
-            except UnicodeEncodeError:
-                print("couldn't print to %s because of encoding" % (fp,))
-        dump_lines(out, sys.stdout)
-        dump_lines(err, sys.stderr)
+        f1 = codecs.open(str(p1), "w", encoding="utf8")
+        f2 = codecs.open(str(p2), "w", encoding="utf8")
+        try:
+            now = time.time()
+            popen = self.popen(cmdargs, stdout=f1, stderr=f2,
+                close_fds=(sys.platform != "win32"))
+            ret = popen.wait()
+        finally:
+            f1.close()
+            f2.close()
+        f1 = codecs.open(str(p1), "r", encoding="utf8")
+        f2 = codecs.open(str(p2), "r", encoding="utf8")
+        try:
+            out = f1.read().splitlines()
+            err = f2.read().splitlines()
+        finally:
+            f1.close()
+            f2.close()
+        self._dump_lines(out, sys.stdout)
+        self._dump_lines(err, sys.stderr)
         return RunResult(ret, out, err, time.time()-now)
 
+    def _dump_lines(self, lines, fp):
+        try:
+            for line in lines:
+                py.builtin.print_(line, file=fp)
+        except UnicodeEncodeError:
+            print("couldn't print to %s because of encoding" % (fp,))
+
     def runpybin(self, scriptname, *args):
         fullargs = self._getpybinargs(scriptname) + args
         return self.run(*fullargs)
 
     def _getpybinargs(self, scriptname):
         if not self.request.config.getvalue("notoolsonpath"):
-            # XXX we rely on script refering to the correct environment
-            # we cannot use "(py.std.sys.executable,script)"
-            # becaue on windows the script is e.g. a py.test.exe
-            return (py.std.sys.executable, _pytest_fullpath,)
+            # XXX we rely on script referring to the correct environment
+            # we cannot use "(sys.executable,script)"
+            # because on windows the script is e.g. a py.test.exe
+            return (sys.executable, _pytest_fullpath,) # noqa
         else:
-            py.test.skip("cannot run %r with --no-tools-on-path" % scriptname)
+            pytest.skip("cannot run %r with --no-tools-on-path" % scriptname)
 
     def runpython(self, script, prepend=True):
         if prepend:
@@ -489,7 +501,7 @@ class TmpTestdir:
 
     def runpython_c(self, command):
         command = self._getsysprepend() + command
-        return self.run(py.std.sys.executable, "-c", command)
+        return self.run(sys.executable, "-c", command)
 
     def runpytest(self, *args):
         p = py.path.local.make_numbered_dir(prefix="runpytest-",
@@ -508,20 +520,23 @@ class TmpTestdir:
 
     def spawn_pytest(self, string, expect_timeout=10.0):
         if self.request.config.getvalue("notoolsonpath"):
-            py.test.skip("--no-tools-on-path prevents running pexpect-spawn tests")
+            pytest.skip("--no-tools-on-path prevents running pexpect-spawn tests")
         basetemp = self.tmpdir.mkdir("pexpect")
         invoke = " ".join(map(str, self._getpybinargs("py.test")))
         cmd = "%s --basetemp=%s %s" % (invoke, basetemp, string)
         return self.spawn(cmd, expect_timeout=expect_timeout)
 
     def spawn(self, cmd, expect_timeout=10.0):
-        pexpect = py.test.importorskip("pexpect", "2.4")
-        if hasattr(sys, 'pypy_version_info') and '64' in py.std.platform.machine():
+        pexpect = pytest.importorskip("pexpect", "3.0")
+        if hasattr(sys, 'pypy_version_info') and '64' in platform.machine():
             pytest.skip("pypy-64 bit not supported")
         if sys.platform == "darwin":
             pytest.xfail("pexpect does not work reliably on darwin?!")
-        logfile = self.tmpdir.join("spawn.out")
-        child = pexpect.spawn(cmd, logfile=logfile.open("w"))
+        if sys.platform.startswith("freebsd"):
+            pytest.xfail("pexpect does not work reliably on freebsd")
+        logfile = self.tmpdir.join("spawn.out").open("wb")
+        child = pexpect.spawn(cmd, logfile=logfile)
+        self.request.addfinalizer(logfile.close)
         child.timeout = expect_timeout
         return child
 
@@ -586,9 +601,10 @@ class ReportRecorder(object):
         passed = []
         skipped = []
         failed = []
-        for rep in self.getreports("pytest_runtest_logreport"):
+        for rep in self.getreports(
+            "pytest_collectreport pytest_runtest_logreport"):
             if rep.passed:
-                if rep.when == "call":
+                if getattr(rep, "when", None) == "call":
                     passed.append(rep)
             elif rep.skipped:
                 skipped.append(rep)
@@ -651,9 +667,15 @@ class LineMatcher:
             else:
                 raise ValueError("line %r not found in output" % line)
 
+    def get_lines_after(self, fnline):
+        for i, line in enumerate(self.lines):
+            if fnline == line or fnmatch(line, fnline):
+                return self.lines[i+1:]
+        raise ValueError("line %r not found in output" % fnline)
+
     def fnmatch_lines(self, lines2):
         def show(arg1, arg2):
-            py.builtin.print_(arg1, arg2, file=py.std.sys.stderr)
+            py.builtin.print_(arg1, arg2, file=sys.stderr)
         lines2 = self._getlines(lines2)
         lines1 = self.lines[:]
         nextline = None
@@ -677,4 +699,4 @@ class LineMatcher:
                     show("    and:", repr(nextline))
                 extralines.append(nextline)
             else:
-                py.test.fail("remains unmatched: %r, see stderr" % (line,))
+                pytest.fail("remains unmatched: %r, see stderr" % (line,))

_pytest/recwarn.py

@@ -1,19 +1,19 @@
 """ recording warnings during test function execution. """
 
-import py
-import sys, os
+import sys
+import warnings
+
 
 def pytest_funcarg__recwarn(request):
     """Return a WarningsRecorder instance that provides these methods:
 
     * ``pop(category=None)``: return last warning matching the category.
     * ``clear()``: clear list of warnings
-   
+
     See http://docs.python.org/library/warnings.html for information
     on warning categories.
     """
     if sys.version_info >= (2,7):
-        import warnings
         oldfilters = warnings.filters[:]
         warnings.simplefilter('default')
         def reset_filters():
@@ -30,26 +30,24 @@ def deprecated_call(func, *args, **kwargs):
     """ assert that calling ``func(*args, **kwargs)``
     triggers a DeprecationWarning.
     """
-    warningmodule = py.std.warnings
     l = []
-    oldwarn_explicit = getattr(warningmodule, 'warn_explicit')
+    oldwarn_explicit = getattr(warnings, 'warn_explicit')
     def warn_explicit(*args, **kwargs):
         l.append(args)
         oldwarn_explicit(*args, **kwargs)
-    oldwarn = getattr(warningmodule, 'warn')
+    oldwarn = getattr(warnings, 'warn')
     def warn(*args, **kwargs):
         l.append(args)
         oldwarn(*args, **kwargs)
 
-    warningmodule.warn_explicit = warn_explicit
-    warningmodule.warn = warn
+    warnings.warn_explicit = warn_explicit
+    warnings.warn = warn
     try:
         ret = func(*args, **kwargs)
     finally:
-        warningmodule.warn_explicit = warn_explicit
-        warningmodule.warn = warn
+        warnings.warn_explicit = warn_explicit
+        warnings.warn = warn
     if not l:
-        #print warningmodule
         __tracebackhide__ = True
         raise AssertionError("%r did not produce DeprecationWarning" %(func,))
     return ret
@@ -65,7 +63,6 @@ class RecordedWarning:
 
 class WarningsRecorder:
     def __init__(self):
-        warningmodule = py.std.warnings
         self.list = []
         def showwarning(message, category, filename, lineno, line=0):
             self.list.append(RecordedWarning(
@@ -76,8 +73,8 @@ class WarningsRecorder:
             except TypeError:
                 # < python2.6
                 self.old_showwarning(message, category, filename, lineno)
-        self.old_showwarning = warningmodule.showwarning
-        warningmodule.showwarning = showwarning
+        self.old_showwarning = warnings.showwarning
+        warnings.showwarning = showwarning
 
     def pop(self, cls=Warning):
         """ pop the first recorded warning, raise exception if not exists."""
@@ -88,7 +85,6 @@ class WarningsRecorder:
         assert 0, "%r not found in %r" %(cls, self.list)
 
     #def resetregistry(self):
-    #    import warnings
     #    warnings.onceregistry.clear()
     #    warnings.__warningregistry__.clear()
 
@@ -96,4 +92,4 @@ class WarningsRecorder:
         self.list[:] = []
 
     def finalize(self):
-        py.std.warnings.showwarning = self.old_showwarning
+        warnings.showwarning = self.old_showwarning

_pytest/resultlog.py

@@ -1,10 +1,12 @@
-""" (disabled by default) create result information in a plain text file. """
+""" log machine-parseable test session result information in a plain
+text file.
+"""
 
 import py
 
 def pytest_addoption(parser):
     group = parser.getgroup("terminal reporting", "resultlog plugin options")
-    group.addoption('--resultlog', action="store", dest="resultlog",
+    group.addoption('--resultlog', '--result-log', action="store",
         metavar="path", default=None,
         help="path for machine-readable result log.")
 
@@ -83,7 +85,7 @@ class ResultLog(object):
         if not report.passed:
             if report.failed:
                 code = "F"
-                longrepr = str(report.longrepr.reprcrash)
+                longrepr = str(report.longrepr)
             else:
                 assert report.skipped
                 code = "S"
@@ -91,5 +93,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

@@ -1,6 +1,10 @@
 """ basic collect and runtest protocol implementations """
+import bdb
+import sys
+from time import time
 
-import py, sys, time
+import py
+import pytest
 from py._code.code import TerminalRepr
 
 def pytest_namespace():
@@ -17,7 +21,7 @@ def pytest_namespace():
 def pytest_addoption(parser):
     group = parser.getgroup("terminal reporting", "reporting", after="general")
     group.addoption('--durations',
-         action="store", type="int", default=None, metavar="N",
+         action="store", type=int, default=None, metavar="N",
          help="show N slowest setup/test durations (N=0 for all)."),
 
 def pytest_terminal_summary(terminalreporter):
@@ -47,45 +51,35 @@ 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):
+    hasrequest = hasattr(item, "_request")
+    if hasrequest and not item._request:
+        item._initrequest()
     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))
+    # after all teardown hooks have been called
+    # want funcargs and request info to go away
+    if hasrequest:
+        item._request = False
+        item.funcargs = None
     return reports
 
 def pytest_runtest_setup(item):
@@ -94,17 +88,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 +105,26 @@ 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)
+    if check_interactive_exception(call, report):
+        hook.pytest_exception_interact(node=item, call=call, report=report)
     return report
 
-def call_runtest_hook(item, when):
+def check_interactive_exception(call, report):
+    return call.excinfo and not (
+                hasattr(report, "wasxfail") or
+                call.excinfo.errisinstance(skip.Exception) or
+                call.excinfo.errisinstance(bdb.BdbQuit))
+
+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. """
@@ -141,16 +134,15 @@ class CallInfo:
         #: context of invocation: one of "setup", "call",
         #: "teardown", "memocollect"
         self.when = when
-        self.start = time.time()
+        self.start = time()
         try:
-            try:
-                self.result = func()
-            except KeyboardInterrupt:
-                raise
-            except:
-                self.excinfo = py.code.ExceptionInfo()
-        finally:
-            self.stop = time.time()
+            self.result = func()
+        except KeyboardInterrupt:
+            self.stop = time()
+            raise
+        except:
+            self.excinfo = py.code.ExceptionInfo()
+        self.stop = time()
 
     def __repr__(self):
         if self.excinfo:
@@ -170,6 +162,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'):
@@ -177,7 +173,15 @@ class BaseReport(object):
         if hasattr(longrepr, 'toterminal'):
             longrepr.toterminal(out)
         else:
-            out.line(str(longrepr))
+            try:
+                out.line(longrepr)
+            except UnicodeEncodeError:
+                out.line("<unprintable longrepr>")
+
+    def get_sections(self, prefix):
+        for name, content in self.sections:
+            if name.startswith(prefix):
+                yield prefix, content
 
     passed = property(lambda x: x.outcome == "passed")
     failed = property(lambda x: x.outcome == "failed")
@@ -192,15 +196,15 @@ def pytest_runtest_makereport(item, call):
     duration = call.stop-call.start
     keywords = dict([(x,1) for x in item.keywords])
     excinfo = call.excinfo
+    sections = []
     if not call.excinfo:
         outcome = "passed"
         longrepr = None
     else:
-        excinfo = call.excinfo
         if not isinstance(excinfo, py.code.ExceptionInfo):
             outcome = "failed"
             longrepr = excinfo
-        elif excinfo.errisinstance(py.test.skip.Exception):
+        elif excinfo.errisinstance(pytest.skip.Exception):
             outcome = "skipped"
             r = excinfo._getreprcrash()
             longrepr = (str(r.path), r.lineno, r.message)
@@ -209,17 +213,20 @@ def pytest_runtest_makereport(item, call):
             if call.when == "call":
                 longrepr = item.repr_failure(excinfo)
             else: # exception in setup or teardown
-                longrepr = item._repr_failure_py(excinfo)
+                longrepr = item._repr_failure_py(excinfo,
+                                            style=item.config.option.tbstyle)
+    for rwhen, key, content in item._report_sections:
+        sections.append(("Captured std%s %s" %(key, rwhen), content))
     return TestReport(item.nodeid, item.location,
                       keywords, outcome, longrepr, when,
-                      duration=duration)
+                      sections, duration)
 
 class TestReport(BaseReport):
     """ Basic test report object (also used for setup and teardown calls if
     they fail).
     """
-    def __init__(self, nodeid, location,
-            keywords, outcome, longrepr, when, sections=(), duration=0):
+    def __init__(self, nodeid, location, keywords, outcome,
+                 longrepr, when, sections=(), duration=0, **extra):
         #: normalized collection node id
         self.nodeid = nodeid
 
@@ -248,6 +255,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 +264,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")
@@ -265,7 +275,9 @@ def pytest_make_collect_report(collector):
     if not call.excinfo:
         outcome = "passed"
     else:
-        if call.excinfo.errisinstance(py.test.skip.Exception):
+        from _pytest import nose
+        skip_exceptions = (Skipped,) + nose.get_skip_exceptions()
+        if call.excinfo.errisinstance(skip_exceptions):
             outcome = "skipped"
             r = collector._repr_failure_py(call.excinfo, "line").reprcrash
             longrepr = (str(r.path), r.lineno, r.message)
@@ -275,16 +287,21 @@ def pytest_make_collect_report(collector):
             if not hasattr(errorinfo, "toterminal"):
                 errorinfo = CollectErrorRepr(errorinfo)
             longrepr = errorinfo
-    return CollectReport(collector.nodeid, outcome, longrepr,
+    rep = CollectReport(collector.nodeid, outcome, longrepr,
         getattr(call, 'result', None))
+    rep.call = call  # see collect_one_node
+    return rep
+
 
 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):
@@ -298,7 +315,7 @@ class CollectErrorRepr(TerminalRepr):
     def __init__(self, msg):
         self.longrepr = msg
     def toterminal(self, out):
-        out.line(str(self.longrepr), red=True)
+        out.line(self.longrepr, red=True)
 
 class SetupState(object):
     """ shared state for setting up/tearing down test items or collectors. """
@@ -311,8 +328,9 @@ class SetupState(object):
         if colitem is None, this will add a finalizer that
         is called at the end of teardown_all().
         """
-        assert hasattr(finalizer, '__call__')
-        #assert colitem in self.stack
+        assert colitem and not isinstance(colitem, tuple)
+        assert py.builtin.callable(finalizer)
+        #assert colitem in self.stack  # some unit tests don't setup stack :/
         self._finalizers.setdefault(colitem, []).append(finalizer)
 
     def _pop_and_teardown(self):
@@ -321,26 +339,36 @@ class SetupState(object):
 
     def _callfinalizers(self, colitem):
         finalizers = self._finalizers.pop(colitem, None)
+        exc = None
         while finalizers:
             fin = finalizers.pop()
-            fin()
+            try:
+                fin()
+            except Exception:
+                # XXX Only first exception will be seen by user,
+                #     ideally all should be reported.
+                if exc is None:
+                    exc = sys.exc_info()
+        if exc:
+            py.builtin._reraise(*exc)
 
     def _teardown_with_finalization(self, colitem):
         self._callfinalizers(colitem)
-        if colitem:
+        if hasattr(colitem, "teardown"):
             colitem.teardown()
         for colitem in self._finalizers:
-            assert colitem is None or colitem in self.stack
+            assert colitem is None or colitem in self.stack \
+             or isinstance(colitem, tuple)
 
     def teardown_all(self):
         while self.stack:
             self._pop_and_teardown()
-        self._teardown_with_finalization(None)
+        for key in list(self._finalizers):
+            self._teardown_with_finalization(key)
         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):
@@ -367,6 +395,16 @@ class SetupState(object):
                 col._prepare_exc = sys.exc_info()
                 raise
 
+def collect_one_node(collector):
+    ihook = collector.ihook
+    ihook.pytest_collectstart(collector=collector)
+    rep = ihook.pytest_make_collect_report(collector=collector)
+    call = rep.__dict__.pop("call", None)
+    if call and check_interactive_exception(call, rep):
+        ihook.pytest_exception_interact(node=collector, call=call, report=rep)
+    return rep
+
+
 # =============================================================
 # Test OutcomeExceptions and helpers for creating them.
 
@@ -376,6 +414,7 @@ class OutcomeException(Exception):
         contain info about test and collection outcomes.
     """
     def __init__(self, msg=None, pytrace=True):
+        Exception.__init__(self, msg)
         self.msg = msg
         self.pytrace = pytrace
 
@@ -391,7 +430,7 @@ class Skipped(OutcomeException):
     __module__ = 'builtins'
 
 class Failed(OutcomeException):
-    """ raised from an explicit call to py.test.fail() """
+    """ raised from an explicit call to pytest.fail() """
     __module__ = 'builtins'
 
 class Exit(KeyboardInterrupt):
@@ -411,7 +450,7 @@ exit.Exception = Exit
 
 def skip(msg=""):
     """ skip an executing test with the given message.  Note: it's usually
-    better to use the py.test.mark.skipif marker to declare a test to be
+    better to use the pytest.mark.skipif marker to declare a test to be
     skipped under certain conditions like mismatching platforms or
     dependencies.  See the pytest_skipping plugin for details.
     """
@@ -421,7 +460,9 @@ skip.Exception = Skipped
 
 def fail(msg="", pytrace=True):
     """ explicitely fail an currently-executing test with the given Message.
-    if @pytrace is not True the msg represents the full failure information.
+
+    :arg pytrace: if false the msg represents the full failure information
+                  and no python traceback will be reported.
     """
     __tracebackhide__ = True
     raise Failed(msg=msg, pytrace=pytrace)
@@ -429,24 +470,25 @@ fail.Exception = Failed
 
 
 def importorskip(modname, minversion=None):
-    """ return imported module if it has a higher __version__ than the
-    optionally specified 'minversion' - otherwise call py.test.skip()
-    with a message detailing the mismatch.
+    """ return imported module if it has at least "minversion" as its
+    __version__ attribute.  If no minversion is specified the a skip
+    is only triggered if the module can not be imported.
+    Note that version comparison only works with simple version strings
+    like "1.2.3" but not "1.2.3.dev1" or others.
     """
     __tracebackhide__ = True
     compile(modname, '', 'eval') # to catch syntaxerrors
     try:
-        mod = __import__(modname, None, None, ['__doc__'])
+        __import__(modname)
     except ImportError:
-        py.test.skip("could not import %r" %(modname,))
+        skip("could not import %r" %(modname,))
+    mod = sys.modules[modname]
     if minversion is None:
         return mod
     verattr = getattr(mod, '__version__', None)
-    if isinstance(minversion, str):
-        minver = minversion.split(".")
-    else:
-        minver = list(minversion)
-    if verattr is None or verattr.split(".") < minver:
-        py.test.skip("module %r has __version__ %r, required is: %r" %(
-                     modname, verattr, minversion))
+    def intver(verstring):
+        return [int(x) for x in verstring.split(".")]
+    if verattr is None or intver(verattr) < intver(minversion):
+        skip("module %r has __version__ %r, required is: %r" %(
+             modname, verattr, minversion))
     return mod

_pytest/skipping.py

@@ -1,7 +1,10 @@
 """ support for skip/xfail functions and markers. """
-
-import py, pytest
+import os
 import sys
+import traceback
+
+import py
+import pytest
 
 def pytest_addoption(parser):
     group = parser.getgroup("general")
@@ -10,25 +13,36 @@ def pytest_addoption(parser):
            help="run tests even if they are marked xfail")
 
 def pytest_configure(config):
+    if config.option.runxfail:
+        old = pytest.xfail
+        config._cleanup.append(lambda: setattr(pytest, "xfail", old))
+        def nop(*args, **kwargs):
+            pass
+        nop.Exception = XFailed
+        setattr(pytest, "xfail", nop)
+
     config.addinivalue_line("markers",
-        "skipif(*conditions): skip the given test function if evaluation "
-        "of all conditions has a True value.  Evaluation happens within the "
+        "skipif(condition): skip the given test function if eval(condition) "
+        "results in 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. "
+        "skips the test if we are on the win32 platform. see "
+        "http://pytest.org/latest/skipping.html"
     )
     config.addinivalue_line("markers",
-        "xfail(*conditions, reason=None, run=True): mark the the test function "
-        "as an expected failure. Optionally specify a reason and run=False "
-        "if you don't even want to execute the test function. Any positional "
-        "condition strings will be evaluated (like with skipif) and if one is "
-        "False the marker will not be applied."
+        "xfail(condition, reason=None, run=True, raises=None): mark the the test function "
+        "as an expected failure if eval(condition) has a True value. "
+        "Optionally specify a reason for better reporting and run=False if "
+        "you don't even want to execute the test function. If only specific "
+        "exception(s) are expected, you can list them in raises, and if the test fails "
+        "in other ways, it will be reported as a true failure. "
+        "See http://pytest.org/latest/skipping.html"
     )
 
 def pytest_namespace():
     return dict(xfail=xfail)
 
 class XFailed(pytest.fail.Exception):
-    """ raised from an explicit call to py.test.xfail() """
+    """ raised from an explicit call to pytest.xfail() """
 
 def xfail(reason=""):
     """ xfail an executing test or setup functions with the given reason."""
@@ -44,6 +58,7 @@ class MarkEvaluator:
     @property
     def holder(self):
         return self.item.keywords.get(self.name, None)
+
     def __bool__(self):
         return bool(self.holder)
     __nonzero__ = __bool__
@@ -51,6 +66,12 @@ class MarkEvaluator:
     def wasvalid(self):
         return not hasattr(self, 'exc')
 
+    def invalidraise(self, exc):
+        raises = self.get('raises')
+        if not raises:
+            return
+        return not isinstance(exc, raises)
+
     def istrue(self):
         try:
             return self._istrue()
@@ -62,7 +83,7 @@ class MarkEvaluator:
                 msg = [" " * (self.exc[1].offset + 4) + "^",]
                 msg.append("SyntaxError: invalid syntax")
             else:
-                msg = py.std.traceback.format_exception_only(*self.exc[:2])
+                msg = traceback.format_exception_only(*self.exc[:2])
             pytest.fail("Error evaluating %r expression\n"
                         "    %s\n"
                         "%s"
@@ -70,7 +91,7 @@ class MarkEvaluator:
                         pytrace=False)
 
     def _getglobals(self):
-        d = {'os': py.std.os, 'sys': py.std.sys, 'config': self.item.config}
+        d = {'os': os, 'sys': sys, 'config': self.item.config}
         func = self.item.obj
         try:
             d.update(func.__globals__)
@@ -85,10 +106,14 @@ class MarkEvaluator:
                 self.result = False
                 for expr in self.holder.args:
                     self.expr = expr
-                    if isinstance(expr, str):
+                    if isinstance(expr, py.builtin._basestring):
                         result = cached_eval(self.item.config, expr, d)
                     else:
-                        pytest.fail("expression is not a string")
+                        if self.get("reason") is None:
+                            # XXX better be checked at collection time
+                            pytest.fail("you need to specify reason=STRING "
+                                        "when using booleans as conditions.")
+                        result = bool(expr)
                     if result:
                         self.result = True
                         self.expr = expr
@@ -110,12 +135,11 @@ class MarkEvaluator:
         return expl
 
 
+@pytest.mark.tryfirst
 def pytest_runtest_setup(item):
-    if not isinstance(item, pytest.Function):
-        return
     evalskip = MarkEvaluator(item, 'skipif')
     if evalskip.istrue():
-        py.test.skip(evalskip.getexplanation())
+        pytest.skip(evalskip.getexplanation())
     item._evalxfail = MarkEvaluator(item, 'xfail')
     check_xfail_no_run(item)
 
@@ -127,44 +151,54 @@ def check_xfail_no_run(item):
         evalxfail = item._evalxfail
         if evalxfail.istrue():
             if not evalxfail.get('run', True):
-                py.test.xfail("[NOTRUN] " + evalxfail.getexplanation())
+                pytest.xfail("[NOTRUN] " + evalxfail.getexplanation())
 
 def pytest_runtest_makereport(__multicall__, item, call):
-    if not isinstance(item, pytest.Function):
-        return
+    # unitttest special case, see setting of _unexpectedsuccess
+    if hasattr(item, '_unexpectedsuccess'):
+        rep = __multicall__.execute()
+        if rep.when == "call":
+            # we need to translate into how pytest encodes xpass
+            rep.wasxfail = "reason: " + repr(item._unexpectedsuccess)
+            rep.outcome = "failed"
+        return rep
     if not (call.excinfo and
-        call.excinfo.errisinstance(py.test.xfail.Exception)):
+        call.excinfo.errisinstance(pytest.xfail.Exception)):
         evalxfail = getattr(item, '_evalxfail', None)
         if not evalxfail:
             return
-    if call.excinfo and call.excinfo.errisinstance(py.test.xfail.Exception):
+    if call.excinfo and call.excinfo.errisinstance(pytest.xfail.Exception):
         if not item.config.getvalue("runxfail"):
             rep = __multicall__.execute()
-            rep.keywords['xfail'] = "reason: " + call.excinfo.value.msg
+            rep.wasxfail = "reason: " + call.excinfo.value.msg
             rep.outcome = "skipped"
             return rep
     rep = __multicall__.execute()
     evalxfail = item._evalxfail
-    if not item.config.option.runxfail:
-        if evalxfail.wasvalid() and evalxfail.istrue():
-            if call.excinfo:
-                rep.outcome = "skipped"
-                rep.keywords['xfail'] = evalxfail.getexplanation()
-            elif call.when == "call":
-                rep.outcome = "failed"
-                rep.keywords['xfail'] = evalxfail.getexplanation()
-            return rep
-    if 'xfail' in rep.keywords:
-        del rep.keywords['xfail']
+    if not rep.skipped:
+        if not item.config.option.runxfail:
+            if evalxfail.wasvalid() and evalxfail.istrue():
+                if call.excinfo:
+                    if evalxfail.invalidraise(call.excinfo.value):
+                        rep.outcome = "failed"
+                        return rep
+                    else:
+                        rep.outcome = "skipped"
+                elif call.when == "call":
+                    rep.outcome = "failed"
+                else:
+                    return rep
+                rep.wasxfail = evalxfail.getexplanation()
+                return rep
     return rep
 
 # called by terminalreporter progress reporting
 def pytest_report_teststatus(report):
-    if 'xfail' in report.keywords:
+    if hasattr(report, "wasxfail"):
         if report.skipped:
             return "xfailed", "x", "xfail"
         elif report.failed:
-            return "xpassed", "X", "XPASS"
+            return "xpassed", "X", ("XPASS", {'yellow': True})
 
 # called by the terminalreporter instance/plugin
 def pytest_terminal_summary(terminalreporter):
@@ -195,7 +229,6 @@ def pytest_terminal_summary(terminalreporter):
             tr._tw.line(line)
 
 def show_simple(terminalreporter, lines, stat, format):
-    tw = terminalreporter._tw
     failed = terminalreporter.stats.get(stat)
     if failed:
         for rep in failed:
@@ -207,7 +240,7 @@ def show_xfailed(terminalreporter, lines):
     if xfailed:
         for rep in xfailed:
             pos = rep.nodeid
-            reason = rep.keywords['xfail']
+            reason = rep.wasxfail
             lines.append("XFAIL %s" % (pos,))
             if reason:
                 lines.append("  " + str(reason))
@@ -217,7 +250,7 @@ def show_xpassed(terminalreporter, lines):
     if xpassed:
         for rep in xpassed:
             pos = rep.nodeid
-            reason = rep.keywords['xfail']
+            reason = rep.wasxfail
             lines.append("XPASS %s %s" %(pos, reason))
 
 def cached_eval(config, expr, d):

_pytest/standalonetemplate.py

@@ -6,13 +6,16 @@ sources = """
 import sys
 import base64
 import zlib
-import imp
 
 class DictImporter(object):
     def __init__(self, sources):
         self.sources = sources
 
     def find_module(self, fullname, path=None):
+        if fullname == "argparse" and sys.version_info >= (2,7):
+            # we were generated with <python2.7 (which pulls in argparse)
+            # but we are running now on a stdlib which has it, so use that.
+            return None
         if fullname in self.sources:
             return self
         if fullname + '.__init__' in self.sources:
@@ -36,7 +39,7 @@ class DictImporter(object):
         if is_pkg:
             module.__path__ = [fullname]
 
-        do_exec(co, module.__dict__)
+        do_exec(co, module.__dict__) # noqa
         return sys.modules[fullname]
 
     def get_source(self, name):
@@ -57,7 +60,7 @@ if __name__ == "__main__":
         sources = pickle.loads(zlib.decompress(base64.decodestring(sources)))
 
     importer = DictImporter(sources)
-    sys.meta_path.append(importer)
+    sys.meta_path.insert(0, importer)
 
     entry = "@ENTRY@"
-    do_exec(entry, locals())
+    do_exec(entry, locals()) # noqa

_pytest/terminal.py

@@ -2,20 +2,22 @@
 
 This is a good source for looking at the various reporting hooks.
 """
-import pytest, py
+import pytest
+import py
 import sys
-import os
+import time
+
 
 def pytest_addoption(parser):
     group = parser.getgroup("terminal reporting", "reporting", after="general")
     group._addoption('-v', '--verbose', action="count",
                dest="verbose", default=0, help="increase verbosity."),
     group._addoption('-q', '--quiet', action="count",
-               dest="quiet", default=0, help="decreate verbosity."),
+               dest="quiet", default=0, help="decrease verbosity."),
     group._addoption('-r',
          action="store", dest="reportchars", default=None, metavar="chars",
          help="show extra test summary info as specified by chars (f)ailed, "
-              "(E)error, (s)skipped, (x)failed, (X)passed.")
+              "(E)error, (s)skipped, (x)failed, (X)passed (w)warnings.")
     group._addoption('-l', '--showlocals',
          action="store_true", dest="showlocals", default=False,
          help="show locals in tracebacks (disabled by default).")
@@ -23,29 +25,20 @@ def pytest_addoption(parser):
          action="store", dest="report", default=None, metavar="opts",
          help="(deprecated, use -r)")
     group._addoption('--tb', metavar="style",
-               action="store", dest="tbstyle", default='long',
-               type="choice", choices=['long', 'short', 'no', 'line', 'native'],
+               action="store", dest="tbstyle", default='auto',
+               choices=['auto', 'long', 'short', 'no', 'line', 'native'],
                help="traceback print mode (long/short/line/native/no).")
-    group._addoption('--fulltrace',
-               action="store_true", dest="fulltrace", default=False,
+    group._addoption('--fulltrace', '--full-trace',
+               action="store_true", default=False,
                help="don't cut any tracebacks (default is to cut).")
+    group._addoption('--color', metavar="color",
+               action="store", dest="color", default='auto',
+               choices=['yes', 'no', 'auto'],
+               help="color terminal output (yes/no/auto).")
 
 def pytest_configure(config):
     config.option.verbose -= config.option.quiet
-    # we try hard to make printing resilient against
-    # later changes on FD level.
-    stdout = py.std.sys.stdout
-    if hasattr(os, 'dup') and hasattr(stdout, 'fileno'):
-        try:
-            newfd = os.dup(stdout.fileno())
-            #print "got newfd", newfd
-        except ValueError:
-            pass
-        else:
-            stdout = os.fdopen(newfd, stdout.mode, 1)
-            config._cleanup.append(lambda: stdout.close())
-
-    reporter = TerminalReporter(config, stdout)
+    reporter = TerminalReporter(config, sys.stdout)
     config.pluginmanager.register(reporter, 'terminalreporter')
     if config.option.debug or config.option.traceconfig:
         def mywriter(tags, args):
@@ -58,7 +51,7 @@ def getreportopt(config):
     optvalue = config.option.report
     if optvalue:
         py.builtin.print_("DEPRECATED: use -r instead of --report option.",
-            file=py.std.sys.stderr)
+            file=sys.stderr)
         if optvalue:
             for setting in optvalue.split(","):
                 setting = setting.strip()
@@ -84,6 +77,14 @@ def pytest_report_teststatus(report):
             letter = "f"
     return report.outcome, letter, report.outcome.upper()
 
+class WarningReport:
+    def __init__(self, code, message, nodeid=None, fslocation=None):
+        self.code = code
+        self.message = message
+        self.nodeid = nodeid
+        self.fslocation = fslocation
+
+
 class TerminalReporter:
     def __init__(self, config, file=None):
         self.config = config
@@ -94,24 +95,28 @@ class TerminalReporter:
         self._numcollected = 0
 
         self.stats = {}
-        self.curdir = py.path.local()
+        self.startdir = self.curdir = py.path.local()
         if file is None:
-            file = py.std.sys.stdout
-        self._tw = py.io.TerminalWriter(file)
+            file = sys.stdout
+        self._tw = self.writer = py.io.TerminalWriter(file)
+        if self.config.option.color == 'yes':
+            self._tw.hasmarkup = True
+        if self.config.option.color == 'no':
+            self._tw.hasmarkup = False
         self.currentfspath = None
         self.reportchars = getreportopt(config)
         self.hasmarkup = self._tw.hasmarkup
 
     def hasopt(self, char):
-        char = {'xfailed': 'x', 'skipped': 's'}.get(char,char)
+        char = {'xfailed': 'x', 'skipped': 's'}.get(char, char)
         return char in self.reportchars
 
     def write_fspath_result(self, fspath, res):
         if fspath != self.currentfspath:
             self.currentfspath = fspath
-            #fspath = self.curdir.bestrelpath(fspath)
+            #fspath = self.startdir.bestrelpath(fspath)
             self._tw.line()
-            #relpath = self.curdir.bestrelpath(fspath)
+            #relpath = self.startdir.bestrelpath(fspath)
             self._tw.write(fspath + " ")
         self._tw.write(res)
 
@@ -133,7 +138,8 @@ class TerminalReporter:
         self._tw.write(content, **markup)
 
     def write_line(self, line, **markup):
-        line = str(line)
+        if not py.builtin._istext(line):
+            line = py.builtin.text(line, errors="replace")
         self.ensure_newline()
         self._tw.line(line, **markup)
 
@@ -145,14 +151,26 @@ class TerminalReporter:
         self.ensure_newline()
         self._tw.sep(sep, title, **markup)
 
+    def section(self, title, sep="=", **kw):
+        self._tw.sep(sep, title, **kw)
+
+    def line(self, msg, **kw):
+        self._tw.line(msg, **kw)
+
     def pytest_internalerror(self, excrepr):
-        for line in str(excrepr).split("\n"):
+        for line in py.builtin.text(excrepr).split("\n"):
             self.write_line("INTERNALERROR> " + line)
         return 1
 
+    def pytest_logwarning(self, code, fslocation, message, nodeid):
+        warnings = self.stats.setdefault("warnings", [])
+        warning = WarningReport(code=code, fslocation=fslocation,
+                                message=message, nodeid=nodeid)
+        warnings.append(warning)
+
     def pytest_plugin_registered(self, plugin):
         if self.config.option.traceconfig:
-            msg = "PLUGIN registered: %s" %(plugin,)
+            msg = "PLUGIN registered: %s" % (plugin,)
             # XXX this event may happen during setup/teardown time
             #     which unfortunately captures our output here
             #     which garbles our output if we use self.write_line
@@ -161,9 +179,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
@@ -179,6 +194,7 @@ class TerminalReporter:
         res = self.config.hook.pytest_report_teststatus(report=rep)
         cat, letter, word = res
         self.stats.setdefault(cat, []).append(rep)
+        self._tests_ran = True
         if not letter and not word:
             # probably passed setup/teardown
             return
@@ -210,7 +226,7 @@ class TerminalReporter:
                 self.currentfspath = -2
 
     def pytest_collection(self):
-        if not self.hasmarkup:
+        if not self.hasmarkup and self.config.option.verbose >= 1:
             self.write("collecting ... ", bold=True)
 
     def pytest_collectreport(self, report):
@@ -225,6 +241,9 @@ class TerminalReporter:
             self.report_collect()
 
     def report_collect(self, final=False):
+        if self.config.option.verbose < 0:
+            return
+
         errors = len(self.stats.get('error', []))
         skipped = len(self.stats.get('skipped', []))
         if final:
@@ -246,8 +265,9 @@ class TerminalReporter:
     def pytest_collection_modifyitems(self):
         self.report_collect(True)
 
+    @pytest.mark.trylast
     def pytest_sessionstart(self, session):
-        self._sessionstarttime = py.std.time.time()
+        self._sessionstarttime = time.time()
         if not self.showheader:
             return
         self.write_sep("=", "test session starts", bold=True)
@@ -256,16 +276,28 @@ class TerminalReporter:
         if hasattr(sys, 'pypy_version_info'):
             verinfo = ".".join(map(str, sys.pypy_version_info[:3]))
             msg += "[pypy-%s-%s]" % (verinfo, sys.pypy_version_info[3])
-        msg += " -- pytest-%s" % (py.test.__version__)
+        msg += " -- py-%s -- pytest-%s" % (py.__version__, pytest.__version__)
         if self.verbosity > 0 or self.config.option.debug or \
            getattr(self.config.option, 'pastebin', None):
             msg += " -- " + str(sys.executable)
         self.write_line(msg)
-        lines = self.config.hook.pytest_report_header(config=self.config)
+        lines = self.config.hook.pytest_report_header(
+            config=self.config, startdir=self.startdir)
         lines.reverse()
         for line in flatten(lines):
             self.write_line(line)
 
+    def pytest_report_header(self, config):
+        plugininfo = config.pluginmanager._plugin_distinfo
+        if plugininfo:
+            l = []
+            for dist, plugin in plugininfo:
+                name = dist.project_name
+                if name.startswith("pytest-"):
+                    name = name[7:]
+                l.append(name)
+            return "plugins: %s" % ", ".join(l)
+
     def pytest_collection_finish(self, session):
         if self.config.option.collectonly:
             self._printcollecteditems(session.items)
@@ -285,10 +317,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 = ""
@@ -302,15 +342,16 @@ class TerminalReporter:
                 stack.append(col)
                 #if col.name == "()":
                 #    continue
-                indent = (len(stack)-1) * "  "
-                self._tw.line("%s%s" %(indent, col))
+                indent = (len(stack) - 1) * "  "
+                self._tw.line("%s%s" % (indent, col))
 
     def pytest_sessionfinish(self, exitstatus, __multicall__):
         __multicall__.execute()
         self._tw.line("")
-        if exitstatus in (0, 1, 2):
+        if exitstatus in (0, 1, 2, 4):
             self.summary_errors()
             self.summary_failures()
+            self.summary_warnings()
             self.config.hook.pytest_terminal_summary(terminalreporter=self)
         if exitstatus == 2:
             self._report_keyboardinterrupt()
@@ -341,11 +382,10 @@ class TerminalReporter:
             fspath = "%s <- %s" % (collect_fspath, fspath)
         if fspath:
             line = str(fspath)
-            if lineno is not None:
-                lineno += 1
-                line += ":" + str(lineno)
             if domain:
-                line += ": " + str(domain)
+                split = str(domain).split('[')
+                split[0] = split[0].replace('.', '::')  # don't replace '.' in params
+                line += "::" + '['.join(split)
         else:
             line = "[location]"
         return line + " "
@@ -376,6 +416,16 @@ class TerminalReporter:
                 l.append(x)
         return l
 
+    def summary_warnings(self):
+        if self.hasopt("w"):
+            warnings = self.stats.get("warnings")
+            if not warnings:
+                return
+            self.write_sep("=", "warning summary")
+            for w in warnings:
+                self._tw.line("W%s %s %s" % (w.code,
+                              w.fslocation, w.message))
+
     def summary_failures(self):
         if self.config.option.tbstyle != "no":
             reports = self.getreports('failed')
@@ -418,9 +468,10 @@ class TerminalReporter:
             self._tw.line(content)
 
     def summary_stats(self):
-        session_duration = py.std.time.time() - self._sessionstarttime
+        session_duration = time.time() - self._sessionstarttime
 
-        keys = "failed passed skipped deselected".split()
+        keys = ("failed passed skipped deselected "
+               "xfailed xpassed warnings").split()
         for key in self.stats.keys():
             if key not in keys:
                 keys.append(key)
@@ -429,14 +480,20 @@ class TerminalReporter:
             if key: # setup/teardown reports have an empty key, ignore them
                 val = self.stats.get(key, None)
                 if val:
-                    parts.append("%d %s" %(len(val), key))
+                    parts.append("%d %s" % (len(val), key))
         line = ", ".join(parts)
-        # XXX coloring
-        msg = "%s in %.2f seconds" %(line, session_duration)
-        if self.verbosity >= 0:
-            self.write_sep("=", msg, bold=True)
+        msg = "%s in %.2f seconds" % (line, session_duration)
+
+        markup = {'bold': True}
+        if 'failed' in self.stats or 'error' in self.stats:
+            markup = {'red': True, 'bold': True}
         else:
-            self.write_line(msg, bold=True)
+            markup = {'green': True, 'bold': True}
+
+        if self.verbosity >= 0:
+            self.write_sep("=", msg, **markup)
+        if self.verbosity == -1:
+            self.write_line(msg, **markup)
 
     def summary_deselected(self):
         if 'deselected' in self.stats:
@@ -447,8 +504,9 @@ class TerminalReporter:
             m = self.config.option.markexpr
             if m:
                 l.append("-m %r" % m)
-            self.write_sep("=", "%d tests deselected by %r" %(
-                len(self.stats['deselected']), " ".join(l)), bold=True)
+            if l:
+                self.write_sep("=", "%d tests deselected by %r" % (
+                    len(self.stats['deselected']), " ".join(l)), bold=True)
 
 def repr_pythonversion(v=None):
     if v is None:

_pytest/tmpdir.py

@@ -1,7 +1,11 @@
 """ support for providing temporary directories to test functions.  """
-import pytest, py
+import re
+
+import pytest
+import py
 from _pytest.monkeypatch import monkeypatch
 
+
 class TempdirHandler:
     def __init__(self, config):
         self.config = config
@@ -40,7 +44,7 @@ class TempdirHandler:
                 basetemp.mkdir()
             else:
                 basetemp = py.path.local.make_numbered_dir(prefix='pytest-')
-            self._basetemp = t = basetemp
+            self._basetemp = t = basetemp.realpath()
             self.trace("new basetemp", t)
             return t
 
@@ -54,15 +58,18 @@ def pytest_configure(config):
     mp.setattr(config, '_tmpdirhandler', t, raising=False)
     mp.setattr(pytest, 'ensuretemp', t.ensuretemp, raising=False)
 
-def pytest_funcarg__tmpdir(request):
+@pytest.fixture
+def tmpdir(request):
     """return a temporary directory path object
     which is unique to each test function invocation,
     created as a sub directory of the base temporary
     directory.  The returned object is a `py.path.local`_
     path object.
     """
-    name = request._pyfuncitem.name
-    name = py.std.re.sub("[\W]", "_", name)
+    name = request.node.name
+    name = re.sub("[\W]", "_", name)
+    MAXVAL = 30
+    if len(name) > MAXVAL:
+        name = name[:MAXVAL]
     x = request.config._tmpdirhandler.mktemp(name, numbered=True)
     return x
-

_pytest/unittest.py

@@ -1,53 +1,78 @@
 """ discovery and running of std-library "unittest" style tests. """
-import pytest, py
-import sys, pdb
+from __future__ import absolute_import
+import traceback
+import sys
+
+import pytest
+import py
+
+
+# for transfering markers
+from _pytest.python import transfer_markers
+
 
 def pytest_pycollect_makeitem(collector, name, obj):
-    unittest = sys.modules.get('unittest')
-    if unittest is None:
-        return # nobody can have derived unittest.TestCase
+    # has unittest been imported and is obj a subclass of its TestCase?
     try:
-        isunit = issubclass(obj, unittest.TestCase)
-    except KeyboardInterrupt:
-        raise
+        if not issubclass(obj, sys.modules["unittest"].TestCase):
+            return
     except Exception:
-        pass
-    else:
-        if isunit:
-            return UnitTestCase(name, parent=collector)
+        return
+    # yes, so let's collect it
+    return UnitTestCase(name, parent=collector)
+
 
 class UnitTestCase(pytest.Class):
-    def collect(self):
-        loader = py.std.unittest.TestLoader()
-        for name in loader.getTestCaseNames(self.obj):
-            yield TestCaseFunction(name, parent=self)
-
+    nofuncargs = True  # marker for fixturemanger.getfixtureinfo()
+                       # to declare that our children do not support funcargs
+                       #
     def setup(self):
-        meth = getattr(self.obj, 'setUpClass', None)
-        if meth is not None:
-            meth()
+        cls = self.obj
+        if getattr(cls, '__unittest_skip__', False):
+            return  # skipped
+        setup = getattr(cls, 'setUpClass', None)
+        if setup is not None:
+            setup()
+        teardown = getattr(cls, 'tearDownClass', None)
+        if teardown is not None:
+            self.addfinalizer(teardown)
         super(UnitTestCase, self).setup()
 
-    def teardown(self):
-        meth = getattr(self.obj, 'tearDownClass', None)
-        if meth is not None:
-            meth()
-        super(UnitTestCase, self).teardown()
+    def collect(self):
+        from unittest import TestLoader
+        cls = self.obj
+        if not getattr(cls, "__test__", True):
+            return
+        self.session._fixturemanager.parsefactories(self, unittest=True)
+        loader = TestLoader()
+        module = self.getparent(pytest.Module).obj
+        foundsomething = False
+        for name in loader.getTestCaseNames(self.obj):
+            x = getattr(self.obj, name)
+            funcobj = getattr(x, 'im_func', x)
+            transfer_markers(funcobj, cls, module)
+            yield TestCaseFunction(name, parent=self)
+            foundsomething = True
+
+        if not foundsomething:
+            runtest = getattr(self.obj, 'runTest', None)
+            if runtest is not None:
+                ut = sys.modules.get("twisted.trial.unittest", None)
+                if ut is None or runtest != ut.TestCase.runTest:
+                    yield TestCaseFunction('runTest', parent=self)
+
+
 
 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, 'setup_method'):
             self._testcase.setup_method(self._obj)
+        if hasattr(self, "_request"):
+            self._request._fillfixtures()
 
     def teardown(self):
         if hasattr(self._testcase, 'teardown_method'):
@@ -64,7 +89,7 @@ class TestCaseFunction(pytest.Function):
         except TypeError:
             try:
                 try:
-                    l = py.std.traceback.format_exception(*rawexcinfo)
+                    l = traceback.format_exception(*rawexcinfo)
                     l.insert(0, "NOTE: Incompatible Exception Representation, "
                         "displaying natively:\n\n")
                     pytest.fail("".join(l), pytrace=False)
@@ -83,42 +108,54 @@ class TestCaseFunction(pytest.Function):
         self._addexcinfo(rawexcinfo)
     def addFailure(self, testcase, rawexcinfo):
         self._addexcinfo(rawexcinfo)
+
     def addSkip(self, testcase, reason):
         try:
             pytest.skip(reason)
         except pytest.skip.Exception:
             self._addexcinfo(sys.exc_info())
-    def addExpectedFailure(self, testcase, rawexcinfo, reason):
+
+    def addExpectedFailure(self, testcase, rawexcinfo, reason=""):
         try:
             pytest.xfail(str(reason))
         except pytest.xfail.Exception:
             self._addexcinfo(sys.exc_info())
-    def addUnexpectedSuccess(self, testcase, reason):
-        pass
+
+    def addUnexpectedSuccess(self, testcase, reason=""):
+        self._unexpectedsuccess = reason
+
     def addSuccess(self, testcase):
         pass
+
     def stopTest(self, testcase):
         pass
+
     def runtest(self):
         self._testcase(result=self)
 
     def _prunetraceback(self, excinfo):
         pytest.Function._prunetraceback(self, excinfo)
-        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):
     if isinstance(item, TestCaseFunction):
         if item._excinfo:
             call.excinfo = item._excinfo.pop(0)
-            del call.result
+            try:
+                del call.result
+            except AttributeError:
+                pass
 
 # twisted trial support
 def pytest_runtest_protocol(item, __multicall__):
     if isinstance(item, TestCaseFunction):
         if 'twisted.trial.unittest' in sys.modules:
             ut = sys.modules['twisted.python.failure']
-            Failure__init__ = ut.Failure.__init__.im_func
+            Failure__init__ = ut.Failure.__init__
             check_testcase_implements_trial_reporter()
             def excstore(self, exc_value=None, exc_type=None, exc_tb=None,
                 captureVars=None):

bench/bench.py

@@ -1,10 +1,12 @@
+import sys
 
 if __name__ == '__main__':
     import cProfile
-    import py
+    import pytest
     import pstats
-    stats = cProfile.run('py.test.cmdline.main(["empty.py", ])', 'prof')
+    script = sys.argv[1:] if len(sys.argv) > 1 else "empty.py"
+    stats = cProfile.run('pytest.cmdline.main(%r)' % script, 'prof')
     p = pstats.Stats("prof")
     p.strip_dirs()
     p.sort_stats('cumulative')
-    print(p.print_stats(30))
+    print(p.print_stats(250))

bench/bench_argcomplete.py

@@ -0,0 +1,19 @@
+
+
+# 10000 iterations, just for relative comparison
+#                      2.7.5     3.3.2
+# FilesCompleter       75.1109   69.2116
+# FastFilesCompleter    0.7383    1.0760
+
+
+if __name__ == '__main__':
+    import sys
+    import timeit
+    from argcomplete.completers import FilesCompleter
+    from _pytest._argcomplete import FastFilesCompleter
+    count = 1000 # only a few seconds
+    setup = 'from __main__ import FastFilesCompleter\nfc = FastFilesCompleter()'
+    run = 'fc("/d")'
+    sys.stdout.write('%s\n' % (timeit.timeit(run,
+                                setup=setup.replace('Fast', ''), number=count)))
+    sys.stdout.write('%s\n' % (timeit.timeit(run, setup=setup, number=count)))

bench/manyparam.py

@@ -0,0 +1,12 @@
+
+import pytest
+
+@pytest.fixture(scope='module', params=range(966))
+def foo(request):
+    return request.param
+
+def test_it(foo):
+    pass
+def test_it2(foo):
+    pass
+

bench/skip.py

@@ -0,0 +1,10 @@
+
+import pytest
+
+
+SKIP = True
+
+@pytest.mark.parametrize("x", xrange(5000))
+def test_foo(x):
+    if SKIP:
+        pytest.skip("heh")

distribute_setup.py

@@ -1,485 +0,0 @@
-#!python
-"""Bootstrap distribute installation
-
-If you want to use setuptools in your package's setup.py, just include this
-file in the same directory with it, and add this to the top of your setup.py::
-
-    from distribute_setup import use_setuptools
-    use_setuptools()
-
-If you want to require a specific version of setuptools, set a download
-mirror, or use an alternate download directory, you can do so by supplying
-the appropriate options to ``use_setuptools()``.
-
-This file can also be run as a script to install or upgrade setuptools.
-"""
-import os
-import sys
-import time
-import fnmatch
-import tempfile
-import tarfile
-from distutils import log
-
-try:
-    from site import USER_SITE
-except ImportError:
-    USER_SITE = None
-
-try:
-    import subprocess
-
-    def _python_cmd(*args):
-        args = (sys.executable,) + args
-        return subprocess.call(args) == 0
-
-except ImportError:
-    # will be used for python 2.3
-    def _python_cmd(*args):
-        args = (sys.executable,) + args
-        # quoting arguments if windows
-        if sys.platform == 'win32':
-            def quote(arg):
-                if ' ' in arg:
-                    return '"%s"' % arg
-                return arg
-            args = [quote(arg) for arg in args]
-        return os.spawnl(os.P_WAIT, sys.executable, *args) == 0
-
-DEFAULT_VERSION = "0.6.19"
-DEFAULT_URL = "http://pypi.python.org/packages/source/d/distribute/"
-SETUPTOOLS_FAKED_VERSION = "0.6c11"
-
-SETUPTOOLS_PKG_INFO = """\
-Metadata-Version: 1.0
-Name: setuptools
-Version: %s
-Summary: xxxx
-Home-page: xxx
-Author: xxx
-Author-email: xxx
-License: xxx
-Description: xxx
-""" % SETUPTOOLS_FAKED_VERSION
-
-
-def _install(tarball):
-    # extracting the tarball
-    tmpdir = tempfile.mkdtemp()
-    log.warn('Extracting in %s', tmpdir)
-    old_wd = os.getcwd()
-    try:
-        os.chdir(tmpdir)
-        tar = tarfile.open(tarball)
-        _extractall(tar)
-        tar.close()
-
-        # going in the directory
-        subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0])
-        os.chdir(subdir)
-        log.warn('Now working in %s', subdir)
-
-        # installing
-        log.warn('Installing Distribute')
-        if not _python_cmd('setup.py', 'install'):
-            log.warn('Something went wrong during the installation.')
-            log.warn('See the error message above.')
-    finally:
-        os.chdir(old_wd)
-
-
-def _build_egg(egg, tarball, to_dir):
-    # extracting the tarball
-    tmpdir = tempfile.mkdtemp()
-    log.warn('Extracting in %s', tmpdir)
-    old_wd = os.getcwd()
-    try:
-        os.chdir(tmpdir)
-        tar = tarfile.open(tarball)
-        _extractall(tar)
-        tar.close()
-
-        # going in the directory
-        subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0])
-        os.chdir(subdir)
-        log.warn('Now working in %s', subdir)
-
-        # building an egg
-        log.warn('Building a Distribute egg in %s', to_dir)
-        _python_cmd('setup.py', '-q', 'bdist_egg', '--dist-dir', to_dir)
-
-    finally:
-        os.chdir(old_wd)
-    # returning the result
-    log.warn(egg)
-    if not os.path.exists(egg):
-        raise IOError('Could not build the egg.')
-
-
-def _do_download(version, download_base, to_dir, download_delay):
-    egg = os.path.join(to_dir, 'distribute-%s-py%d.%d.egg'
-                       % (version, sys.version_info[0], sys.version_info[1]))
-    if not os.path.exists(egg):
-        tarball = download_setuptools(version, download_base,
-                                      to_dir, download_delay)
-        _build_egg(egg, tarball, to_dir)
-    sys.path.insert(0, egg)
-    import setuptools
-    setuptools.bootstrap_install_from = egg
-
-
-def use_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
-                   to_dir=os.curdir, download_delay=15, no_fake=True):
-    # making sure we use the absolute path
-    to_dir = os.path.abspath(to_dir)
-    was_imported = 'pkg_resources' in sys.modules or \
-        'setuptools' in sys.modules
-    try:
-        try:
-            import pkg_resources
-            if not hasattr(pkg_resources, '_distribute'):
-                if not no_fake:
-                    _fake_setuptools()
-                raise ImportError
-        except ImportError:
-            return _do_download(version, download_base, to_dir, download_delay)
-        try:
-            pkg_resources.require("distribute>="+version)
-            return
-        except pkg_resources.VersionConflict:
-            e = sys.exc_info()[1]
-            if was_imported:
-                sys.stderr.write(
-                "The required version of distribute (>=%s) is not available,\n"
-                "and can't be installed while this script is running. Please\n"
-                "install a more recent version first, using\n"
-                "'easy_install -U distribute'."
-                "\n\n(Currently using %r)\n" % (version, e.args[0]))
-                sys.exit(2)
-            else:
-                del pkg_resources, sys.modules['pkg_resources']    # reload ok
-                return _do_download(version, download_base, to_dir,
-                                    download_delay)
-        except pkg_resources.DistributionNotFound:
-            return _do_download(version, download_base, to_dir,
-                                download_delay)
-    finally:
-        if not no_fake:
-            _create_fake_setuptools_pkg_info(to_dir)
-
-def download_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
-                        to_dir=os.curdir, delay=15):
-    """Download distribute from a specified location and return its filename
-
-    `version` should be a valid distribute version number that is available
-    as an egg for download under the `download_base` URL (which should end
-    with a '/'). `to_dir` is the directory where the egg will be downloaded.
-    `delay` is the number of seconds to pause before an actual download
-    attempt.
-    """
-    # making sure we use the absolute path
-    to_dir = os.path.abspath(to_dir)
-    try:
-        from urllib.request import urlopen
-    except ImportError:
-        from urllib2 import urlopen
-    tgz_name = "distribute-%s.tar.gz" % version
-    url = download_base + tgz_name
-    saveto = os.path.join(to_dir, tgz_name)
-    src = dst = None
-    if not os.path.exists(saveto):  # Avoid repeated downloads
-        try:
-            log.warn("Downloading %s", url)
-            src = urlopen(url)
-            # Read/write all in one block, so we don't create a corrupt file
-            # if the download is interrupted.
-            data = src.read()
-            dst = open(saveto, "wb")
-            dst.write(data)
-        finally:
-            if src:
-                src.close()
-            if dst:
-                dst.close()
-    return os.path.realpath(saveto)
-
-def _no_sandbox(function):
-    def __no_sandbox(*args, **kw):
-        try:
-            from setuptools.sandbox import DirectorySandbox
-            if not hasattr(DirectorySandbox, '_old'):
-                def violation(*args):
-                    pass
-                DirectorySandbox._old = DirectorySandbox._violation
-                DirectorySandbox._violation = violation
-                patched = True
-            else:
-                patched = False
-        except ImportError:
-            patched = False
-
-        try:
-            return function(*args, **kw)
-        finally:
-            if patched:
-                DirectorySandbox._violation = DirectorySandbox._old
-                del DirectorySandbox._old
-
-    return __no_sandbox
-
-def _patch_file(path, content):
-    """Will backup the file then patch it"""
-    existing_content = open(path).read()
-    if existing_content == content:
-        # already patched
-        log.warn('Already patched.')
-        return False
-    log.warn('Patching...')
-    _rename_path(path)
-    f = open(path, 'w')
-    try:
-        f.write(content)
-    finally:
-        f.close()
-    return True
-
-_patch_file = _no_sandbox(_patch_file)
-
-def _same_content(path, content):
-    return open(path).read() == content
-
-def _rename_path(path):
-    new_name = path + '.OLD.%s' % time.time()
-    log.warn('Renaming %s into %s', path, new_name)
-    os.rename(path, new_name)
-    return new_name
-
-def _remove_flat_installation(placeholder):
-    if not os.path.isdir(placeholder):
-        log.warn('Unkown installation at %s', placeholder)
-        return False
-    found = False
-    for file in os.listdir(placeholder):
-        if fnmatch.fnmatch(file, 'setuptools*.egg-info'):
-            found = True
-            break
-    if not found:
-        log.warn('Could not locate setuptools*.egg-info')
-        return
-
-    log.warn('Removing elements out of the way...')
-    pkg_info = os.path.join(placeholder, file)
-    if os.path.isdir(pkg_info):
-        patched = _patch_egg_dir(pkg_info)
-    else:
-        patched = _patch_file(pkg_info, SETUPTOOLS_PKG_INFO)
-
-    if not patched:
-        log.warn('%s already patched.', pkg_info)
-        return False
-    # now let's move the files out of the way
-    for element in ('setuptools', 'pkg_resources.py', 'site.py'):
-        element = os.path.join(placeholder, element)
-        if os.path.exists(element):
-            _rename_path(element)
-        else:
-            log.warn('Could not find the %s element of the '
-                     'Setuptools distribution', element)
-    return True
-
-_remove_flat_installation = _no_sandbox(_remove_flat_installation)
-
-def _after_install(dist):
-    log.warn('After install bootstrap.')
-    placeholder = dist.get_command_obj('install').install_purelib
-    _create_fake_setuptools_pkg_info(placeholder)
-
-def _create_fake_setuptools_pkg_info(placeholder):
-    if not placeholder or not os.path.exists(placeholder):
-        log.warn('Could not find the install location')
-        return
-    pyver = '%s.%s' % (sys.version_info[0], sys.version_info[1])
-    setuptools_file = 'setuptools-%s-py%s.egg-info' % \
-            (SETUPTOOLS_FAKED_VERSION, pyver)
-    pkg_info = os.path.join(placeholder, setuptools_file)
-    if os.path.exists(pkg_info):
-        log.warn('%s already exists', pkg_info)
-        return
-
-    log.warn('Creating %s', pkg_info)
-    f = open(pkg_info, 'w')
-    try:
-        f.write(SETUPTOOLS_PKG_INFO)
-    finally:
-        f.close()
-
-    pth_file = os.path.join(placeholder, 'setuptools.pth')
-    log.warn('Creating %s', pth_file)
-    f = open(pth_file, 'w')
-    try:
-        f.write(os.path.join(os.curdir, setuptools_file))
-    finally:
-        f.close()
-
-_create_fake_setuptools_pkg_info = _no_sandbox(_create_fake_setuptools_pkg_info)
-
-def _patch_egg_dir(path):
-    # let's check if it's already patched
-    pkg_info = os.path.join(path, 'EGG-INFO', 'PKG-INFO')
-    if os.path.exists(pkg_info):
-        if _same_content(pkg_info, SETUPTOOLS_PKG_INFO):
-            log.warn('%s already patched.', pkg_info)
-            return False
-    _rename_path(path)
-    os.mkdir(path)
-    os.mkdir(os.path.join(path, 'EGG-INFO'))
-    pkg_info = os.path.join(path, 'EGG-INFO', 'PKG-INFO')
-    f = open(pkg_info, 'w')
-    try:
-        f.write(SETUPTOOLS_PKG_INFO)
-    finally:
-        f.close()
-    return True
-
-_patch_egg_dir = _no_sandbox(_patch_egg_dir)
-
-def _before_install():
-    log.warn('Before install bootstrap.')
-    _fake_setuptools()
-
-
-def _under_prefix(location):
-    if 'install' not in sys.argv:
-        return True
-    args = sys.argv[sys.argv.index('install')+1:]
-    for index, arg in enumerate(args):
-        for option in ('--root', '--prefix'):
-            if arg.startswith('%s=' % option):
-                top_dir = arg.split('root=')[-1]
-                return location.startswith(top_dir)
-            elif arg == option:
-                if len(args) > index:
-                    top_dir = args[index+1]
-                    return location.startswith(top_dir)
-        if arg == '--user' and USER_SITE is not None:
-            return location.startswith(USER_SITE)
-    return True
-
-
-def _fake_setuptools():
-    log.warn('Scanning installed packages')
-    try:
-        import pkg_resources
-    except ImportError:
-        # we're cool
-        log.warn('Setuptools or Distribute does not seem to be installed.')
-        return
-    ws = pkg_resources.working_set
-    try:
-        setuptools_dist = ws.find(pkg_resources.Requirement.parse('setuptools',
-                                  replacement=False))
-    except TypeError:
-        # old distribute API
-        setuptools_dist = ws.find(pkg_resources.Requirement.parse('setuptools'))
-
-    if setuptools_dist is None:
-        log.warn('No setuptools distribution found')
-        return
-    # detecting if it was already faked
-    setuptools_location = setuptools_dist.location
-    log.warn('Setuptools installation detected at %s', setuptools_location)
-
-    # if --root or --preix was provided, and if
-    # setuptools is not located in them, we don't patch it
-    if not _under_prefix(setuptools_location):
-        log.warn('Not patching, --root or --prefix is installing Distribute'
-                 ' in another location')
-        return
-
-    # let's see if its an egg
-    if not setuptools_location.endswith('.egg'):
-        log.warn('Non-egg installation')
-        res = _remove_flat_installation(setuptools_location)
-        if not res:
-            return
-    else:
-        log.warn('Egg installation')
-        pkg_info = os.path.join(setuptools_location, 'EGG-INFO', 'PKG-INFO')
-        if (os.path.exists(pkg_info) and
-            _same_content(pkg_info, SETUPTOOLS_PKG_INFO)):
-            log.warn('Already patched.')
-            return
-        log.warn('Patching...')
-        # let's create a fake egg replacing setuptools one
-        res = _patch_egg_dir(setuptools_location)
-        if not res:
-            return
-    log.warn('Patched done.')
-    _relaunch()
-
-
-def _relaunch():
-    log.warn('Relaunching...')
-    # we have to relaunch the process
-    # pip marker to avoid a relaunch bug
-    if sys.argv[:3] == ['-c', 'install', '--single-version-externally-managed']:
-        sys.argv[0] = 'setup.py'
-    args = [sys.executable] + sys.argv
-    sys.exit(subprocess.call(args))
-
-
-def _extractall(self, path=".", members=None):
-    """Extract all members from the archive to the current working
-       directory and set owner, modification time and permissions on
-       directories afterwards. `path' specifies a different directory
-       to extract to. `members' is optional and must be a subset of the
-       list returned by getmembers().
-    """
-    import copy
-    import operator
-    from tarfile import ExtractError
-    directories = []
-
-    if members is None:
-        members = self
-
-    for tarinfo in members:
-        if tarinfo.isdir():
-            # Extract directories with a safe mode.
-            directories.append(tarinfo)
-            tarinfo = copy.copy(tarinfo)
-            tarinfo.mode = 448 # decimal for oct 0700
-        self.extract(tarinfo, path)
-
-    # Reverse sort directories.
-    if sys.version_info < (2, 4):
-        def sorter(dir1, dir2):
-            return cmp(dir1.name, dir2.name)
-        directories.sort(sorter)
-        directories.reverse()
-    else:
-        directories.sort(key=operator.attrgetter('name'), reverse=True)
-
-    # Set correct owner, mtime and filemode on directories.
-    for tarinfo in directories:
-        dirpath = os.path.join(path, tarinfo.name)
-        try:
-            self.chown(tarinfo, dirpath)
-            self.utime(tarinfo, dirpath)
-            self.chmod(tarinfo, dirpath)
-        except ExtractError:
-            e = sys.exc_info()[1]
-            if self.errorlevel > 1:
-                raise
-            else:
-                self._dbg(1, "tarfile: %s" % e)
-
-
-def main(argv, version=DEFAULT_VERSION):
-    """Install or upgrade setuptools and EasyInstall"""
-    tarball = download_setuptools()
-    _install(tarball)
-
-
-if __name__ == '__main__':
-    main(sys.argv[1:])

doc/_templates/indexsidebar.html

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

doc/_templates/localtoc.html

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

doc/contact.txt

@@ -1,43 +0,0 @@
-
-.. _`contact channels`:
-.. _`contact`:
-
-Contact channels
-===================================
-
-- `new issue tracker`_ to report bugs or suggest features (for version
-  2.0 and above).  You may also peek at the `old issue tracker`_ but please
-  don't submit bugs there anymore.
-
-- `Testing In Python`_: a mailing list for Python testing tools and discussion.
-
-- `py-dev developers list`_ pytest specific announcements and discussions.
-
-- #pylib on irc.freenode.net IRC channel for random questions.
-
-- private mail to Holger.Krekel at gmail com if you want to communicate sensitive issues
-
-- `commit mailing list`_
-
-- `merlinux.eu`_ offers on-site teaching and consulting services.
-
-.. _`new issue tracker`: http://bitbucket.org/hpk42/pytest/issues/
-.. _`old issue tracker`: http://bitbucket.org/hpk42/py-trunk/issues/
-
-.. _`merlinux.eu`: http://merlinux.eu
-
-.. _`get an account`:
-
-.. _tetamap: http://tetamap.wordpress.com
-
-.. _`@pylibcommit`: http://twitter.com/pylibcommit
-
-
-.. _`Testing in Python`: http://lists.idyll.org/listinfo/testing-in-python
-.. _FOAF: http://en.wikipedia.org/wiki/FOAF
-.. _`py-dev`:
-.. _`development mailing list`:
-.. _`py-dev developers list`: http://codespeak.net/mailman/listinfo/py-dev
-.. _`py-svn`:
-.. _`commit mailing list`: http://codespeak.net/mailman/listinfo/py-svn
-

doc/contents.txt

@@ -1,26 +0,0 @@
-
-.. _toc:
-
-Full pytest documenation
-========================
-
-`Download latest version as PDF <http://media.readthedocs.org/pdf/pytest/latest/pytest.pdf>`_
-
-.. `Download latest version as EPUB <http://media.readthedocs.org/epub/pytest/latest/pytest.epub>`_
-
-.. toctree::
-   :maxdepth: 2
-
-   overview
-   example/index
-   apiref
-   plugins
-   talks
-   develop
-   announce/index
-
-.. toctree::
-   :hidden:
-
-   changelog.txt
-

doc/develop.txt

@@ -1,40 +0,0 @@
-=================================================
-Feedback and contribute to py.test
-=================================================
-
-.. toctree::
-   :maxdepth: 2
-
-   contact.txt
-
-.. _checkout:
-
-Working from version control or a tarball
-=================================================
-
-To follow development or start experiments, checkout the
-complete code and documentation source with mercurial_::
-
-    hg clone https://bitbucket.org/hpk42/pytest/
-
-You can also go to the python package index and
-download and unpack a TAR file::
-
-    http://pypi.python.org/pypi/pytest/
-
-Activating a checkout with setuptools
---------------------------------------------
-
-With a working Distribute_ or setuptools_ installation you can type::
-
-    python setup.py develop
-
-in order to work inline with the tools and the lib of your checkout.
-
-If this command complains that it could not find the required version
-of "py" then you need to use the development pypi repository::
-
-    python setup.py develop -i http://pypi.testrun.org
-
-
-.. include:: links.inc

doc/en/Makefile

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

doc/en/_templates/globaltoc.html

@@ -0,0 +1,17 @@
+<h3><a href="{{ pathto(master_doc) }}">{{ _('Table Of Contents') }}</a></h3>
+
+<ul>
+  <li><a href="{{ pathto('index') }}">Home</a></li>
+  <li><a href="{{ pathto('contents') }}">Contents</a></li>
+  <li><a href="{{ pathto('getting-started') }}">Install</a></li>
+  <li><a href="{{ pathto('example/index') }}">Examples</a></li>
+  <li><a href="{{ pathto('customize') }}">Customize</a></li>
+  <li><a href="{{ pathto('contact') }}">Contact</a></li>
+  <li><a href="{{ pathto('talks') }}">Talks/Posts</a></li>
+  <li><a href="{{ pathto('changelog') }}">Changelog</a></li>
+</ul>
+
+{%- if display_toc %}
+  <hr>
+  {{ toc }}
+{%- endif %}

doc/en/_templates/layout.html

@@ -1,10 +1,5 @@
 {% extends "!layout.html" %}
 
-{% block relbaritems %}
-{{ super() }}
-<g:plusone></g:plusone>
-{% endblock %}
-
 {% block footer %}
 {{ super() }}
 <script type="text/javascript">
@@ -20,5 +15,4 @@
   })();
 
 </script>
-<script type="text/javascript" src="https://apis.google.com/js/plusone.js"></script>
 {% endblock %}

doc/en/_templates/links.html

@@ -0,0 +1,11 @@
+<h3>Useful Links</h3>
+<ul>
+  <li><a href="{{ pathto('index') }}">The pytest Website</a></li>
+  <li><a href="{{ pathto('contributing') }}">Contribution Guide</a></li>
+  <li><a href="https://pypi.python.org/pypi/pytest">pytest @ PyPI</a></li>
+  <li><a href="https://bitbucket.org/hpk42/pytest/">pytest @ Bitbucket</a></li>
+  <li><a href="http://pytest.org/latest/plugins_index/index.html">3rd party plugins</a></li>
+  <li><a href="https://bitbucket.org/hpk42/pytest/issues?status=new&status=open">Issue Tracker</a></li>
+  <li><a href="http://pytest.org/latest/pytest.pdf">PDF Documentation</a>
+</ul>
+

doc/en/_templates/sidebarintro.html

@@ -0,0 +1,5 @@
+<h3>About pytest</h3>
+<p>
+  pytest is a mature full-featured Python testing tool that helps
+  you write better programs.
+</p>

doc/en/_themes/.gitignore

@@ -0,0 +1,3 @@
+*.pyc
+*.pyo
+.DS_Store

doc/en/_themes/LICENSE

@@ -0,0 +1,37 @@
+Copyright (c) 2010 by Armin Ronacher.
+
+Some rights reserved.
+
+Redistribution and use in source and binary forms of the theme, with or
+without modification, are permitted provided that the following conditions
+are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the following
+  disclaimer in the documentation and/or other materials provided
+  with the distribution.
+
+* The names of the contributors may not be used to endorse or
+  promote products derived from this software without specific
+  prior written permission.
+
+We kindly ask you to only use these themes in an unmodified manner just
+for Flask and Flask-related products, not for unrelated projects.  If you
+like the visual style and want to use it for your own projects, please
+consider making some larger changes to the themes (such as changing
+font faces, sizes, colors or margins).
+
+THIS THEME IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS THEME, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

doc/en/_themes/README

@@ -0,0 +1,31 @@
+Flask Sphinx Styles
+===================
+
+This repository contains sphinx styles for Flask and Flask related
+projects.  To use this style in your Sphinx documentation, follow
+this guide:
+
+1. put this folder as _themes into your docs folder.  Alternatively
+   you can also use git submodules to check out the contents there.
+2. add this to your conf.py:
+
+   sys.path.append(os.path.abspath('_themes'))
+   html_theme_path = ['_themes']
+   html_theme = 'flask'
+
+The following themes exist:
+
+- 'flask' - the standard flask documentation theme for large
+  projects
+- 'flask_small' - small one-page theme.  Intended to be used by
+  very small addon libraries for flask.
+
+The following options exist for the flask_small theme:
+
+   [options]
+   index_logo = ''              filename of a picture in _static
+                                to be used as replacement for the
+                                h1 in the index.rst file.
+   index_logo_height = 120px    height of the index logo
+   github_fork = ''             repository name on github for the
+                                "fork me" badge

doc/en/_themes/flask/layout.html

@@ -0,0 +1,24 @@
+{%- extends "basic/layout.html" %}
+{%- block extrahead %}
+  {{ super() }}
+  {% if theme_touch_icon %}
+  <link rel="apple-touch-icon" href="{{ pathto('_static/' ~ theme_touch_icon, 1) }}" />
+  {% endif %}
+  <meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9">
+{% endblock %}
+{%- block relbar2 %}{% endblock %}
+{% block header %}
+  {{ super() }}
+  {% if pagename == 'index' %}
+  <div class=indexwrapper>
+  {% endif %}
+{% endblock %}
+{%- block footer %}
+  <div class="footer">
+    &copy; Copyright {{ copyright }}.
+    Created using <a href="http://sphinx.pocoo.org/">Sphinx</a>.
+  </div>
+  {% if pagename == 'index' %}
+  </div>
+  {% endif %}
+{%- endblock %}

doc/en/_themes/flask/relations.html

@@ -0,0 +1,19 @@
+<h3>Related Topics</h3>
+<ul>
+  <li><a href="{{ pathto(master_doc) }}">Documentation overview</a><ul>
+  {%- for parent in parents %}
+  <li><a href="{{ parent.link|e }}">{{ parent.title }}</a><ul>
+  {%- endfor %}
+    {%- if prev %}
+      <li>Previous: <a href="{{ prev.link|e }}" title="{{ _('previous chapter')
+        }}">{{ prev.title }}</a></li>
+    {%- endif %}
+    {%- if next %}
+      <li>Next: <a href="{{ next.link|e }}" title="{{ _('next chapter')
+        }}">{{ next.title }}</a></li>
+    {%- endif %}
+  {%- for parent in parents %}
+  </ul></li>
+  {%- endfor %}
+  </ul></li>
+</ul>

doc/en/_themes/flask/static/flasky.css_t

@@ -0,0 +1,556 @@
+/*
+ * flasky.css_t
+ * ~~~~~~~~~~~~
+ *
+ * :copyright: Copyright 2010 by Armin Ronacher.
+ * :license: Flask Design License, see LICENSE for details.
+ */
+
+{% set page_width = '1020px' %}
+{% set sidebar_width = '220px' %}
+/* orange of logo is #d67c29 but we use black for links for now */
+{% set link_color = '#000' %}
+{% set link_hover_color = '#000' %}
+{% set base_font = 'sans-serif' %}
+{% set header_font = 'sans-serif' %}
+
+@import url("basic.css");
+
+/* -- page layout ----------------------------------------------------------- */
+
+body {
+    font-family: {{ base_font }};
+    font-size: 17px;
+    background-color: white;
+    color: #000;
+    margin: 0;
+    padding: 0;
+}
+
+div.document {
+    width: {{ page_width }};
+    margin: 30px auto 0 auto;
+}
+
+div.documentwrapper {
+    float: left;
+    width: 100%;
+}
+
+div.bodywrapper {
+    margin: 0 0 0 {{ sidebar_width }};
+}
+
+div.sphinxsidebar {
+    width: {{ sidebar_width }};
+}
+
+hr {
+    border: 0;
+    border-top: 1px solid #B1B4B6;
+}
+
+div.body {
+    background-color: #ffffff;
+    color: #3E4349;
+    padding: 0 30px 0 30px;
+}
+
+img.floatingflask {
+    padding: 0 0 10px 10px;
+    float: right;
+}
+
+div.footer {
+    width: {{ page_width }};
+    margin: 20px auto 30px auto;
+    font-size: 14px;
+    color: #888;
+    text-align: right;
+}
+
+div.footer a {
+    color: #888;
+}
+
+div.related {
+    display: none;
+}
+
+div.sphinxsidebar a {
+    color: #444;
+    text-decoration: none;
+    border-bottom: 1px dotted #999;
+}
+
+div.sphinxsidebar a:hover {
+    border-bottom: 1px solid #999;
+}
+
+div.sphinxsidebar {
+    font-size: 14px;
+    line-height: 1.5;
+}
+
+div.sphinxsidebarwrapper {
+    padding: 18px 10px;
+}
+
+div.sphinxsidebarwrapper p.logo {
+    padding: 0 0 20px 0;
+    margin: 0;
+    text-align: center;
+}
+
+div.sphinxsidebar h3,
+div.sphinxsidebar h4 {
+    font-family: {{ header_font }};
+    color: #444;
+    font-size: 24px;
+    font-weight: normal;
+    margin: 0 0 5px 0;
+    padding: 0;
+}
+
+div.sphinxsidebar h4 {
+    font-size: 20px;
+}
+
+div.sphinxsidebar h3 a {
+    color: #444;
+}
+
+div.sphinxsidebar p.logo a,
+div.sphinxsidebar h3 a,
+div.sphinxsidebar p.logo a:hover,
+div.sphinxsidebar h3 a:hover {
+    border: none;
+}
+
+div.sphinxsidebar p {
+    color: #555;
+    margin: 10px 0;
+}
+
+div.sphinxsidebar ul {
+    margin: 10px 0;
+    padding: 0;
+    color: #000;
+}
+
+div.sphinxsidebar input {
+    border: 1px solid #ccc;
+    font-family: {{ base_font }};
+    font-size: 1em;
+}
+
+/* -- body styles ----------------------------------------------------------- */
+
+a {
+    color: {{ link_color }};
+    text-decoration: underline;
+}
+
+a:hover {
+    color: {{ link_hover_color }};
+    text-decoration: underline;
+}
+
+a.reference.internal em {
+    font-style: normal;
+}
+
+div.body h1,
+div.body h2,
+div.body h3,
+div.body h4,
+div.body h5,
+div.body h6 {
+    font-family: {{ header_font }};
+    font-weight: normal;
+    margin: 30px 0px 10px 0px;
+    padding: 0;
+}
+
+{% if theme_index_logo %}
+div.indexwrapper h1 {
+    text-indent: -999999px;
+    background: url({{ theme_index_logo }}) no-repeat center center;
+    height: {{ theme_index_logo_height }};
+}
+{% else %}
+div.indexwrapper div.body h1 {
+    font-size: 200%;
+}
+{% endif %}
+div.body h1 { margin-top: 0; padding-top: 0; font-size: 240%; }
+div.body h2 { font-size: 180%; }
+div.body h3 { font-size: 150%; }
+div.body h4 { font-size: 130%; }
+div.body h5 { font-size: 100%; }
+div.body h6 { font-size: 100%; }
+
+a.headerlink {
+    color: #ddd;
+    padding: 0 4px;
+    text-decoration: none;
+}
+
+a.headerlink:hover {
+    color: #444;
+    background: #eaeaea;
+}
+
+div.body p, div.body dd, div.body li {
+    line-height: 1.4em;
+}
+
+div.admonition {
+    background: #fafafa;
+    margin: 20px -30px;
+    padding: 10px 30px;
+    border-top: 1px solid #ccc;
+    border-bottom: 1px solid #ccc;
+}
+
+div.admonition tt.xref, div.admonition a tt {
+    border-bottom: 1px solid #fafafa;
+}
+
+dd div.admonition {
+    margin-left: -60px;
+    padding-left: 60px;
+}
+
+div.admonition p.admonition-title {
+    font-family: {{ header_font }};
+    font-weight: normal;
+    font-size: 24px;
+    margin: 0 0 10px 0;
+    padding: 0;
+    line-height: 1;
+}
+
+div.admonition p.last {
+    margin-bottom: 0;
+}
+
+div.highlight {
+    background-color: white;
+}
+
+dt:target, .highlight {
+    background: #FAF3E8;
+}
+
+div.note {
+    background-color: #eee;
+    border: 1px solid #ccc;
+}
+
+div.seealso {
+    background-color: #ffc;
+    border: 1px solid #ff6;
+}
+
+div.topic {
+    background-color: #eee;
+}
+
+p.admonition-title {
+    display: inline;
+}
+
+p.admonition-title:after {
+    content: ":";
+}
+
+pre, tt {
+    font-family: 'Consolas', 'Menlo', 'Deja Vu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
+    font-size: 0.9em;
+}
+
+img.screenshot {
+}
+
+tt.descname, tt.descclassname {
+    font-size: 0.95em;
+}
+
+tt.descname {
+    padding-right: 0.08em;
+}
+
+img.screenshot {
+    -moz-box-shadow: 2px 2px 4px #eee;
+    -webkit-box-shadow: 2px 2px 4px #eee;
+    box-shadow: 2px 2px 4px #eee;
+}
+
+table.docutils {
+    border: 1px solid #888;
+    -moz-box-shadow: 2px 2px 4px #eee;
+    -webkit-box-shadow: 2px 2px 4px #eee;
+    box-shadow: 2px 2px 4px #eee;
+}
+
+table.docutils td, table.docutils th {
+    border: 1px solid #888;
+    padding: 0.25em 0.7em;
+}
+
+table.field-list, table.footnote {
+    border: none;
+    -moz-box-shadow: none;
+    -webkit-box-shadow: none;
+    box-shadow: none;
+}
+
+table.footnote {
+    margin: 15px 0;
+    width: 100%;
+    border: 1px solid #eee;
+    background: #fdfdfd;
+    font-size: 0.9em;
+}
+
+table.footnote + table.footnote {
+    margin-top: -15px;
+    border-top: none;
+}
+
+table.field-list th {
+    padding: 0 0.8em 0 0;
+}
+
+table.field-list td {
+    padding: 0;
+}
+
+table.footnote td.label {
+    width: 0px;
+    padding: 0.3em 0 0.3em 0.5em;
+}
+
+table.footnote td {
+    padding: 0.3em 0.5em;
+}
+
+dl {
+    margin: 0;
+    padding: 0;
+}
+
+dl dd {
+    margin-left: 30px;
+}
+
+blockquote {
+    margin: 0 0 0 30px;
+    padding: 0;
+}
+
+ul, ol {
+    margin: 10px 0 10px 30px;
+    padding: 0;
+}
+
+pre {
+    background: #eee;
+    padding: 7px 30px;
+    margin: 15px -30px;
+    line-height: 1.3em;
+}
+
+dl pre, blockquote pre, li pre {
+    margin-left: -60px;
+    padding-left: 60px;
+}
+
+dl dl pre {
+    margin-left: -90px;
+    padding-left: 90px;
+}
+
+tt {
+    background-color: #ecf0f3;
+    color: #222;
+    /* padding: 1px 2px; */
+}
+
+tt.xref, a tt {
+    background-color: #FBFBFB;
+    border-bottom: 1px solid white;
+}
+
+a.reference {
+    text-decoration: none;
+    border-bottom: 1px dotted {{ link_color }};
+}
+
+a.reference:hover {
+    border-bottom: 1px solid {{ link_hover_color }};
+}
+
+a.footnote-reference {
+    text-decoration: none;
+    font-size: 0.7em;
+    vertical-align: top;
+    border-bottom: 1px dotted {{ link_color }};
+}
+
+a.footnote-reference:hover {
+    border-bottom: 1px solid {{ link_hover_color }};
+}
+
+a:hover tt {
+    background: #EEE;
+}
+
+
+@media screen and (max-width: 870px) {
+
+    div.sphinxsidebar {
+        display: none;
+    }
+
+    div.document {
+       width: 100%;
+
+    }
+
+    div.documentwrapper {
+        margin-left: 0;
+        margin-top: 0;
+        margin-right: 0;
+        margin-bottom: 0;
+    }
+
+    div.bodywrapper {
+        margin-top: 0;
+        margin-right: 0;
+        margin-bottom: 0;
+        margin-left: 0;
+    }
+
+    ul {
+        margin-left: 0;
+    }
+
+    .document {
+        width: auto;
+    }
+
+    .footer {
+        width: auto;
+    }
+
+    .bodywrapper {
+        margin: 0;
+    }
+
+    .footer {
+        width: auto;
+    }
+
+    .github {
+        display: none;
+    }
+
+
+
+}
+
+
+
+@media screen and (max-width: 875px) {
+
+    body {
+        margin: 0;
+        padding: 20px 30px;
+    }
+
+    div.documentwrapper {
+        float: none;
+        background: white;
+    }
+
+    div.sphinxsidebar {
+        display: block;
+        float: none;
+        width: 102.5%;
+        margin: 50px -30px -20px -30px;
+        padding: 10px 20px;
+        background: #333;
+        color: white;
+    }
+
+    div.sphinxsidebar h3, div.sphinxsidebar h4, div.sphinxsidebar p,
+    div.sphinxsidebar h3 a, div.sphinxsidebar ul {
+        color: white;
+    }
+
+    div.sphinxsidebar a {
+        color: #aaa;
+    }
+
+    div.sphinxsidebar p.logo {
+        display: none;
+    }
+
+    div.document {
+        width: 100%;
+        margin: 0;
+    }
+
+    div.related {
+        display: block;
+        margin: 0;
+        padding: 10px 0 20px 0;
+    }
+
+    div.related ul,
+    div.related ul li {
+        margin: 0;
+        padding: 0;
+    }
+
+    div.footer {
+        display: none;
+    }
+
+    div.bodywrapper {
+        margin: 0;
+    }
+
+    div.body {
+        min-height: 0;
+        padding: 0;
+    }
+
+    .rtd_doc_footer {
+        display: none;
+    }
+
+    .document {
+        width: auto;
+    }
+
+    .footer {
+        width: auto;
+    }
+
+    .footer {
+        width: auto;
+    }
+
+    .github {
+        display: none;
+    }
+}
+
+/* misc. */
+
+.revsys-inline {
+    display: none!important;
+}

doc/en/_themes/flask/theme.conf

@@ -0,0 +1,9 @@
+[theme]
+inherit = basic
+stylesheet = flasky.css
+pygments_style = flask_theme_support.FlaskyStyle
+
+[options]
+index_logo = ''
+index_logo_height = 120px
+touch_icon = 

doc/en/_themes/flask_theme_support.py

@@ -0,0 +1,86 @@
+# flasky extensions.  flasky pygments style based on tango style
+from pygments.style import Style
+from pygments.token import Keyword, Name, Comment, String, Error, \
+     Number, Operator, Generic, Whitespace, Punctuation, Other, Literal
+
+
+class FlaskyStyle(Style):
+    background_color = "#f8f8f8"
+    default_style = ""
+
+    styles = {
+        # No corresponding class for the following:
+        #Text:                     "", # class:  ''
+        Whitespace:                "underline #f8f8f8",      # class: 'w'
+        Error:                     "#a40000 border:#ef2929", # class: 'err'
+        Other:                     "#000000",                # class 'x'
+
+        Comment:                   "italic #8f5902", # class: 'c'
+        Comment.Preproc:           "noitalic",       # class: 'cp'
+
+        Keyword:                   "bold #004461",   # class: 'k'
+        Keyword.Constant:          "bold #004461",   # class: 'kc'
+        Keyword.Declaration:       "bold #004461",   # class: 'kd'
+        Keyword.Namespace:         "bold #004461",   # class: 'kn'
+        Keyword.Pseudo:            "bold #004461",   # class: 'kp'
+        Keyword.Reserved:          "bold #004461",   # class: 'kr'
+        Keyword.Type:              "bold #004461",   # class: 'kt'
+
+        Operator:                  "#582800",   # class: 'o'
+        Operator.Word:             "bold #004461",   # class: 'ow' - like keywords
+
+        Punctuation:               "bold #000000",   # class: 'p'
+
+        # because special names such as Name.Class, Name.Function, etc.
+        # are not recognized as such later in the parsing, we choose them
+        # to look the same as ordinary variables.
+        Name:                      "#000000",        # class: 'n'
+        Name.Attribute:            "#c4a000",        # class: 'na' - to be revised
+        Name.Builtin:              "#004461",        # class: 'nb'
+        Name.Builtin.Pseudo:       "#3465a4",        # class: 'bp'
+        Name.Class:                "#000000",        # class: 'nc' - to be revised
+        Name.Constant:             "#000000",        # class: 'no' - to be revised
+        Name.Decorator:            "#888",           # class: 'nd' - to be revised
+        Name.Entity:               "#ce5c00",        # class: 'ni'
+        Name.Exception:            "bold #cc0000",   # class: 'ne'
+        Name.Function:             "#000000",        # class: 'nf'
+        Name.Property:             "#000000",        # class: 'py'
+        Name.Label:                "#f57900",        # class: 'nl'
+        Name.Namespace:            "#000000",        # class: 'nn' - to be revised
+        Name.Other:                "#000000",        # class: 'nx'
+        Name.Tag:                  "bold #004461",   # class: 'nt' - like a keyword
+        Name.Variable:             "#000000",        # class: 'nv' - to be revised
+        Name.Variable.Class:       "#000000",        # class: 'vc' - to be revised
+        Name.Variable.Global:      "#000000",        # class: 'vg' - to be revised
+        Name.Variable.Instance:    "#000000",        # class: 'vi' - to be revised
+
+        Number:                    "#990000",        # class: 'm'
+
+        Literal:                   "#000000",        # class: 'l'
+        Literal.Date:              "#000000",        # class: 'ld'
+
+        String:                    "#4e9a06",        # class: 's'
+        String.Backtick:           "#4e9a06",        # class: 'sb'
+        String.Char:               "#4e9a06",        # class: 'sc'
+        String.Doc:                "italic #8f5902", # class: 'sd' - like a comment
+        String.Double:             "#4e9a06",        # class: 's2'
+        String.Escape:             "#4e9a06",        # class: 'se'
+        String.Heredoc:            "#4e9a06",        # class: 'sh'
+        String.Interpol:           "#4e9a06",        # class: 'si'
+        String.Other:              "#4e9a06",        # class: 'sx'
+        String.Regex:              "#4e9a06",        # class: 'sr'
+        String.Single:             "#4e9a06",        # class: 's1'
+        String.Symbol:             "#4e9a06",        # class: 'ss'
+
+        Generic:                   "#000000",        # class: 'g'
+        Generic.Deleted:           "#a40000",        # class: 'gd'
+        Generic.Emph:              "italic #000000", # class: 'ge'
+        Generic.Error:             "#ef2929",        # class: 'gr'
+        Generic.Heading:           "bold #000080",   # class: 'gh'
+        Generic.Inserted:          "#00A000",        # class: 'gi'
+        Generic.Output:            "#888",           # class: 'go'
+        Generic.Prompt:            "#745334",        # class: 'gp'
+        Generic.Strong:            "bold #000000",   # class: 'gs'
+        Generic.Subheading:        "bold #800080",   # class: 'gu'
+        Generic.Traceback:         "bold #a40000",   # class: 'gt'
+    }

doc/en/announce/index.txt

@@ -0,0 +1,35 @@
+
+Release announcements
+===========================================
+
+.. toctree::
+   :maxdepth: 2
+
+   release-2.6.2
+   release-2.6.1
+   release-2.6.0
+   release-2.5.2
+   release-2.5.1
+   release-2.5.0
+   release-2.4.2
+   release-2.4.1
+   release-2.4.0
+   release-2.3.5
+   release-2.3.4
+   release-2.3.3
+   release-2.3.2
+   release-2.3.1
+   release-2.3.0
+   release-2.2.4
+   release-2.2.2
+   release-2.2.1
+   release-2.2.0
+   release-2.1.3
+   release-2.1.2
+   release-2.1.1
+   release-2.1.0
+   release-2.0.3
+   release-2.0.2
+   release-2.0.1
+   release-2.0.0
+

doc/en/announce/release-2.0.1.txt

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

doc/en/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/en/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/en/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/en/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/en/announce/release-2.2.2.txt

@@ -0,0 +1,43 @@
+pytest-2.2.2: bug fixes
+===========================================================================
+
+pytest-2.2.2 (updated to 2.2.3 to fix packaging issues) 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/en/announce/release-2.2.4.txt

@@ -0,0 +1,39 @@
+pytest-2.2.4: bug fixes, better junitxml/unittest/python3 compat
+===========================================================================
+
+pytest-2.2.4 is a minor backward-compatible release of the versatile
+py.test testing tool.   It contains bug fixes and a few refinements
+to junitxml reporting, better unittest- and python3 compatibility.
+
+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 Benjamin Peterson and the contributors of issues.
+
+best,
+holger krekel
+
+Changes between 2.2.3 and 2.2.4
+-----------------------------------
+
+- fix error message for rewritten assertions involving the % operator
+- fix issue 126: correctly match all invalid xml characters for junitxml
+  binary escape
+- fix issue with unittest: now @unittest.expectedFailure markers should
+  be processed correctly (you can also use @pytest.mark markers)
+- document integration with the extended distribute/setuptools test commands
+- fix issue 140: propperly get the real functions
+  of bound classmethods for setup/teardown_class
+- fix issue #141: switch from the deceased paste.pocoo.org to bpaste.net
+- fix issue #143: call unconfigure/sessionfinish always when
+  configure/sessionstart where called
+- fix issue #144: better mangle test ids to junitxml classnames
+- upgrade distribute_setup.py to 0.6.27
+

doc/en/announce/release-2.3.0.txt

@@ -0,0 +1,134 @@
+pytest-2.3: improved fixtures / better unittest integration
+=============================================================================
+
+pytest-2.3 comes with many major improvements for fixture/funcarg management 
+and parametrized testing in Python.  It is now easier, more efficient and
+more predicatable to re-run the same tests with different fixture
+instances.  Also, you can directly declare the caching "scope" of
+fixtures so that dependent tests throughout your whole test suite can
+re-use database or other expensive fixture objects with ease.  Lastly,
+it's possible for fixture functions (formerly known as funcarg
+factories) to use other fixtures, allowing for a completely modular and
+re-useable fixture design. 
+
+For detailed info and tutorial-style examples, see:
+
+    http://pytest.org/latest/fixture.html
+
+Moreover, there is now support for using pytest fixtures/funcargs with
+unittest-style suites, see here for examples:
+
+    http://pytest.org/latest/unittest.html
+
+Besides, more unittest-test suites are now expected to "simply work"
+with pytest.
+
+All changes are backward compatible and you should be able to continue
+to run your test suites and 3rd party plugins that worked with
+pytest-2.2.4.
+
+If you are interested in the precise reasoning (including examples) of the 
+pytest-2.3 fixture evolution, please consult
+http://pytest.org/latest/funcarg_compare.html
+
+For general info on installation and getting started:
+
+    http://pytest.org/latest/getting-started.html
+
+Docs and PDF access as usual at:
+
+    http://pytest.org
+
+and more details for those already in the knowing of pytest can be found
+in the CHANGELOG below.
+
+Particular thanks for this release go to Floris Bruynooghe, Alex Okrushko
+Carl Meyer, Ronny Pfannschmidt, Benjamin Peterson and Alex Gaynor for helping 
+to get the new features right and well integrated.  Ronny and Floris
+also helped to fix a number of bugs and yet more people helped by
+providing bug reports.
+
+have fun,
+holger krekel
+
+
+Changes between 2.2.4 and 2.3.0
+-----------------------------------
+
+- fix issue202 - better automatic names for parametrized test functions
+- fix issue139 - introduce @pytest.fixture which allows direct scoping
+  and parametrization of funcarg factories.  Introduce new @pytest.setup
+  marker to allow the writing of setup functions which accept funcargs.
+- fix issue198 - conftest fixtures were not found on windows32 in some
+  circumstances with nested directory structures due to path manipulation issues
+- fix issue193 skip test functions with were parametrized with empty
+  parameter sets
+- fix python3.3 compat, mostly reporting bits that previously depended
+  on dict ordering
+- introduce re-ordering of tests by resource and parametrization setup
+  which takes precedence to the usual file-ordering
+- fix issue185 monkeypatching time.time does not cause pytest to fail
+- fix issue172 duplicate call of pytest.setup-decoratored setup_module
+  functions
+- fix junitxml=path construction so that if tests change the
+  current working directory and the path is a relative path
+  it is constructed correctly from the original current working dir.
+- fix "python setup.py test" example to cause a proper "errno" return
+- fix issue165 - fix broken doc links and mention stackoverflow for FAQ
+- catch unicode-issues when writing failure representations
+  to terminal to prevent the whole session from crashing
+- fix xfail/skip confusion: a skip-mark or an imperative pytest.skip
+  will now take precedence before xfail-markers because we
+  can't determine xfail/xpass status in case of a skip. see also:
+  http://stackoverflow.com/questions/11105828/in-py-test-when-i-explicitly-skip-a-test-that-is-marked-as-xfail-how-can-i-get
+
+- always report installed 3rd party plugins in the header of a test run
+
+- fix issue160: a failing setup of an xfail-marked tests should
+  be reported as xfail (not xpass)
+
+- fix issue128: show captured output when capsys/capfd are used
+
+- fix issue179: propperly show the dependency chain of factories
+
+- pluginmanager.register(...) now raises ValueError if the
+  plugin has been already registered or the name is taken
+
+- fix issue159: improve http://pytest.org/latest/faq.html 
+  especially with respect to the "magic" history, also mention
+  pytest-django, trial and unittest integration.
+
+- make request.keywords and node.keywords writable.  All descendant
+  collection nodes will see keyword values.  Keywords are dictionaries
+  containing markers and other info.
+
+- fix issue 178: xml binary escapes are now wrapped in py.xml.raw
+
+- fix issue 176: correctly catch the builtin AssertionError
+  even when we replaced AssertionError with a subclass on the
+  python level
+
+- factory discovery no longer fails with magic global callables
+  that provide no sane __code__ object (mock.call for example)
+
+- fix issue 182: testdir.inprocess_run now considers passed plugins
+
+- fix issue 188: ensure sys.exc_info is clear on python2
+                 before calling into a test
+
+- fix issue 191: add unittest TestCase runTest method support
+- fix issue 156: monkeypatch correctly handles class level descriptors
+
+- reporting refinements:
+
+  - pytest_report_header now receives a "startdir" so that
+    you can use startdir.bestrelpath(yourpath) to show
+    nice relative path
+
+  - allow plugins to implement both pytest_report_header and 
+    pytest_sessionstart (sessionstart is invoked first).
+
+  - don't show deselected reason line if there is none
+
+  - py.test -vv will show all of assert comparisations instead of truncating
+

doc/en/announce/release-2.3.1.txt

@@ -0,0 +1,39 @@
+pytest-2.3.1: fix regression with factory functions
+===========================================================================
+
+pytest-2.3.1 is a quick follow-up release:
+
+- fix issue202 - regression with fixture functions/funcarg factories:  
+  using "self" is now safe again and works as in 2.2.4.  Thanks 
+  to Eduard Schettino for the quick bug report.
+
+- disable pexpect pytest self tests on Freebsd - thanks Koob for the 
+  quick reporting
+
+- fix/improve interactive docs with --markers
+
+See 
+
+     http://pytest.org/
+
+for general information.  To install or upgrade pytest:
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+best,
+holger krekel
+
+
+Changes between 2.3.0 and 2.3.1
+-----------------------------------
+
+- fix issue202 - fix regression: using "self" from fixture functions now
+  works as expected (it's the same "self" instance that a test method
+  which uses the fixture sees)
+
+- skip pexpect using tests (test_pdb.py mostly) on freebsd* systems
+  due to pexpect not supporting it properly (hanging)
+
+- link to web pages from --markers output which provides help for
+  pytest.mark.* usage.

doc/en/announce/release-2.3.2.txt

@@ -0,0 +1,57 @@
+pytest-2.3.2: some fixes and more traceback-printing speed
+===========================================================================
+
+pytest-2.3.2 is a another stabilization release:
+
+- issue 205: fixes a regression with conftest detection
+- issue 208/29: fixes traceback-printing speed in some bad cases
+- fix teardown-ordering for parametrized setups
+- fix unittest and trial compat behaviour with respect  to runTest() methods
+- issue 206 and others: some improvements to packaging
+- fix issue127 and others: improve some docs 
+
+See 
+
+     http://pytest.org/
+
+for general information.  To install or upgrade pytest:
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+best,
+holger krekel
+
+
+Changes between 2.3.1 and 2.3.2
+-----------------------------------
+
+- fix issue208 and fix issue29 use new py version to avoid long pauses 
+  when printing tracebacks in long modules
+
+- fix issue205 - conftests in subdirs customizing
+  pytest_pycollect_makemodule and pytest_pycollect_makeitem
+  now work properly
+
+- fix teardown-ordering for parametrized setups
+
+- fix issue127 - better documentation for pytest_addoption
+  and related objects.
+
+- fix unittest behaviour: TestCase.runtest only called if there are
+  test methods defined
+
+- improve trial support: don't collect its empty
+  unittest.TestCase.runTest() method
+
+- "python setup.py test" now works with pytest itself
+
+- fix/improve internal/packaging related bits:
+
+  - exception message check of test_nose.py now passes on python33 as well
+
+  - issue206 - fix test_assertrewrite.py to work when a global
+    PYTHONDONTWRITEBYTECODE=1 is present
+
+  - add tox.ini to pytest distribution so that ignore-dirs and others config
+    bits are properly distributed for maintainers who run pytest-own tests

doc/en/announce/release-2.3.3.txt

@@ -0,0 +1,62 @@
+pytest-2.3.3: integration fixes, py24 suport, ``*/**`` shown in traceback
+===========================================================================
+
+pytest-2.3.3 is a another stabilization release of the py.test tool
+which offers uebersimple assertions, scalable fixture mechanisms
+and deep customization for testing with Python.  Particularly,
+this release provides:
+
+- integration fixes and improvements related to flask, numpy, nose, 
+  unittest, mock
+
+- makes pytest work on py24 again (yes, people sometimes still need to use it)
+
+- show ``*,**`` args in pytest tracebacks
+
+Thanks to Manuel Jacob, Thomas Waldmann, Ronny Pfannschmidt, Pavel Repin
+and Andreas Taumoefolau for providing patches and all for the issues.
+
+See 
+
+     http://pytest.org/
+
+for general information.  To install or upgrade pytest:
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+best,
+holger krekel
+
+Changes between 2.3.2 and 2.3.3
+-----------------------------------
+
+- fix issue214 - parse modules that contain special objects like e. g.
+  flask's request object which blows up on getattr access if no request
+  is active. thanks Thomas Waldmann.
+
+- fix issue213 - allow to parametrize with values like numpy arrays that
+  do not support an __eq__ operator
+
+- fix issue215 - split test_python.org into multiple files
+
+- fix issue148 - @unittest.skip on classes is now recognized and avoids
+  calling setUpClass/tearDownClass, thanks Pavel Repin
+
+- fix issue209 - reintroduce python2.4 support by depending on newer
+  pylib which re-introduced statement-finding for pre-AST interpreters
+
+- nose support: only call setup if its a callable, thanks Andrew
+  Taumoefolau
+
+- fix issue219 - add py2.4-3.3 classifiers to TROVE list
+
+- in tracebacks *,** arg values are now shown next to normal arguments
+  (thanks Manuel Jacob)
+
+- fix issue217 - support mock.patch with pytest's fixtures - note that
+  you need either mock-1.0.1 or the python3.3 builtin unittest.mock.
+
+- fix issue127 - improve documentation for pytest_addoption() and
+  add a ``config.getoption(name)`` helper function for consistency.
+

doc/en/announce/release-2.3.4.txt

@@ -0,0 +1,39 @@
+pytest-2.3.4: stabilization, more flexible selection via "-k expr"
+===========================================================================
+
+pytest-2.3.4 is a small stabilization release of the py.test tool
+which offers uebersimple assertions, scalable fixture mechanisms
+and deep customization for testing with Python.  This release
+comes with the following fixes and features:
+
+- make "-k" option accept an expressions the same as with "-m" so that one
+  can write: -k "name1 or name2" etc.  This is a slight usage incompatibility
+  if you used special syntax like "TestClass.test_method" which you now
+  need to write as -k "TestClass and test_method" to match a certain
+  method in a certain test class.  
+- allow to dynamically define markers via
+  item.keywords[...]=assignment integrating with "-m" option
+- yielded test functions will now have autouse-fixtures active but 
+  cannot accept fixtures as funcargs - it's anyway recommended to
+  rather use the post-2.0 parametrize features instead of yield, see:
+  http://pytest.org/latest/example/parametrize.html
+- fix autouse-issue where autouse-fixtures would not be discovered
+  if defined in a a/conftest.py file and tests in a/tests/test_some.py
+- fix issue226 - LIFO ordering for fixture teardowns
+- fix issue224 - invocations with >256 char arguments now work
+- fix issue91 - add/discuss package/directory level setups in example
+- fixes related to autouse discovery and calling
+
+Thanks in particular to Thomas Waldmann for spotting and reporting issues.
+
+See 
+
+     http://pytest.org/
+
+for general information.  To install or upgrade pytest:
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+best,
+holger krekel

doc/en/announce/release-2.3.5.txt

@@ -0,0 +1,97 @@
+pytest-2.3.5: bug fixes and little improvements
+===========================================================================
+
+pytest-2.3.5 is a maintenance release with many bug fixes and little
+improvements.  See the changelog below for details.  No backward
+compatibility issues are foreseen and all plugins which worked with the
+prior version are expected to work unmodified.   Speaking of which, a
+few interesting new plugins saw the light last month:
+
+- pytest-instafail: show failure information while tests are running
+- pytest-qt: testing of GUI applications written with QT/Pyside
+- pytest-xprocess: managing external processes across test runs
+- pytest-random: randomize test ordering
+
+And several others like pytest-django saw maintenance releases.
+For a more complete list, check out 
+https://pypi.python.org/pypi?%3Aaction=search&term=pytest&submit=search.
+
+For general information see:
+
+     http://pytest.org/
+
+To install or upgrade pytest:
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+Particular thanks to Floris, Ronny, Benjamin and the many bug reporters
+and fix providers.
+
+may the fixtures be with you,
+holger krekel
+
+
+Changes between 2.3.4 and 2.3.5
+-----------------------------------
+
+- never consider a fixture function for test function collection
+
+- allow re-running of test items / helps to fix pytest-reruntests plugin
+  and also help to keep less fixture/resource references alive
+
+- put captured stdout/stderr into junitxml output even for passing tests
+  (thanks Adam Goucher)
+
+- Issue 265 - integrate nose setup/teardown with setupstate
+  so it doesnt try to teardown if it did not setup
+
+- issue 271 - dont write junitxml on slave nodes
+
+- Issue 274 - dont try to show full doctest example
+  when doctest does not know the example location
+
+- issue 280 - disable assertion rewriting on buggy CPython 2.6.0
+
+- inject "getfixture()" helper to retrieve fixtures from doctests,
+  thanks Andreas Zeidler
+
+- issue 259 - when assertion rewriting, be consistent with the default
+  source encoding of ASCII on Python 2
+
+- issue 251 - report a skip instead of ignoring classes with init
+
+- issue250 unicode/str mixes in parametrization names and values now works
+
+- issue257, assertion-triggered compilation of source ending in a
+  comment line doesn't blow up in python2.5 (fixed through py>=1.4.13.dev6)
+
+- fix --genscript option to generate standalone scripts that also
+  work with python3.3 (importer ordering)
+
+- issue171 - in assertion rewriting, show the repr of some
+  global variables
+
+- fix option help for "-k"
+
+- move long description of distribution into README.rst
+
+- improve docstring for metafunc.parametrize()
+
+- fix bug where using capsys with pytest.set_trace() in a test
+  function would break when looking at capsys.readouterr()
+
+- allow to specify prefixes starting with "_" when 
+  customizing python_functions test discovery. (thanks Graham Horler)
+
+- improve PYTEST_DEBUG tracing output by puting
+  extra data on a new lines with additional indent
+
+- ensure OutcomeExceptions like skip/fail have initialized exception attributes
+
+- issue 260 - don't use nose special setup on plain unittest cases
+
+- fix issue134 - print the collect errors that prevent running specified test items
+
+- fix issue266 - accept unicode in MarkEvaluator expressions
+

doc/en/announce/release-2.4.0.txt

@@ -0,0 +1,225 @@
+pytest-2.4.0: new fixture features/hooks and bug fixes
+===========================================================================
+
+The just released pytest-2.4.0 brings many improvements and numerous 
+bug fixes while remaining plugin- and test-suite compatible apart
+from a few supposedly very minor incompatibilities.  See below for 
+a full list of details.  A few feature highlights:
+
+- new yield-style fixtures `pytest.yield_fixture
+  <http://pytest.org/latest/yieldfixture.html>`_, allowing to use
+  existing with-style context managers in fixture functions.
+
+- improved pdb support: ``import pdb ; pdb.set_trace()`` now works
+  without requiring prior disabling of stdout/stderr capturing.
+  Also the ``--pdb`` options works now on collection and internal errors
+  and we introduced a new experimental hook for IDEs/plugins to 
+  intercept debugging: ``pytest_exception_interact(node, call, report)``.
+
+- shorter monkeypatch variant to allow specifying an import path as
+  a target, for example: ``monkeypatch.setattr("requests.get", myfunc)``
+
+- better unittest/nose compatibility: all teardown methods are now only
+  called if the corresponding setup method succeeded.
+
+- integrate tab-completion on command line options if you
+  have `argcomplete <http://pypi.python.org/pypi/argcomplete>`_ 
+  configured.
+
+- allow boolean expression directly with skipif/xfail
+  if a "reason" is also specified.
+
+- a new hook ``pytest_load_initial_conftests`` allows plugins like
+  `pytest-django <http://pypi.python.org/pypi/pytest-django>`_ to
+  influence the environment before conftest files import ``django``.
+
+- reporting: color the last line red or green depending if
+  failures/errors occured or everything passed.
+
+The documentation has been updated to accomodate the changes, 
+see `http://pytest.org <http://pytest.org>`_ 
+
+To install or upgrade pytest::
+
+    pip install -U pytest # or
+    easy_install -U pytest
+
+
+**Many thanks to all who helped, including Floris Bruynooghe, 
+Brianna Laugher, Andreas Pelme, Anthon van der Neut, Anatoly Bubenkoff, 
+Vladimir Keleshev, Mathieu Agopian, Ronny Pfannschmidt, Christian
+Theunert and many others.**
+
+may passing tests be with you,
+
+holger krekel
+
+Changes between 2.3.5 and 2.4
+-----------------------------------
+
+known incompatibilities:
+
+- if calling --genscript from python2.7 or above, you only get a
+  standalone script which works on python2.7 or above.  Use Python2.6
+  to also get a python2.5 compatible version.
+
+- all xunit-style teardown methods (nose-style, pytest-style,
+  unittest-style) will not be called if the corresponding setup method failed,
+  see issue322 below.
+
+- the pytest_plugin_unregister hook wasn't ever properly called
+  and there is no known implementation of the hook - so it got removed.
+
+- pytest.fixture-decorated functions cannot be generators (i.e. use
+  yield) anymore.  This change might be reversed in 2.4.1 if it causes
+  unforeseen real-life issues.  However, you can always write and return
+  an inner function/generator and change the fixture consumer to iterate
+  over the returned generator.  This change was done in lieu of the new
+  ``pytest.yield_fixture`` decorator, see below.
+
+new features:
+
+- experimentally introduce a new ``pytest.yield_fixture`` decorator
+  which accepts exactly the same parameters as pytest.fixture but
+  mandates a ``yield`` statement instead of a ``return statement`` from
+  fixture functions.  This allows direct integration with "with-style"
+  context managers in fixture functions and generally avoids registering
+  of finalization callbacks in favour of treating the "after-yield" as
+  teardown code.  Thanks Andreas Pelme, Vladimir Keleshev, Floris
+  Bruynooghe, Ronny Pfannschmidt and many others for discussions.
+
+- allow boolean expression directly with skipif/xfail
+  if a "reason" is also specified.  Rework skipping documentation
+  to recommend "condition as booleans" because it prevents surprises
+  when importing markers between modules.  Specifying conditions
+  as strings will remain fully supported.
+
+- reporting: color the last line red or green depending if
+  failures/errors occured or everything passed.  thanks Christian
+  Theunert.
+
+- make "import pdb ; pdb.set_trace()" work natively wrt capturing (no
+  "-s" needed anymore), making ``pytest.set_trace()`` a mere shortcut.
+
+- fix issue181: --pdb now also works on collect errors (and 
+  on internal errors) .  This was implemented by a slight internal 
+  refactoring and the introduction of a new hook 
+  ``pytest_exception_interact`` hook (see next item).
+
+- fix issue341: introduce new experimental hook for IDEs/terminals to 
+  intercept debugging: ``pytest_exception_interact(node, call, report)``.
+
+- new monkeypatch.setattr() variant to provide a shorter
+  invocation for patching out classes/functions from modules:
+
+     monkeypatch.setattr("requests.get", myfunc)
+
+  will replace the "get" function of the "requests" module with ``myfunc``.
+
+- fix issue322: tearDownClass is not run if setUpClass failed. Thanks
+  Mathieu Agopian for the initial fix.  Also make all of pytest/nose
+  finalizer mimick the same generic behaviour: if a setupX exists and
+  fails, don't run teardownX.  This internally introduces a new method
+  "node.addfinalizer()" helper which can only be called during the setup
+  phase of a node.
+
+- simplify pytest.mark.parametrize() signature: allow to pass a
+  CSV-separated string to specify argnames.  For example: 
+  ``pytest.mark.parametrize("input,expected",  [(1,2), (2,3)])``
+  works as well as the previous:
+  ``pytest.mark.parametrize(("input", "expected"), ...)``.
+
+- add support for setUpModule/tearDownModule detection, thanks Brian Okken.
+
+- integrate tab-completion on options through use of "argcomplete".
+  Thanks Anthon van der Neut for the PR.
+
+- change option names to be hyphen-separated long options but keep the
+  old spelling backward compatible.  py.test -h will only show the
+  hyphenated version, for example "--collect-only" but "--collectonly"
+  will remain valid as well (for backward-compat reasons).  Many thanks to
+  Anthon van der Neut for the implementation and to Hynek Schlawack for
+  pushing us.
+
+- fix issue 308 - allow to mark/xfail/skip individual parameter sets
+  when parametrizing.  Thanks Brianna Laugher.
+
+- call new experimental pytest_load_initial_conftests hook to allow
+  3rd party plugins to do something before a conftest is loaded.
+
+Bug fixes:
+
+- fix issue358 - capturing options are now parsed more properly 
+  by using a new parser.parse_known_args method.
+
+- pytest now uses argparse instead of optparse (thanks Anthon) which 
+  means that "argparse" is added as a dependency if installing into python2.6
+  environments or below.
+
+- fix issue333: fix a case of bad unittest/pytest hook interaction.
+
+- PR27: correctly handle nose.SkipTest during collection.  Thanks
+  Antonio Cuni, Ronny Pfannschmidt.
+
+- fix issue355: junitxml puts name="pytest" attribute to testsuite tag.
+
+- fix issue336: autouse fixture in plugins should work again.
+
+- fix issue279: improve object comparisons on assertion failure
+  for standard datatypes and recognise collections.abc.  Thanks to
+  Brianna Laugher and Mathieu Agopian.
+
+- fix issue317: assertion rewriter support for the is_package method
+
+- fix issue335: document py.code.ExceptionInfo() object returned
+  from pytest.raises(), thanks Mathieu Agopian.
+
+- remove implicit distribute_setup support from setup.py.
+
+- fix issue305: ignore any problems when writing pyc files.
+
+- SO-17664702: call fixture finalizers even if the fixture function
+  partially failed (finalizers would not always be called before)
+
+- fix issue320 - fix class scope for fixtures when mixed with
+  module-level functions.  Thanks Anatloy Bubenkoff.
+
+- you can specify "-q" or "-qq" to get different levels of "quieter"
+  reporting (thanks Katarzyna Jachim)
+
+- fix issue300 - Fix order of conftest loading when starting py.test
+  in a subdirectory.
+
+- fix issue323 - sorting of many module-scoped arg parametrizations
+
+- make sessionfinish hooks execute with the same cwd-context as at
+  session start (helps fix plugin behaviour which write output files 
+  with relative path such as pytest-cov)
+
+- fix issue316 - properly reference collection hooks in docs
+
+- fix issue 306 - cleanup of -k/-m options to only match markers/test
+  names/keywords respectively.  Thanks Wouter van Ackooy.
+
+- improved doctest counting for doctests in python modules -- 
+  files without any doctest items will not show up anymore
+  and doctest examples are counted as separate test items.
+  thanks Danilo Bellini.
+
+- fix issue245 by depending on the released py-1.4.14
+  which fixes py.io.dupfile to work with files with no
+  mode. Thanks Jason R. Coombs.
+
+- fix junitxml generation when test output contains control characters,
+  addressing issue267, thanks Jaap Broekhuizen 
+
+- fix issue338: honor --tb style for setup/teardown errors as well.  Thanks Maho.
+
+- fix issue307 - use yaml.safe_load in example, thanks Mark Eichin.
+
+- better parametrize error messages, thanks Brianna Laugher
+
+- pytest_terminal_summary(terminalreporter) hooks can now use
+  ".section(title)" and ".line(msg)" methods to print extra 
+  information at the end of a test run.
+

doc/en/announce/release-2.4.1.txt

@@ -0,0 +1,25 @@
+pytest-2.4.1: fixing three regressions compared to 2.3.5
+===========================================================================
+
+pytest-2.4.1 is a quick follow up release to fix three regressions
+compared to 2.3.5 before they hit more people:
+
+- When using parser.addoption() unicode arguments to the
+  "type" keyword should also be converted to the respective types.
+  thanks Floris Bruynooghe, @dnozay. (fixes issue360 and issue362)
+
+- fix dotted filename completion when using argcomplete 
+  thanks Anthon van der Neuth. (fixes issue361)
+
+- fix regression when a 1-tuple ("arg",) is used for specifying
+  parametrization (the values of the parametrization were passed
+  nested in a tuple).  Thanks Donald Stufft.
+
+- also merge doc typo fixes, thanks Andy Dirnberger
+
+as usual, docs at http://pytest.org and upgrades via::
+
+    pip install -U pytest
+
+have fun,
+holger krekel

doc/en/announce/release-2.4.2.txt

@@ -0,0 +1,39 @@
+pytest-2.4.2: colorama on windows, plugin/tmpdir fixes
+===========================================================================
+
+pytest-2.4.2 is another bug-fixing release:
+
+- on Windows require colorama and a newer py lib so that py.io.TerminalWriter()
+  now uses colorama instead of its own ctypes hacks. (fixes issue365)
+  thanks Paul Moore for bringing it up.
+
+- fix "-k" matching of tests where "repr" and "attr" and other names would
+  cause wrong matches because of an internal implementation quirk
+  (don't ask) which is now properly implemented. fixes issue345.
+
+- avoid tmpdir fixture to create too long filenames especially
+  when parametrization is used (issue354)
+
+- fix pytest-pep8 and pytest-flakes / pytest interactions
+  (collection names in mark plugin was assuming an item always
+  has a function which is not true for those plugins etc.)
+  Thanks Andi Zeidler.
+
+- introduce node.get_marker/node.add_marker API for plugins
+  like pytest-pep8 and pytest-flakes to avoid the messy
+  details of the node.keywords  pseudo-dicts.  Adapated
+  docs.
+
+- remove attempt to "dup" stdout at startup as it's icky.
+  the normal capturing should catch enough possibilities
+  of tests messing up standard FDs. 
+
+- add pluginmanager.do_configure(config) as a link to 
+  config.do_configure() for plugin-compatibility
+
+as usual, docs at http://pytest.org and upgrades via::
+
+    pip install -U pytest
+
+have fun,
+holger krekel

doc/en/announce/release-2.5.0.txt

@@ -0,0 +1,175 @@
+pytest-2.5.0: now down to ZERO reported bugs!
+===========================================================================
+
+pytest-2.5.0 is a big fixing release, the result of two community bug
+fixing days plus numerous additional works from many people and
+reporters.  The release should be fully compatible to 2.4.2, existing
+plugins and test suites.  We aim at maintaining this level of ZERO reported 
+bugs because it's no fun if your testing tool has bugs, is it?  Under a
+condition, though: when submitting a bug report please provide
+clear information about the circumstances and a simple example which
+reproduces the problem.
+
+The issue tracker is of course not empty now.  We have many remaining
+"enhacement" issues which we'll hopefully can tackle in 2014 with your
+help.
+
+For those who use older Python versions, please note that pytest is not
+automatically tested on python2.5 due to virtualenv, setuptools and tox
+not supporting it anymore.  Manual verification shows that it mostly
+works fine but it's not going to be part of the automated release 
+process and thus likely to break in the future.
+
+As usual, current docs are at 
+
+    http://pytest.org 
+
+and you can upgrade from pypi via::
+
+    pip install -U pytest
+
+Particular thanks for helping with this release go to Anatoly Bubenkoff,
+Floris Bruynooghe, Marc Abramowitz, Ralph Schmitt, Ronny Pfannschmidt,
+Donald Stufft, James Lan, Rob Dennis, Jason R. Coombs, Mathieu Agopian,
+Virgil Dupras, Bruno Oliveira, Alex Gaynor and others.
+
+have fun,
+holger krekel
+
+
+2.5.0
+-----------------------------------
+
+- dropped python2.5 from automated release testing of pytest itself 
+  which means it's probably going to break soon (but still works 
+  with this release we believe).
+
+- simplified and fixed implementation for calling finalizers when
+  parametrized fixtures or function arguments are involved.  finalization 
+  is now performed lazily at setup time instead of in the "teardown phase".
+  While this might sound odd at first, it helps to ensure that we are 
+  correctly handling setup/teardown even in complex code.  User-level code
+  should not be affected unless it's implementing the pytest_runtest_teardown
+  hook and expecting certain fixture instances are torn down within (very
+  unlikely and would have been unreliable anyway).
+
+- PR90: add --color=yes|no|auto option to force terminal coloring 
+  mode ("auto" is default).  Thanks Marc Abramowitz.
+
+- fix issue319 - correctly show unicode in assertion errors.  Many
+  thanks to Floris Bruynooghe for the complete PR.  Also means
+  we depend on py>=1.4.19 now.
+
+- fix issue396 - correctly sort and finalize class-scoped parametrized 
+  tests independently from number of methods on the class.  
+
+- refix issue323 in a better way -- parametrization should now never
+  cause Runtime Recursion errors because the underlying algorithm
+  for re-ordering tests per-scope/per-fixture is not recursive
+  anymore (it was tail-call recursive before which could lead
+  to problems for more than >966 non-function scoped parameters).
+
+- fix issue290 - there is preliminary support now for parametrizing
+  with repeated same values (sometimes useful to to test if calling 
+  a second time works as with the first time).
+
+- close issue240 - document precisely how pytest module importing
+  works, discuss the two common test directory layouts, and how it 
+  interacts with PEP420-namespace packages.
+
+- fix issue246 fix finalizer order to be LIFO on independent fixtures
+  depending on a parametrized higher-than-function scoped fixture. 
+  (was quite some effort so please bear with the complexity of this sentence :)
+  Thanks Ralph Schmitt for the precise failure example.
+ 
+- fix issue244 by implementing special index for parameters to only use
+  indices for paramentrized test ids
+
+- fix issue287 by running all finalizers but saving the exception
+  from the first failing finalizer and re-raising it so teardown will
+  still have failed.  We reraise the first failing exception because
+  it might be the cause for other finalizers to fail.
+
+- fix ordering when mock.patch or other standard decorator-wrappings
+  are used with test methods.  This fixues issue346 and should
+  help with random "xdist" collection failures.  Thanks to
+  Ronny Pfannschmidt and Donald Stufft for helping to isolate it.
+
+- fix issue357 - special case "-k" expressions to allow for
+  filtering with simple strings that are not valid python expressions.
+  Examples: "-k 1.3" matches all tests parametrized with 1.3.
+  "-k None" filters all tests that have "None" in their name
+  and conversely "-k 'not None'". 
+  Previously these examples would raise syntax errors.
+  
+- fix issue384 by removing the trial support code
+  since the unittest compat enhancements allow
+  trial to handle it on its own
+
+- don't hide an ImportError when importing a plugin produces one.
+  fixes issue375.
+
+- fix issue275 - allow usefixtures and autouse fixtures 
+  for running doctest text files.
+
+- fix issue380 by making --resultlog only rely on longrepr instead
+  of the "reprcrash" attribute which only exists sometimes.
+
+- address issue122: allow @pytest.fixture(params=iterator) by exploding
+  into a list early on.
+
+- fix pexpect-3.0 compatibility for pytest's own tests.
+  (fixes issue386)
+
+- allow nested parametrize-value markers, thanks James Lan for the PR.
+
+- fix unicode handling with new monkeypatch.setattr(import_path, value)
+  API.  Thanks Rob Dennis.  Fixes issue371.
+
+- fix unicode handling with junitxml, fixes issue368.
+
+- In assertion rewriting mode on Python 2, fix the detection of coding
+  cookies. See issue #330.
+
+- make "--runxfail" turn imperative pytest.xfail calls into no ops
+  (it already did neutralize pytest.mark.xfail markers)
+
+- refine pytest / pkg_resources interactions: The AssertionRewritingHook
+  PEP302 compliant loader now registers itself with setuptools/pkg_resources 
+  properly so that the pkg_resources.resource_stream method works properly.
+  Fixes issue366.  Thanks for the investigations and full PR to Jason R. Coombs.
+
+- pytestconfig fixture is now session-scoped as it is the same object during the
+  whole test run.  Fixes issue370. 
+
+- avoid one surprising case of marker malfunction/confusion::
+  
+      @pytest.mark.some(lambda arg: ...)
+      def test_function():
+
+  would not work correctly because pytest assumes @pytest.mark.some 
+  gets a function to be decorated already.  We now at least detect if this 
+  arg is an lambda and thus the example will work.  Thanks Alex Gaynor
+  for bringing it up.
+
+- xfail a test on pypy that checks wrong encoding/ascii (pypy does
+  not error out). fixes issue385.
+
+- internally make varnames() deal with classes's __init__,
+  although it's not needed by pytest itself atm.  Also
+  fix caching.  Fixes issue376.
+
+- fix issue221 - handle importing of namespace-package with no 
+  __init__.py properly.
+
+- refactor internal FixtureRequest handling to avoid monkeypatching.
+  One of the positive user-facing effects is that the "request" object 
+  can now be used in closures.
+
+- fixed version comparison in pytest.importskip(modname, minverstring)
+
+- fix issue377 by clarifying in the nose-compat docs that pytest
+  does not duplicate the unittest-API into the "plain" namespace.
+
+- fix verbose reporting for @mock'd test functions
+

doc/en/announce/release-2.5.1.txt

@@ -0,0 +1,47 @@
+pytest-2.5.1: fixes and new home page styling
+===========================================================================
+
+pytest is a mature Python testing tool with more than a 1000 tests 
+against itself, passing on many different interpreters and platforms.  
+
+The 2.5.1 release maintains the "zero-reported-bugs" promise by fixing
+the three bugs reported since the last release a few days ago.  It also
+features a new home page styling implemented by Tobias Bieniek, based on
+the flask theme from Armin Ronacher:
+
+    http://pytest.org
+
+If you have anything more to improve styling and docs, 
+we'd be very happy to merge further pull requests.
+
+On the coding side, the release also contains a little enhancement to
+fixture decorators allowing to directly influence generation of test
+ids, thanks to Floris Bruynooghe.  Other thanks for helping with 
+this release go to Anatoly Bubenkoff and Ronny Pfannschmidt.
+
+As usual, you can upgrade from pypi via::
+
+    pip install -U pytest
+
+have fun and a nice remaining "bug-free" time of the year :)
+holger krekel
+
+2.5.1
+-----------------------------------
+
+- merge new documentation styling PR from Tobias Bieniek.
+
+- fix issue403: allow parametrize of multiple same-name functions within
+  a collection node.  Thanks Andreas Kloeckner and Alex Gaynor for reporting
+  and analysis.
+
+- Allow parameterized fixtures to specify the ID of the parameters by
+  adding an ids argument to pytest.fixture() and pytest.yield_fixture().
+  Thanks Floris Bruynooghe. 
+
+- fix issue404 by always using the binary xml escape in the junitxml
+  plugin.  Thanks Ronny Pfannschmidt.
+
+- fix issue407: fix addoption docstring to point to argparse instead of
+  optparse. Thanks Daniel D. Wright.
+

doc/en/announce/release-2.5.2.txt

@@ -0,0 +1,64 @@
+pytest-2.5.2: fixes 
+===========================================================================
+
+pytest is a mature Python testing tool with more than a 1000 tests 
+against itself, passing on many different interpreters and platforms.  
+
+The 2.5.2 release fixes a few bugs with two maybe-bugs remaining and
+actively being worked on (and waiting for the bug reporter's input).
+We also have a new contribution guide thanks to Piotr Banaszkiewicz
+and others.
+
+See docs at:
+
+    http://pytest.org
+
+As usual, you can upgrade from pypi via::
+
+    pip install -U pytest
+
+Thanks to the following people who contributed to this release:
+
+    Anatoly Bubenkov 
+    Ronny Pfannschmidt
+    Floris Bruynooghe
+    Bruno Oliveira 
+    Andreas Pelme 
+    Jurko Gospodnetić
+    Piotr Banaszkiewicz 
+    Simon Liedtke 
+    lakka 
+    Lukasz Balcerzak 
+    Philippe Muller 
+    Daniel Hahler 
+
+have fun,
+holger krekel
+
+2.5.2
+-----------------------------------
+
+- fix issue409 -- better interoperate with cx_freeze by not
+  trying to import from collections.abc which causes problems 
+  for py27/cx_freeze.  Thanks Wolfgang L. for reporting and tracking it down.
+
+- fixed docs and code to use "pytest" instead of "py.test" almost everywhere.
+  Thanks Jurko Gospodnetic for the complete PR.  
+
+- fix issue425: mention at end of "py.test -h" that --markers
+  and --fixtures work according to specified test path (or current dir)
+
+- fix issue413: exceptions with unicode attributes are now printed
+  correctly also on python2 and with pytest-xdist runs. (the fix
+  requires py-1.4.20)
+
+- copy, cleanup and integrate py.io capture
+  from pylib 1.4.20.dev2 (rev 13d9af95547e)
+  
+- address issue416: clarify docs as to conftest.py loading semantics
+
+- fix issue429: comparing byte strings with non-ascii chars in assert
+  expressions now work better.  Thanks Floris Bruynooghe.
+
+- make capfd/capsys.capture private, its unused and shouldnt be exposed
+

doc/en/announce/release-2.6.0.txt

@@ -0,0 +1,153 @@
+pytest-2.6.0: shorter tracebacks, new warning system, test runner compat
+===========================================================================
+
+pytest is a mature Python testing tool with more than a 1000 tests
+against itself, passing on many different interpreters and platforms.
+
+The 2.6.0 release should be drop-in backward compatible to 2.5.2 and
+fixes a number of bugs and brings some new features, mainly:
+
+- shorter tracebacks by default: only the first (test function) entry
+  and the last (failure location) entry are shown, the ones between
+  only in "short" format.  Use ``--tb=long`` to get back the old
+  behaviour of showing "long" entries everywhere.
+
+- a new warning system which reports oddities during collection
+  and execution.  For example, ignoring collecting Test* classes with an
+  ``__init__`` now produces a warning.
+
+- various improvements to nose/mock/unittest integration
+
+Note also that 2.6.0 departs with the "zero reported bugs" policy
+because it has been too hard to keep up with it, unfortunately.
+Instead we are for now rather bound to work on "upvoted" issues in
+the https://bitbucket.org/hpk42/pytest/issues?status=new&status=open&sort=-votes
+issue tracker.
+
+See docs at:
+
+    http://pytest.org
+
+As usual, you can upgrade from pypi via::
+
+    pip install -U pytest
+
+Thanks to all who contributed, among them:
+
+    Benjamin Peterson
+    Jurko Gospodnetić
+    Floris Bruynooghe
+    Marc Abramowitz
+    Marc Schlaich
+    Trevor Bekolay
+    Bruno Oliveira
+    Alex Groenholm
+
+have fun,
+holger krekel
+
+2.6.0
+-----------------------------------
+
+- fix issue537: Avoid importing old assertion reinterpretation code by default.
+  Thanks Benjamin Peterson.
+
+- fix issue364: shorten and enhance tracebacks representation by default.
+  The new "--tb=auto" option (default) will only display long tracebacks
+  for the first and last entry.  You can get the old behaviour of printing
+  all entries as long entries with "--tb=long".  Also short entries by
+  default are now printed very similarly to "--tb=native" ones.
+
+- fix issue514: teach assertion reinterpretation about private class attributes
+  Thanks Benjamin Peterson.
+
+- change -v output to include full node IDs of tests.  Users can copy
+  a node ID from a test run, including line number, and use it as a
+  positional argument in order to run only a single test.
+
+- fix issue 475: fail early and comprehensible if calling
+  pytest.raises with wrong exception type.
+
+- fix issue516: tell in getting-started about current dependencies.
+
+- cleanup setup.py a bit and specify supported versions. Thanks Jurko
+  Gospodnetic for the PR.
+
+- change XPASS colour to yellow rather then red when tests are run
+  with -v.
+
+- fix issue473: work around mock putting an unbound method into a class
+  dict when double-patching.
+
+- fix issue498: if a fixture finalizer fails, make sure that
+  the fixture is still invalidated.
+
+- fix issue453: the result of the pytest_assertrepr_compare hook now gets
+  it's newlines escaped so that format_exception does not blow up.
+
+- internal new warning system: pytest will now produce warnings when
+  it detects oddities in your test collection or execution.
+  Warnings are ultimately sent to a new pytest_logwarning hook which is
+  currently only implemented by the terminal plugin which displays
+  warnings in the summary line and shows more details when -rw (report on
+  warnings) is specified.
+
+- change skips into warnings for test classes with an __init__ and
+  callables in test modules which look like a test but are not functions.
+
+- fix issue436: improved finding of initial conftest files from command
+  line arguments by using the result of parse_known_args rather than
+  the previous flaky heuristics.  Thanks Marc Abramowitz for tests
+  and initial fixing approaches in this area.
+
+- fix issue #479: properly handle nose/unittest(2) SkipTest exceptions
+  during collection/loading of test modules.  Thanks to Marc Schlaich
+  for the complete PR.
+
+- fix issue490: include pytest_load_initial_conftests in documentation
+  and improve docstring.
+
+- fix issue472: clarify that ``pytest.config.getvalue()`` cannot work
+  if it's triggered ahead of command line parsing.
+
+- merge PR123: improved integration with mock.patch decorator on tests.
+
+- fix issue412: messing with stdout/stderr FD-level streams is now
+  captured without crashes.
+
+- fix issue483: trial/py33 works now properly.  Thanks Daniel Grana for PR.
+
+- improve example for pytest integration with "python setup.py test"
+  which now has a generic "-a" or "--pytest-args" option where you
+  can pass additional options as a quoted string.  Thanks Trevor Bekolay.
+
+- simplified internal capturing mechanism and made it more robust
+  against tests or setups changing FD1/FD2, also better integrated
+  now with pytest.pdb() in single tests.
+
+- improvements to pytest's own test-suite leakage detection, courtesy of PRs
+  from Marc Abramowitz
+
+- fix issue492: avoid leak in test_writeorg.  Thanks Marc Abramowitz.
+
+- fix issue493: don't run tests in doc directory with ``python setup.py test``
+  (use tox -e doctesting for that)
+
+- fix issue486: better reporting and handling of early conftest loading failures
+
+- some cleanup and simplification of internal conftest handling.
+
+- work a bit harder to break reference cycles when catching exceptions.
+  Thanks Jurko Gospodnetic.
+
+- fix issue443: fix skip examples to use proper comparison.  Thanks Alex
+  Groenholm.
+
+- support nose-style ``__test__`` attribute on modules, classes and
+  functions, including unittest-style Classes.  If set to False, the
+  test will not be collected.
+
+- fix issue512: show "<notset>" for arguments which might not be set
+  in monkeypatch plugin.  Improves output in documentation.
+
+- avoid importing "py.test" (an old alias module for "pytest")

doc/en/announce/release-2.6.1.txt

@@ -0,0 +1,59 @@
+pytest-2.6.1: fixes and new xfail feature
+===========================================================================
+
+pytest is a mature Python testing tool with more than a 1100 tests
+against itself, passing on many different interpreters and platforms.
+The 2.6.1 release is drop-in compatible to 2.5.2 and actually fixes some
+regressions introduced with 2.6.0.  It also brings a little feature
+to the xfail marker which now recognizes expected exceptions,
+see the CHANGELOG below.
+
+See docs at:
+
+    http://pytest.org
+
+As usual, you can upgrade from pypi via::
+
+    pip install -U pytest
+
+Thanks to all who contributed, among them:
+
+    Floris Bruynooghe
+    Bruno Oliveira
+    Nicolas Delaby
+
+have fun,
+holger krekel
+
+Changes 2.6.1
+=================
+
+- No longer show line numbers in the --verbose output, the output is now
+  purely the nodeid.  The line number is still shown in failure reports.
+  Thanks Floris Bruynooghe.
+
+- fix issue437 where assertion rewriting could cause pytest-xdist slaves
+  to collect different tests. Thanks Bruno Oliveira.
+
+- fix issue555: add "errors" attribute to capture-streams to satisfy
+  some distutils and possibly other code accessing sys.stdout.errors.
+
+- fix issue547 capsys/capfd also work when output capturing ("-s") is disabled.
+
+- address issue170: allow pytest.mark.xfail(...) to specify expected exceptions via
+  an optional "raises=EXC" argument where EXC can be a single exception
+  or a tuple of exception classes.  Thanks David Mohr for the complete
+  PR.
+
+- fix integration of pytest with unittest.mock.patch decorator when
+  it uses the "new" argument.  Thanks Nicolas Delaby for test and PR.
+
+- fix issue with detecting conftest files if the arguments contain
+  "::" node id specifications (copy pasted from "-v" output)
+
+- fix issue544 by only removing "@NUM" at the end of "::" separated parts
+  and if the part has an ".py" extension
+
+- don't use py.std import helper, rather import things directly.
+  Thanks Bruno Oliveira.
+

doc/en/announce/release-2.6.2.txt

@@ -0,0 +1,52 @@
+pytest-2.6.2: few fixes and cx_freeze support
+===========================================================================
+
+pytest is a mature Python testing tool with more than a 1100 tests
+against itself, passing on many different interpreters and platforms.
+This release is drop-in compatible to 2.5.2 and 2.6.X.  It also
+brings support for including pytest with cx_freeze or similar
+freezing tools into your single-file app distribution.  For details
+see the CHANGELOG below.
+
+See docs at:
+
+    http://pytest.org
+
+As usual, you can upgrade from pypi via::
+
+    pip install -U pytest
+
+Thanks to all who contributed, among them:
+
+    Floris Bruynooghe
+    Benjamin Peterson
+    Bruno Oliveira
+
+have fun,
+holger krekel
+
+2.6.2
+-----------
+
+- Added function pytest.freeze_includes(), which makes it easy to embed
+  pytest into executables using tools like cx_freeze.
+  See docs for examples and rationale. Thanks Bruno Oliveira.
+
+- Improve assertion rewriting cache invalidation precision.
+
+- fixed issue561: adapt autouse fixture example for python3.
+
+- fixed issue453: assertion rewriting issue with __repr__ containing
+  "\n{", "\n}" and "\n~".
+
+- fix issue560: correctly display code if an "else:" or "finally:" is
+  followed by statements on the same line.
+
+- Fix example in monkeypatch documentation, thanks t-8ch.
+
+- fix issue572: correct tmpdir doc example for python3.
+
+- Do not mark as universal wheel because Python 2.6 is different from
+  other builds due to the extra argparse dependency.  Fixes issue566.
+  Thanks sontek.
+

doc/en/announce/release-2.6.3.txt

@@ -0,0 +1,52 @@
+pytest-2.6.3: fixes and little improvements
+===========================================================================
+
+pytest is a mature Python testing tool with more than a 1100 tests
+against itself, passing on many different interpreters and platforms.
+This release is drop-in compatible to 2.5.2 and 2.6.X.
+See below for the changes and see docs at:
+
+    http://pytest.org
+
+As usual, you can upgrade from pypi via::
+
+    pip install -U pytest
+
+Thanks to all who contributed, among them:
+
+    Floris Bruynooghe
+    Oleg Sinyavskiy
+    Uwe Schmitt
+    Charles Cloud
+    Wolfgang Schnerring
+
+have fun,
+holger krekel
+
+Changes 2.6.3
+======================
+
+- fix issue575: xunit-xml was reporting collection errors as failures
+  instead of errors, thanks Oleg Sinyavskiy.
+
+- fix issue582: fix setuptools example, thanks Laszlo Papp and Ronny
+  Pfannschmidt.
+
+- Fix infinite recursion bug when pickling capture.EncodedFile, thanks
+  Uwe Schmitt.
+
+- fix issue589: fix bad interaction with numpy and others when showing
+  exceptions.  Check for precise "maximum recursion depth exceed" exception
+  instead of presuming any RuntimeError is that one (implemented in py
+  dep).  Thanks Charles Cloud for analysing the issue.
+
+- fix conftest related fixture visibility issue: when running with a
+  CWD outside a test package pytest would get fixture discovery wrong.
+  Thanks to Wolfgang Schnerring for figuring out a reproducable example.
+
+- Introduce pytest_enter_pdb hook (needed e.g. by pytest_timeout to cancel the
+  timeout when interactively entering pdb).  Thanks Wolfgang Schnerring.
+
+- check xfail/skip also with non-python function test items. Thanks
+  Floris Bruynooghe.
+

doc/en/apiref.txt

@@ -1,7 +1,7 @@
 
 .. _apiref:
 
-py.test reference documentation
+pytest reference documentation
 ================================================
 
 .. toctree::
@@ -10,14 +10,16 @@ py.test reference documentation
    builtin.txt
    customize.txt
    assert.txt
-   funcargs.txt
+   fixture.txt
+   yieldfixture.txt
+   parametrize.txt
    xunit_setup.txt
    capture.txt
    monkeypatch.txt
    xdist.txt
    tmpdir.txt
-   skipping.txt
    mark.txt
+   skipping.txt
    recwarn.txt
    unittest.txt
    nose.txt

doc/en/assert.txt

@@ -2,12 +2,15 @@
 The writing and reporting of assertions in tests
 ==================================================
 
+.. _`assertfeedback`:
 .. _`assert with the assert statement`:
+.. _`assert`:
+
 
 Asserting with the ``assert`` statement
 ---------------------------------------------------------
 
-``py.test`` allows you to use the standard python ``assert`` for verifying
+``pytest`` allows you to use the standard python ``assert`` for verifying
 expectations and values in Python tests.  For example, you can write the
 following::
 
@@ -23,8 +26,8 @@ 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
-    collecting ... collected 1 items
+    platform linux -- Python 3.4.0 -- py-1.4.25 -- pytest-2.6.3
+    collected 1 items
     
     test_assert1.py F
     
@@ -37,9 +40,9 @@ you will see the return value of the function call::
     E        +  where 3 = f()
     
     test_assert1.py:5: AssertionError
-    ========================= 1 failed in 0.02 seconds =========================
+    ========================= 1 failed in 0.01 seconds =========================
 
-py.test has support for showing the values of the most common subexpressions
+``pytest`` has support for showing the values of the most common subexpressions
 including calls, attributes, comparisons, and binary and unary
 operators. (See :ref:`tbreportdemo`).  This allows you to use the
 idiomatic python constructs without boilerplate code while not losing
@@ -54,6 +57,8 @@ will be simply shown in the traceback.
 
 See :ref:`assert-details` for more information on assertion introspection.
 
+.. _`assertraises`:
+
 Assertions about expected exceptions
 ------------------------------------------
 
@@ -61,19 +66,28 @@ In order to write assertions about raised exceptions, you can use
 ``pytest.raises`` as a context manager like this::
 
     import pytest
-    with pytest.raises(ZeroDivisionError):
-        1 / 0
+
+    def test_zero_division():
+        with pytest.raises(ZeroDivisionError):
+            1 / 0
 
 and if you need to have access to the actual exception info you may use::
 
-    with pytest.raises(RuntimeError) as excinfo:
-        def f():
+    def test_recursion_depth():
+        with pytest.raises(RuntimeError) as excinfo:
+            def f():
+                f()
             f()
-        f()
+        assert 'maximum recursion' in str(excinfo.value)
 
-    # do checks related to excinfo.type, excinfo.value, excinfo.traceback
+``excinfo`` is a `py.code.ExceptionInfo`_ instance, which is a wrapper around
+the actual exception raised.  The main attributes of interest are
+``.type``, ``.value`` and ``.traceback``.
 
-If you want to write test code that works on Python2.4 as well,
+.. _py.code.ExceptionInfo:
+    http://pylib.readthedocs.org/en/latest/code.html#py-code-exceptioninfo
+
+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)
@@ -84,6 +98,22 @@ asserts that the given ``ExpectedException`` is raised.  The reporter will
 provide you with helpful output in case of failures such as *no
 exception* or *wrong exception*.
 
+Note that it is also possible to specify a "raises" argument to
+``pytest.mark.xfail``, which checks that the test is failing in a more
+specific way than just having any exception raised::
+
+    @pytest.mark.xfail(raises=IndexError)
+    def test_f():
+        f()
+
+Using ``pytest.raises`` is likely to be better for cases where you are testing
+exceptions your own code is deliberately raising, whereas using
+``@pytest.mark.xfail`` with a check function is probably better for something
+like documenting unfixed bugs (where the test describes what "should" happen)
+or bugs in dependencies.
+
+
+
 .. _newreport:
 
 Making use of context-sensitive comparisons
@@ -91,7 +121,7 @@ Making use of context-sensitive comparisons
 
 .. versionadded:: 2.0
 
-py.test has rich support for providing context-sensitive information
+``pytest`` has rich support for providing context-sensitive information
 when it encounters comparisons.  For example::
 
     # content of test_assert2.py
@@ -105,8 +135,8 @@ if you run this module::
 
     $ py.test test_assert2.py
     =========================== test session starts ============================
-    platform darwin -- Python 2.7.1 -- pytest-2.2.0
-    collecting ... collected 1 items
+    platform linux -- Python 3.4.0 -- py-1.4.25 -- pytest-2.6.3
+    collected 1 items
     
     test_assert2.py F
     
@@ -124,7 +154,7 @@ if you run this module::
     E         '5'
     
     test_assert2.py:5: AssertionError
-    ========================= 1 failed in 0.02 seconds =========================
+    ========================= 1 failed in 0.01 seconds =========================
 
 Special comparisons are done for a number of cases:
 
@@ -164,24 +194,23 @@ now, given this test module::
        f2 = Foo(2)
        assert f1 == f2
 
-you can run the test module and get the custom output defined in 
+you can run the test module and get the custom output defined in
 the conftest file::
 
    $ py.test -q test_foocompare.py
-   collecting ... collected 1 items
    F
    ================================= FAILURES =================================
    _______________________________ test_compare _______________________________
-   
+
        def test_compare():
            f1 = Foo(1)
            f2 = Foo(2)
    >       assert f1 == f2
    E       assert Comparing Foo instances:
    E            vals: 1 != 2
-   
+
    test_foocompare.py:8: AssertionError
-   1 failed in 0.02 seconds
+   1 failed in 0.01 seconds
 
 .. _assert-details:
 .. _`assert introspection`:
@@ -195,33 +224,33 @@ Advanced assertion introspection
 Reporting details about a failing assertion is achieved either by rewriting
 assert statements before they are run or re-evaluating the assert expression and
 recording the intermediate values. Which technique is used depends on the
-location of the assert, py.test's configuration, and Python version being used
-to run py.test.  Note that for assert statements with a manually provided
+location of the assert, ``pytest`` configuration, and Python version being used
+to run ``pytest``.  Note that for assert statements with a manually provided
 message, i.e. ``assert expr, message``, no assertion introspection takes place
 and the manually provided message will be rendered in tracebacks.
 
-By default, if the Python version is greater than or equal to 2.6, py.test
+By default, if the Python version is greater than or equal to 2.6, ``pytest``
 rewrites assert statements in test modules. Rewritten assert statements put
-introspection information into the assertion failure message. py.test only
+introspection information into the assertion failure message. ``pytest`` only
 rewrites test modules directly discovered by its test collection process, so
 asserts in supporting modules which are not themselves test modules will not be
 rewritten.
 
 .. note::
 
-   py.test rewrites test modules on import. It does this by using an import hook
-   to write a new pyc files. Most of the time this works transparently. However,
-   if you are messing with import yourself, the import hook may interfere. If
-   this is the case, simply use ``--assert=reinterp`` or
+   ``pytest`` rewrites test modules on import. It does this by using an import
+   hook to write a new pyc files. Most of the time this works transparently.
+   However, if you are messing with import yourself, the import hook may
+   interfere. If this is the case, simply use ``--assert=reinterp`` or
    ``--assert=plain``. Additionally, rewriting will fail silently if it cannot
    write new pycs, i.e. in a read-only filesystem or a zipfile.
 
 If an assert statement has not been rewritten or the Python version is less than
-2.6, py.test falls back on assert reinterpretation. In assert reinterpretation,
-py.test walks the frame of the function containing the assert statement to
-discover sub-expression results of the failing assert statement. You can force
-py.test to always use assertion reinterpretation by passing the
-``--assert=reinterp`` option.
+2.6, ``pytest`` falls back on assert reinterpretation. In assert
+reinterpretation, ``pytest`` walks the frame of the function containing the
+assert statement to discover sub-expression results of the failing assert
+statement. You can force ``pytest`` to always use assertion reinterpretation by
+passing the ``--assert=reinterp`` option.
 
 Assert reinterpretation has a caveat not present with assert rewriting: If
 evaluating the assert expression has side effects you may get a warning that the
@@ -240,7 +269,7 @@ easy to rewrite the assertion and avoid any trouble::
 
 All assert introspection can be turned off by passing ``--assert=plain``.
 
-For further information, Benjamin Peterson wrote up `Behind the scenes of py.test's new assertion rewriting <http://pybites.blogspot.com/2011/07/behind-scenes-of-pytests-new-assertion.html>`_.
+For further information, Benjamin Peterson wrote up `Behind the scenes of pytest's new assertion rewriting <http://pybites.blogspot.com/2011/07/behind-scenes-of-pytests-new-assertion.html>`_.
 
 .. versionadded:: 2.1
    Add assert rewriting as an alternate introspection technique.

doc/en/bash-completion.txt

@@ -0,0 +1,28 @@
+
+.. _bash_completion:
+
+Setting up bash completion
+==========================
+
+When using bash as your shell, ``pytest`` can use argcomplete
+(https://argcomplete.readthedocs.org/) for auto-completion.
+For this ``argcomplete`` needs to be installed **and** enabled.
+
+Install argcomplete using::
+
+        sudo pip install 'argcomplete>=0.5.7'
+
+For global activation of all argcomplete enabled python applications run::
+
+	sudo activate-global-python-argcomplete
+
+For permanent (but not global) ``pytest`` activation, use::
+
+        register-python-argcomplete py.test >> ~/.bashrc
+
+For one-time activation of argcomplete for ``pytest`` only, use::
+
+        eval "$(register-python-argcomplete py.test)"
+
+
+