Merge pull request #1084 from hpk42/branch-281

2.8.1 release

.coveragerc

@@ -0,0 +1,7 @@
+[run]
+omit = 
+    # standlonetemplate is read dynamically and tested by test_genscript
+    *standalonetemplate.py
+    # oldinterpret could be removed, as it is no longer used in py26+
+    *oldinterpret.py
+    vendored_packages

.gitattributes

@@ -0,0 +1 @@
+CHANGELOG    merge=union

.gitignore

@@ -17,16 +17,18 @@ include/
 *.orig
 *~
 
+.eggs/
+
 doc/*/_build
 build/
 dist/
 *.egg-info
 issue/
 env/
+.env/
 3rdparty/
 .tox
 .cache
 .coverage
 .ropeproject
 .idea
-

.hgignore

@@ -1,39 +0,0 @@
-# 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
-*.pyc
-*.pyo
-*.swp
-*.html
-*.class
-*.orig
-*~
-
-doc/*/_build
-build/
-dist/
-testing/cx_freeze/build
-testing/cx_freeze/cx_freeze_source
-*.egg-info
-issue/
-env/
-env3/
-3rdparty/
-.tox
-.cache
-.coverage
-.ropeproject
-*.sublime-*

.hgtags

@@ -1,77 +0,0 @@
-52c6d9e78777a5a34e813123997dfc614a1a4767 1.0.0b3
-1c7aaa8c61f3b0945921a9acc7beb184201aed4b 1.0.0b4
-1c7aaa8c61f3b0945921a9acc7beb184201aed4b 1.0.0b4
-0000000000000000000000000000000000000000 1.0.0b4
-0000000000000000000000000000000000000000 1.0.0b4
-8cd6eb91eba313b012d6e568f37d844dc0751f2e 1.0.0b4
-8cd6eb91eba313b012d6e568f37d844dc0751f2e 1.0.0b4
-0000000000000000000000000000000000000000 1.0.0b4
-2cc0507f117ffe721dff7ee026648cfce00ec92f 1.0.0b6
-86f1e1b6e49bf5882a809f11edd1dbb08162cdad 1.0.0b8
-86f1e1b6e49bf5882a809f11edd1dbb08162cdad 1.0.0b8
-c63f35c266cbb26dad6b87b5e115d65685adf448 1.0.0b8
-c63f35c266cbb26dad6b87b5e115d65685adf448 1.0.0b8
-0eaa0fdf2ba0163cf534dc2eff4ba2e5fc66c261 1.0.0b8
-e2a60653cb490aeed81bbbd83c070b99401c211c 1.0.0b9
-5ea0cdf7854c3d4278d36eda94a2b68483a0e211 1.0.0
-5ea0cdf7854c3d4278d36eda94a2b68483a0e211 1.0.0
-7acde360d94b6a2690ce3d03ff39301da84c0a2b 1.0.0
-6bd221981ac99103002c1cb94fede400d23a96a1 1.0.1
-4816e8b80602a3fd3a0a120333ad85fbe7d8bab4 1.0.2
-60c44bdbf093285dc69d5462d4dbb4acad325ca6 1.1.0
-319187fcda66714c5eb1353492babeec3d3c826f 1.1.1
-4fc5212f7626a56b9eb6437b5c673f56dd7eb942 1.2.0
-c143a8c8840a1c68570890c8ac6165bbf92fd3c6 1.2.1
-eafd3c256e8732dfb0a4d49d051b5b4339858926 1.3.0
-d5eacf390af74553227122b85e20345d47b2f9e6 1.3.1
-d5eacf390af74553227122b85e20345d47b2f9e6 1.3.1
-8b8e7c25a13cf863f01b2dd955978285ae9daf6a 1.3.1
-3bff44b188a7ec1af328d977b9d39b6757bb38df 1.3.2
-c59d3fa8681a5b5966b8375b16fccd64a3a8dbeb 1.3.3
-79ef6377705184c55633d456832eea318fedcf61 1.3.4
-79ef6377705184c55633d456832eea318fedcf61 1.3.4
-90fffd35373e9f125af233f78b19416f0938d841 1.3.4
-e9e127acd6f0497324ef7f40cfb997cad4c4cd17 2.0.0
-e4497c2aed358c1988cf7be83ca9394c3c707fa2 2.0.1
-84e5c54b72448194a0f6f815da7e048ac8019d50 2.0.2
-2ef82d82daacb72733a3a532a95c5a37164e5819 2.0.3
-2ef82d82daacb72733a3a532a95c5a37164e5819 2.0.3
-c777dcad166548b7499564cb49ae5c8b4b07f935 2.0.3
-c777dcad166548b7499564cb49ae5c8b4b07f935 2.0.3
-49f11dbff725acdcc5fe3657cbcdf9ae04e25bbc 2.0.3
-49f11dbff725acdcc5fe3657cbcdf9ae04e25bbc 2.0.3
-363e5a5a59c803e6bc176a6f9cc4bf1a1ca2dab0 2.0.3
-e5e1746a197f0398356a43fbe2eebac9690f795d 2.1.0
-5864412c6f3c903384243bd315639d101d7ebc67 2.1.2
-12a05d59249f80276e25fd8b96e8e545b1332b7a 2.1.3
-1522710369337d96bf9568569d5f0ca9b38a74e0 2.2.0
-3da8cec6c5326ed27c144c9b6d7a64a648370005 2.2.1
-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
-2967aa416a4f3cdb65fc75073a2a148e1f372742 2.6.3
-f03b6de8325f5b6c35cea7c3de092f134ea8ef07 2.6.4
-7ed701fa2fb554bfc0618d447dfec700cc697407 2.7.0
-edc1d080bab5a970da8f6c776be50768829a7b09 2.7.1

.travis.yml

@@ -1,37 +1,40 @@
 sudo: false
 language: python
 python:
-    - '3.5.0b3'
+    - '3.5'
 # command to install dependencies
 install: "pip install -U tox"
 # # command to run tests
 env:
   matrix:
+    - TESTENV=coveralls
+    - TESTENV=doctesting
     - TESTENV=flakes
     - TESTENV=py26
     - TESTENV=py27
+    - TESTENV=py27-cxfreeze
+    - TESTENV=py27-nobyte
+    - TESTENV=py27-pexpect
+    - TESTENV=py27-subprocess
+    - TESTENV=py27-trial
+    - TESTENV=py27-xdist
+    - TESTENV=py33
     - TESTENV=py33
     - TESTENV=py34
+    - TESTENV=py35-pexpect
+    - TESTENV=py35-trial
+    - TESTENV=py35-xdist
     - TESTENV=py35
     - TESTENV=pypy
-    - TESTENV=py27-pexpect
-    - TESTENV=py34-pexpect
-    - TESTENV=py27-nobyte
-    - TESTENV=py27-xdist
-    - TESTENV=py34-xdist
-    - TESTENV=py27-trial
-    - TESTENV=py33
-    - TESTENV=py34-trial
-    # inprocess tests by default were introduced in 2.8 only;
-    # this TESTENV should be enabled when merged back to master
-    #- TESTENV=py27-subprocess
-    - TESTENV=doctesting
-    - TESTENV=py27-cxfreeze
-    - TESTENV=coveralls
-script: tox --recreate -i ALL=https://devpi.net/hpk/dev/ -e $TESTENV
+
+script: tox --recreate -e $TESTENV
 
 notifications:
   irc:
-    - "chat.freenode.net#pytest-dev"
+    channels:
+      - "chat.freenode.net#pytest"
+    on_success: change
+    on_failure: change
+    skip_join: true
   email:
     - pytest-commit@python.org

AUTHORS

@@ -3,6 +3,7 @@ merlinux GmbH, Germany, office at merlinux eu
 
 Contributors include::
 
+Abhijeet Kasurde
 Anatoly Bubenkoff
 Andreas Zeidler
 Andy Freeland
@@ -14,6 +15,7 @@ Bob Ippolito
 Brian Dorsey
 Brian Okken
 Brianna Laugher
+Bruno Oliveira
 Carl Friedrich Bolz
 Charles Cloud
 Chris Lamb
@@ -25,6 +27,11 @@ Daniel Nuri
 Dave Hunt
 David Mohr
 Edison Gustavo Muenz
+Eduardo Schettino
+Elizaveta Shashkova
+Eric Hunsberger
+Eric Siegerman
+Florian Bruhin
 Floris Bruynooghe
 Graham Horler
 Grig Gheorghiu
@@ -33,14 +40,18 @@ Harald Armin Massa
 Ian Bicking
 Jaap Broekhuizen
 Jan Balster
+Janne Vanhala
 Jason R. Coombs
 Jurko Gospodnetić
 Katarzyna Jachim
+Kevin Cox
 Maciek Fijalkowski
 Maho
 Marc Schlaich
 Mark Abramowitz
+Markus Unterwaditzer
 Martijn Faassen
+Michael Droettboom
 Nicolas Delaby
 Pieter Mulder
 Piotr Banaszkiewicz
@@ -52,3 +63,8 @@ Samuele Pedroni
 Tom Viner
 Trevor Bekolay
 Wouter van Ackooy
+David Díaz-Barquero
+Eric Hunsberger
+Simon Gomizelj
+Russel Winder
+Ben Webb

CHANGELOG

@@ -1,3 +1,239 @@
+2.8.1
+-----
+
+- fix #1034: Add missing nodeid on pytest_logwarning call in
+  addhook.  Thanks Simon Gomizelj for the PR.
+
+- 'deprecated_call' is now only satisfied with a DeprecationWarning or
+  PendingDeprecationWarning. Before 2.8.0, it accepted any warning, and 2.8.0
+  made it accept only DeprecationWarning (but not PendingDeprecationWarning).
+  Thanks Alex Gaynor for the issue and Eric Hunsberger for the PR.
+
+- fix issue #1073: avoid calling __getattr__ on potential plugin objects.
+  This fixes an incompatibility with pytest-django.  Thanks Andreas Pelme,
+  Bruno Oliveira and Ronny Pfannschmidt for contributing and Holger Krekel
+  for the fix.
+
+- Fix issue #704: handle versionconflict during plugin loading more
+  gracefully.  Thanks Bruno Oliveira for the PR.
+
+- Fix issue #1064: ""--junitxml" regression when used with the
+  "pytest-xdist" plugin, with test reports being assigned to the wrong tests.
+  Thanks Daniel Grunwald for the report and Bruno Oliveira for the PR.
+
+- (experimental) adapt more SEMVER style versioning and change meaning of 
+  master branch in git repo: "master" branch now keeps the bugfixes, changes 
+  aimed for micro releases.  "features" branch will only be be released 
+  with minor or major pytest releases.
+
+- Fix issue #766 by removing documentation references to distutils.
+  Thanks Russel Winder.
+
+- Fix issue #1030: now byte-strings are escaped to produce item node ids
+  to make them always serializable.
+  Thanks Andy Freeland for the report and Bruno Oliveira for the PR.
+
+- Python 2: if unicode parametrized values are convertible to ascii, their
+  ascii representation is used for the node id.
+
+- Fix issue #411: Add __eq__ method to assertion comparison example.
+  Thanks Ben Webb.
+
+- fix issue 877: properly handle assertion explanations with non-ascii repr
+  Thanks Mathieu Agopian for the report and Ronny Pfannschmidt for the PR.
+
+- fix issue 1029: transform errors when writing cache values into pytest-warnings
+
+2.8.0
+-----------------------------
+
+- new ``--lf`` and ``-ff`` options to run only the last failing tests or
+  "failing tests first" from the last run.  This functionality is provided 
+  through porting the formerly external pytest-cache plugin into pytest core.
+  BACKWARD INCOMPAT: if you used pytest-cache's functionality to persist
+  data between test runs be aware that we don't serialize sets anymore.
+  Thanks Ronny Pfannschmidt for most of the merging work.
+
+- "-r" option now accepts "a" to include all possible reports, similar
+  to passing "fEsxXw" explicitly (isse960).
+  Thanks Abhijeet Kasurde for the PR.
+
+- avoid python3.5 deprecation warnings by introducing version
+  specific inspection helpers, thanks Michael Droettboom.
+
+- fix issue562: @nose.tools.istest now fully respected.
+
+- fix issue934: when string comparison fails and a diff is too large to display
+  without passing -vv, still show a few lines of the diff.
+  Thanks Florian Bruhin for the report and Bruno Oliveira for the PR.
+
+- fix issue736: Fix a bug where fixture params would be discarded when combined
+  with parametrization markers.
+  Thanks to Markus Unterwaditzer for the PR.
+
+- fix issue710: introduce ALLOW_UNICODE doctest option: when enabled, the
+  ``u`` prefix is stripped from unicode strings in expected doctest output. This
+  allows doctests which use unicode to run in Python 2 and 3 unchanged.
+  Thanks Jason R. Coombs for the report and Bruno Oliveira for the PR.
+
+- parametrize now also generates meaningful test IDs for enum, regex and class
+  objects (as opposed to class instances).
+  Thanks to Florian Bruhin for the PR.
+
+- Add 'warns' to assert that warnings are thrown (like 'raises').
+  Thanks to Eric Hunsberger for the PR.
+
+- Fix issue683: Do not apply an already applied mark.  Thanks ojake for the PR.
+
+- Deal with capturing failures better so fewer exceptions get lost to
+  /dev/null.  Thanks David Szotten for the PR.
+
+- fix issue730: deprecate and warn about the --genscript option.
+  Thanks Ronny Pfannschmidt for the report and Christian Pommranz for the PR.
+
+- fix issue751: multiple parametrize with ids bug if it parametrizes class with
+  two or more test methods. Thanks Sergey Chipiga for reporting and Jan
+  Bednarik for PR.
+
+- fix issue82: avoid loading conftest files from setup.cfg/pytest.ini/tox.ini
+  files and upwards by default (--confcutdir can still be set to override this).
+  Thanks Bruno Oliveira for the PR.
+
+- fix issue768: docstrings found in python modules were not setting up session
+  fixtures. Thanks Jason R. Coombs for reporting and Bruno Oliveira for the PR.
+
+- added `tmpdir_factory`, a session-scoped fixture that can be used to create
+  directories under the base temporary directory. Previously this object was
+  installed as a `_tmpdirhandler` attribute of the `config` object, but now it
+  is part of the official API and using `config._tmpdirhandler` is
+  deprecated.
+  Thanks Bruno Oliveira for the PR.
+
+- fix issue808: pytest's internal assertion rewrite hook now implements the
+  optional PEP302 get_data API so tests can access data files next to them.
+  Thanks xmo-odoo for request and example and Bruno Oliveira for
+  the PR.
+
+- rootdir and inifile are now displayed during usage errors to help
+  users diagnose problems such as unexpected ini files which add
+  unknown options being picked up by pytest. Thanks to Pavel Savchenko for
+  bringing the problem to attention in #821 and Bruno Oliveira for the PR.
+
+- Summary bar now is colored yellow for warning
+  situations such as: all tests either were skipped or xpass/xfailed,
+  or no tests were run at all (this is a partial fix for issue500).
+
+- fix issue812: pytest now exits with status code 5 in situations where no
+  tests were run at all, such as the directory given in the command line does
+  not contain any tests or as result of a command line option filters
+  all out all tests (-k for example).
+  Thanks Eric Siegerman (issue812) and Bruno Oliveira for the PR.
+
+- Summary bar now is colored yellow for warning
+  situations such as: all tests either were skipped or xpass/xfailed,
+  or no tests were run at all (related to issue500).
+  Thanks Eric Siegerman.
+
+- New `testpaths` ini option: list of directories to search for tests
+  when executing pytest from the root directory. This can be used
+  to speed up test collection when a project has well specified directories
+  for tests, being usually more practical than configuring norecursedirs for
+  all directories that do not contain tests.
+  Thanks to Adrian for idea (#694) and Bruno Oliveira for the PR.
+
+- fix issue713: JUnit XML reports for doctest failures.
+  Thanks Punyashloka Biswal.
+
+- fix issue970: internal pytest warnings now appear as "pytest-warnings" in
+  the terminal instead of "warnings", so it is clear for users that those
+  warnings are from pytest and not from the builtin "warnings" module.
+  Thanks Bruno Oliveira.
+
+- Include setup and teardown in junitxml test durations.
+  Thanks Janne Vanhala.
+
+- fix issue735: assertion failures on debug versions of Python 3.4+
+
+- new option ``--import-mode`` to allow to change test module importing 
+  behaviour to append to sys.path instead of prepending.  This better allows 
+  to run test modules against installated versions of a package even if the 
+  package under test has the same import root.  In this example::
+
+        testing/__init__.py
+        testing/test_pkg_under_test.py
+        pkg_under_test/
+
+  the tests will run against the installed version
+  of pkg_under_test when ``--import-mode=append`` is used whereas 
+  by default they would always pick up the local version.  Thanks Holger Krekel.
+
+- pytester: add method ``TmpTestdir.delete_loaded_modules()``, and call it
+  from ``inline_run()`` to allow temporary modules to be reloaded.
+  Thanks Eduardo Schettino.
+
+- internally refactor pluginmanager API and code so that there
+  is a clear distinction between a pytest-agnostic rather simple
+  pluginmanager and the PytestPluginManager which adds a lot of
+  behaviour, among it handling of the local conftest files.
+  In terms of documented methods this is a backward compatible
+  change but it might still break 3rd party plugins which relied on
+  details like especially the pluginmanager.add_shutdown() API.
+  Thanks Holger Krekel.
+
+- pluginmanagement: introduce ``pytest.hookimpl`` and
+  ``pytest.hookspec`` decorators for setting impl/spec
+  specific parameters.  This substitutes the previous
+  now deprecated use of ``pytest.mark`` which is meant to
+  contain markers for test functions only.
+
+- write/refine docs for "writing plugins" which now have their
+  own page and are separate from the "using/installing plugins`` page.
+
+- fix issue732: properly unregister plugins from any hook calling
+  sites allowing to have temporary plugins during test execution.
+
+- deprecate and warn about ``__multicall__`` argument in hook
+  implementations.  Use the ``hookwrapper`` mechanism instead already
+  introduced with pytest-2.7.
+
+- speed up pytest's own test suite considerably by using inprocess
+  tests by default (testrun can be modified with --runpytest=subprocess
+  to create subprocesses in many places instead).  The main
+  APIs to run pytest in a test is "runpytest()" or "runpytest_subprocess"
+  and "runpytest_inprocess" if you need a particular way of running
+  the test.  In all cases you get back a RunResult but the inprocess
+  one will also have a "reprec" attribute with the recorded events/reports.
+
+- fix monkeypatch.setattr("x.y", raising=False) to actually not raise
+  if "y" is not a pre-existing attribute. Thanks Florian Bruhin.
+
+- fix issue741: make running output from testdir.run copy/pasteable
+  Thanks Bruno Oliveira.
+
+- add a new ``--noconftest`` argument which ignores all ``conftest.py`` files.
+
+- add ``file`` and ``line`` attributes to JUnit-XML output.
+
+- fix issue890: changed extension of all documentation files from ``txt`` to
+  ``rst``. Thanks to Abhijeet for the PR.
+
+- fix issue714: add ability to apply indirect=True parameter on particular argnames.
+  Thanks Elizaveta239.
+
+- fix issue890: changed extension of all documentation files from ``txt`` to
+  ``rst``. Thanks to Abhijeet for the PR.
+
+- fix issue957: "# doctest: SKIP" option will now register doctests as SKIPPED
+  rather than PASSED.
+  Thanks Thomas Grainger for the report and Bruno Oliveira for the PR.
+
+- issue951: add new record_xml_property fixture, that supports logging
+  additional information on xml output. Thanks David Diaz for the PR.
+
+- issue949: paths after normal options (for example `-s`, `-v`, etc) are now
+  properly used to discover `rootdir` and `ini` files.
+  Thanks Peter Lauri for the report and Bruno Oliveira for the PR.
+
 2.7.3 (compared to 2.7.2)
 -----------------------------
 
@@ -41,7 +277,6 @@
   directories created by this fixture (defaults to $TEMP/pytest-$USER).
   Thanks Bruno Oliveira for the PR.
 
-
 2.7.2 (compared to 2.7.1)
 -----------------------------
 
@@ -164,7 +399,7 @@
   it from the "decorator" case.  Thanks Tom Viner.
 
 - "python_classes" and "python_functions" options now support glob-patterns
-  for test discovery, as discussed in issue600. Thanks Ldiary Translations.
+ for test discovery, as discussed in issue600. Thanks Ldiary Translations.
 
 - allow to override parametrized fixtures with non-parametrized ones and vice versa (bubenkoff).
 
@@ -1973,7 +2208,7 @@ v1.0.0b1
 * introduced new "funcarg" setup method,
   see doc/test/funcarg.txt
 
-* introduced plugin architecuture and many
+* introduced plugin architecture and many
   new py.test plugins, see
   doc/test/plugins.txt
 

CONTRIBUTING.rst

@@ -21,7 +21,7 @@ in repositories living under:
 
 - `the pytest-dev bitbucket team <https://bitbucket.org/pytest-dev>`_
 
-All pytest-dev team members have write access to all contained
+All pytest-dev Contributors team members have write access to all contained
 repositories.  pytest core and plugins are generally developed
 using `pull requests`_ to respective repositories.
 
@@ -46,9 +46,9 @@ the following:
 
 If no contributor strongly objects and two agree, the repo will be
 transferred to the ``pytest-dev`` organisation and you'll become a
-member of the ``pytest-dev`` team, with commit rights to all projects.
-We recommend that each plugin has at least three people who have the
-right to release to pypi.
+member of the ``pytest-dev Contributors`` team, with commit rights
+to all projects. We recommend that each plugin has at least three
+people who have the right to release to pypi.
 
 
 .. _reportbugs:
@@ -66,6 +66,10 @@ If you are reporting a bug, please include:
   installed libraries and pytest version.
 * Detailed steps to reproduce the bug.
 
+If you can write a demonstration test that currently fails but should pass (xfail),
+that is a very useful commit to make as well, even if you can't find how
+to fix the bug yet.
+
 .. _submitfeedback:
 
 Submit feedback for developers
@@ -93,6 +97,8 @@ https://github.com/pytest-dev/pytest/labels/bug
 
 :ref:`Talk <contact>` to developers to find out how you can fix specific bugs.
 
+Don't forget to check the issue trackers of your favourite plugins, too!
+
 .. _writeplugins:
 
 Implement features
@@ -111,10 +117,14 @@ 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.
+* Documentation translations.  We currently have only English.
 * Docstrings.  There's never too much of them.
 * Blog posts, articles and such -- they're all very appreciated.
 
+You can also edit documentation files directly in the Github web interface
+without needing to make a fork and local copy. This can be convenient for
+small fixes.
+
 .. _`pull requests`:
 .. _pull-requests:
 
@@ -141,59 +151,71 @@ but here is a simple overview:
 
     $ git clone git@github.com:YOUR_GITHUB_USERNAME/pytest.git
     $ cd pytest
-    $ git checkout pytest-2.7      # if you want to fix a bug for the pytest-2.7 series
-    $ git checkout master          # if you want to add a feature bound for the next minor release
-    $ git branch your-branch-name  # your feature/bugfix branch
+    # now, to fix a bug create your own branch off "master":
+    
+        $ git checkout -b your-bugfix-branch-name master
+
+    # or to instead add a feature create your own branch off "features":
+    
+        $ git checkout -b your-feature-branch-name features
+
+   Given we have "major.minor.micro" version numbers, bugfixes will usually 
+   be released in micro releases whereas features will be released in 
+   minor releases and incompatible changes in major releases.
 
    If you need some help with Git, follow this quick start
    guide: https://git.wiki.kernel.org/index.php/QuickStart
 
-#. Create a development environment
+#. Install tox
+
+   Tox is used to run all the tests and will automatically setup virtualenvs
+   to run the tests in.
    (will implicitly use http://www.virtualenv.org/en/latest/)::
 
-    $ make develop
-    $ source .env/bin/activate
+    $ pip install tox
 
-#. You can now edit your local working copy.
+#. Run all the tests
 
-   You need to have Python 2.7 and 3.4 available in your system.  Now
+   You need to have Python 2.7 and 3.5 available in your system.  Now
    running tests is as simple as issuing this command::
 
-    $ python runtox.py -e py27,py34,flakes
+    $ python runtox.py -e py27,py35,flakes
 
-   This command will run tests via the "tox" tool against Python 2.7 and 3.4
+   This command will run tests via the "tox" tool against Python 2.7 and 3.5
    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)
+#. You can now edit your local working copy.
+
+   You can now make the changes you want and run the tests again as necessary.
+
+   To run tests on py27 and pass options to pytest (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 py34::
+   or to only run tests in a particular test module on py35::
 
-    $ python runtox.py -e py34 -- testing/test_config.py
+    $ python runtox.py -e py35 -- testing/test_config.py
 
 #. Commit and push once your tests pass and you are happy with your change(s)::
 
     $ git commit -a -m "<commit message>"
     $ git push -u
 
-#. Finally, submit a pull request through the GitHub website:
+   Make sure you add a CHANGELOG message, and add yourself to AUTHORS. If you
+   are unsure about either of these steps, submit your pull request and we'll
+   help you fix it up.
 
-   .. image:: img/pullrequest.png
-    :width: 700px
-    :align: center
-
-   ::
+#. Finally, submit a pull request through the GitHub website using this data::
 
     head-fork: YOUR_GITHUB_USERNAME/pytest
     compare: your-branch-name
 
     base-fork: pytest-dev/pytest
-    base: master          # if it's a feature
-    base: pytest-VERSION  # if it's a bugfix
+    base: master          # if it's a bugfix
+    base: feature         # if it's a feature
 
 

HOWTORELEASE.rst

@@ -1,59 +1,87 @@
-
-How to release pytest (draft)
+How to release pytest
 --------------------------------------------
 
-1. bump version numbers in _pytest/__init__.py (setup.py reads it)
+Note: this assumes you have already registered on pypi.
 
-2. check and finalize CHANGELOG
+1. Bump version numbers in _pytest/__init__.py (setup.py reads it)
 
-3. write doc/en/announce/release-VERSION.txt and include
+2. Check and finalize CHANGELOG
+
+3. Write doc/en/announce/release-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 --formats sdist,bdist_wheel``
+4. Use devpi for uploading a release tarball to a staging area::
 
-5. run from multiple machines:
-   - ``devpi use https://devpi.net/USER/dev`` 
-   - ``devpi test pytest==VERSION``
+     devpi use https://devpi.net/USER/dev
+     devpi upload --formats sdist,bdist_wheel
+
+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
 
-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. Regenerate the docs examples using tox::
-      # Create and activate a virtualenv with regendoc installed
-      # (currently needs revision 4a9ec1035734)
-      tox -e regen
+7. Regenerate the docs examples using tox, and check for regressions::
 
-8. Build the docs, you need a virtualenv with, py and sphinx
+      tox -e regen
+      git diff
+
+
+8. Build the docs, you need a virtualenv with py and sphinx
    installed::
-      cd docs/en
+
+      cd doc/en
       make html
 
-9. Tag the release::
-      hg tag VERSION
+   Commit any changes before tagging the release.
+
+9. Tag the release::
+
+      git tag VERSION
+      git push
+
+10. Upload the docs using doc/en/Makefile::
+
+      cd doc/en
+      make install  # or "installall" if you have LaTeX installed for PDF
 
-10. Upload the docs using docs/en/Makefile::
-      cd docs/en
-      make install  # or "installall" if you have LaTeX installed
    This requires ssh-login permission on pytest.org because it uses
    rsync.
-   Note that the "install" target of doc/en/Makefile defines where the
+   Note that the ``install`` target of ``doc/en/Makefile`` defines where the
    rsync goes to, typically to the "latest" section of pytest.org.
 
-11. publish to pypi "devpi push pytest-VERSION 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"
+   If you are making a minor release (e.g. 5.4), you also need to manually
+   create a symlink for "latest"::
 
-12. send release announcement to mailing lists:
+     ssh pytest-dev@pytest.org
+     ln -s 5.4 latest
 
-   pytest-dev
-   testing-in-python
-   python-announce-list@python.org
+   Browse to pytest.org to verify.
 
+11. Publish to pypi::
+
+      devpi push pytest-VERSION pypi:NAME
+
+   where NAME is the name of pypi.python.org as configured in your ``~/.pypirc``
+   file `for devpi <http://doc.devpi.net/latest/quickstart-releaseprocess.html?highlight=pypirc#devpi-push-releasing-to-an-external-index>`_.
+
+
+12. Send release announcement to mailing lists:
+
+    - pytest-dev
+    - testing-in-python
+    - python-announce-list@python.org
+
+
+13. **after the release** Bump the version number in ``_pytest/__init__.py``,
+   to the next Minor release version (i.e. if you released ``pytest-2.8.0``,
+   set it to ``pytest-2.9.0.dev1``).

Makefile

@@ -1,25 +0,0 @@
-# Set of targets useful for development/release process
-PYTHON = python2.7
-PATH := $(PWD)/.env/bin:$(PATH)
-
-# prepare virtual python environment
-.env:
-	virtualenv .env -p $(PYTHON)
-
-# install all needed for development
-develop: .env
-	pip install -e . tox -r requirements-docs.txt
-
-# clean the development envrironment
-clean:
-	-rm -rf .env
-
-# generate documentation
-docs: develop
-	find doc/en -name '*.txt' -not -path 'doc/en/_build/*' | xargs .env/bin/regendoc
-	cd doc/en; make html
-
-# upload documentation
-upload-docs: develop
-	find doc/en -name '*.txt' -not -path 'doc/en/_build/*' | xargs .env/bin/regendoc --update
-	cd doc/en; make install

README.rst

@@ -1,16 +1,27 @@
-.. image:: https://pypip.in/v/pytest/badge.png
+======
+pytest
+======
+
+The ``pytest`` testing tool makes it easy to write small tests, yet
+scales to support complex functional testing.
+
+.. image:: http://img.shields.io/pypi/v/pytest.svg
    :target: https://pypi.python.org/pypi/pytest
+.. image:: http://img.shields.io/coveralls/pytest-dev/pytest/master.svg
+   :target: https://coveralls.io/r/pytest-dev/pytest
+.. image:: https://travis-ci.org/pytest-dev/pytest.svg?branch=master
+    :target: https://travis-ci.org/pytest-dev/pytest
+.. image:: https://ci.appveyor.com/api/projects/status/mrgbjaua7t33pg6b?svg=true
+    :target: https://ci.appveyor.com/project/pytestbot/pytest
 
 Documentation: http://pytest.org/latest/
 
 Changelog: http://pytest.org/latest/changelog.html
 
-Issues: https://bitbucket.org/pytest-dev/pytest/issues?status=open
+Issues: https://github.com/pytest-dev/pytest/issues
 
-CI: https://drone.io/bitbucket.org/pytest-dev/pytest
-
-The ``pytest`` testing tool makes it easy to write small tests, yet
-scales to support complex functional testing.  It provides
+Features
+--------
 
 - `auto-discovery
   <http://pytest.org/latest/goodpractises.html#python-test-discovery>`_
@@ -22,12 +33,14 @@ scales to support complex functional testing.  It provides
   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)
+  Python3.5, 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::
+A simple example for a test:
+
+.. code-block:: python
 
     # content of test_module.py
     def test_function():
@@ -42,12 +55,12 @@ For much more info, including PDF docs, see
 
 and report bugs at:
 
-    http://bitbucket.org/pytest-dev/pytest/issues/
+    https://github.com/pytest-dev/pytest/issues
 
 and checkout or fork repo at:
 
-    http://bitbucket.org/pytest-dev/pytest/
+    https://github.com/pytest-dev/pytest
 
 
-Copyright Holger Krekel and others, 2004-2014
+Copyright Holger Krekel and others, 2004-2015
 Licensed under the MIT license.

_pytest/__init__.py

@@ -1,2 +1,2 @@
 #
-__version__ = '2.7.3'
+__version__ = '2.8.1'

_pytest/_pluggy.py

@@ -0,0 +1,11 @@
+"""
+imports symbols from vendored "pluggy" if available, otherwise
+falls back to importing "pluggy" from the default namespace.
+"""
+
+try:
+    from _pytest.vendored_packages.pluggy import *  # noqa
+    from _pytest.vendored_packages.pluggy import __version__  # noqa
+except ImportError:
+    from pluggy import *  # noqa
+    from pluggy import __version__  # noqa

_pytest/assertion/__init__.py

@@ -70,12 +70,11 @@ def pytest_configure(config):
     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 and hook in sys.meta_path:
-        sys.meta_path.remove(hook)
+    def undo():
+        hook = config._assertstate.hook
+        if hook is not None and hook in sys.meta_path:
+            sys.meta_path.remove(hook)
+    config.add_cleanup(undo)
 
 
 def pytest_collection(session):
@@ -115,8 +114,11 @@ def pytest_runtest_setup(item):
             if 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')]
+                    show_max = 10
+                    truncated_lines = len(new_expl) - show_max
+                    new_expl[show_max:] = [py.builtin._totext(
+                        'Detailed information truncated (%d more lines)'
+                        ', use "-vv" to show' % truncated_lines)]
                 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":

_pytest/assertion/rewrite.py

@@ -203,6 +203,12 @@ class AssertionRewritingHook(object):
         #  DefaultProvider is appropriate.
         pkg_resources.register_loader_type(cls, pkg_resources.DefaultProvider)
 
+    def get_data(self, pathname):
+        """Optional PEP302 get_data API.
+        """
+        with open(pathname, 'rb') as f:
+            return f.read()
+
 
 def _write_pyc(state, co, source_stat, pyc):
     # Technically, we don't have to have the same pyc format as

_pytest/assertion/util.py

@@ -129,7 +129,16 @@ def assertrepr_compare(config, op, left, right):
     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 = u('%s %s %s') % (left_repr, op, right_repr)
+
+    # the re-encoding is needed for python2 repr
+    # with non-ascii characters (see issue 877)
+    def ecu(s):
+        try:
+            return u(s, 'utf-8', 'replace')
+        except TypeError:
+            return s
+
+    summary = u('%s %s %s') % (ecu(left_repr), op, ecu(right_repr))
 
     issequence = lambda x: (isinstance(x, (list, tuple, Sequence))
                             and not isinstance(x, basestring))

_pytest/cacheprovider.py

@@ -0,0 +1,243 @@
+"""
+merged implementation of the cache provider
+
+the name cache was not choosen to ensure pluggy automatically
+ignores the external pytest-cache
+"""
+
+import py
+import pytest
+import json
+from os.path import sep as _sep, altsep as _altsep
+
+
+class Cache(object):
+    def __init__(self, config):
+        self.config = config
+        self._cachedir = config.rootdir.join(".cache")
+        self.trace = config.trace.root.get("cache")
+        if config.getvalue("cacheclear"):
+            self.trace("clearing cachedir")
+            if self._cachedir.check():
+                self._cachedir.remove()
+            self._cachedir.mkdir()
+
+    def makedir(self, name):
+        """ return a directory path object with the given name.  If the
+        directory does not yet exist, it will be created.  You can use it
+        to manage files likes e. g. store/retrieve database
+        dumps across test sessions.
+
+        :param name: must be a string not containing a ``/`` separator.
+             Make sure the name contains your plugin or application
+             identifiers to prevent clashes with other cache users.
+        """
+        if _sep in name or _altsep is not None and _altsep in name:
+            raise ValueError("name is not allowed to contain path separators")
+        return self._cachedir.ensure_dir("d", name)
+
+    def _getvaluepath(self, key):
+        return self._cachedir.join('v', *key.split('/'))
+
+    def get(self, key, default):
+        """ return cached value for the given key.  If no value
+        was yet cached or the value cannot be read, the specified
+        default is returned.
+
+        :param key: must be a ``/`` separated value. Usually the first
+             name is the name of your plugin or your application.
+        :param default: must be provided in case of a cache-miss or
+             invalid cache values.
+
+        """
+        path = self._getvaluepath(key)
+        if path.check():
+            try:
+                with path.open("r") as f:
+                    return json.load(f)
+            except ValueError:
+                self.trace("cache-invalid at %s" % (path,))
+        return default
+
+    def set(self, key, value):
+        """ save value for the given key.
+
+        :param key: must be a ``/`` separated value. Usually the first
+             name is the name of your plugin or your application.
+        :param value: must be of any combination of basic
+               python types, including nested types
+               like e. g. lists of dictionaries.
+        """
+        path = self._getvaluepath(key)
+        try:
+            path.dirpath().ensure_dir()
+        except (py.error.EEXIST, py.error.EACCES):
+            self.config.warn(
+                code='I9', message='could not create cache path %s' % (path,)
+            )
+            return
+        try:
+            f = path.open('w')
+        except py.error.ENOTDIR:
+            self.config.warn(
+                code='I9', message='cache could not write path %s' % (path,))
+        else:
+            with f:
+                self.trace("cache-write %s: %r" % (key, value,))
+                json.dump(value, f, indent=2, sort_keys=True)
+
+
+class LFPlugin:
+    """ Plugin which implements the --lf (run last-failing) option """
+    def __init__(self, config):
+        self.config = config
+        active_keys = 'lf', 'failedfirst'
+        self.active = any(config.getvalue(key) for key in active_keys)
+        if self.active:
+            self.lastfailed = config.cache.get("cache/lastfailed", {})
+        else:
+            self.lastfailed = {}
+
+    def pytest_report_header(self):
+        if self.active:
+            if not self.lastfailed:
+                mode = "run all (no recorded failures)"
+            else:
+                mode = "rerun last %d failures%s" % (
+                    len(self.lastfailed),
+                    " first" if self.config.getvalue("failedfirst") else "")
+            return "run-last-failure: %s" % mode
+
+    def pytest_runtest_logreport(self, report):
+        if report.failed and "xfail" not in report.keywords:
+            self.lastfailed[report.nodeid] = True
+        elif not report.failed:
+            if report.when == "call":
+                self.lastfailed.pop(report.nodeid, None)
+
+    def pytest_collectreport(self, report):
+        passed = report.outcome in ('passed', 'skipped')
+        if passed:
+            if report.nodeid in self.lastfailed:
+                self.lastfailed.pop(report.nodeid)
+                self.lastfailed.update(
+                    (item.nodeid, True)
+                    for item in report.result)
+        else:
+            self.lastfailed[report.nodeid] = True
+
+    def pytest_collection_modifyitems(self, session, config, items):
+        if self.active and self.lastfailed:
+            previously_failed = []
+            previously_passed = []
+            for item in items:
+                if item.nodeid in self.lastfailed:
+                    previously_failed.append(item)
+                else:
+                    previously_passed.append(item)
+            if not previously_failed and previously_passed:
+                # running a subset of all tests with recorded failures outside
+                # of the set of tests currently executing
+                pass
+            elif self.config.getvalue("failedfirst"):
+                items[:] = previously_failed + previously_passed
+            else:
+                items[:] = previously_failed
+                config.hook.pytest_deselected(items=previously_passed)
+
+    def pytest_sessionfinish(self, session):
+        config = self.config
+        if config.getvalue("cacheshow") or hasattr(config, "slaveinput"):
+            return
+        config.cache.set("cache/lastfailed", self.lastfailed)
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("general")
+    group.addoption(
+        '--lf', action='store_true', dest="lf",
+        help="rerun only the tests that failed "
+             "at the last run (or all if none failed)")
+    group.addoption(
+        '--ff', action='store_true', dest="failedfirst",
+        help="run all tests but run the last failures first.  "
+             "This may re-order tests and thus lead to "
+             "repeated fixture setup/teardown")
+    group.addoption(
+        '--cache-show', action='store_true', dest="cacheshow",
+        help="show cache contents, don't perform collection or tests")
+    group.addoption(
+        '--cache-clear', action='store_true', dest="cacheclear",
+        help="remove all cache contents at start of test run.")
+
+
+def pytest_cmdline_main(config):
+    if config.option.cacheshow:
+        from _pytest.main import wrap_session
+        return wrap_session(config, cacheshow)
+
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_configure(config):
+    config.cache = Cache(config)
+    config.pluginmanager.register(LFPlugin(config), "lfplugin")
+
+
+@pytest.fixture
+def cache(request):
+    """
+    Return a cache object that can persist state between testing sessions.
+
+    cache.get(key, default)
+    cache.set(key, value)
+
+    Keys must be strings not containing a "/" separator. Add a unique identifier
+    (such as plugin/app name) to avoid clashes with other cache users.
+
+    Values can be any object handled by the json stdlib module.
+    """
+    return request.config.cache
+
+
+def pytest_report_header(config):
+    if config.option.verbose:
+        relpath = py.path.local().bestrelpath(config.cache._cachedir)
+        return "cachedir: %s" % relpath
+
+
+def cacheshow(config, session):
+    from pprint import pprint
+    tw = py.io.TerminalWriter()
+    tw.line("cachedir: " + str(config.cache._cachedir))
+    if not config.cache._cachedir.check():
+        tw.line("cache is empty")
+        return 0
+    dummy = object()
+    basedir = config.cache._cachedir
+    vdir = basedir.join("v")
+    tw.sep("-", "cache values")
+    for valpath in vdir.visit(lambda x: x.isfile()):
+        key = valpath.relto(vdir).replace(valpath.sep, "/")
+        val = config.cache.get(key, dummy)
+        if val is dummy:
+            tw.line("%s contains unreadable content, "
+                  "will be ignored" % key)
+        else:
+            tw.line("%s contains:" % key)
+            stream = py.io.TextIO()
+            pprint(val, stream=stream)
+            for line in stream.getvalue().splitlines():
+                tw.line("  " + line)
+
+    ddir = basedir.join("d")
+    if ddir.isdir() and ddir.listdir():
+        tw.sep("-", "cache directories")
+        for p in basedir.join("d").visit():
+            #if p.check(dir=1):
+            #    print("%s/" % p.relto(basedir))
+            if p.isfile():
+                key = p.relto(basedir)
+                tw.line("%s is a file of length %d" % (
+                        key, p.size()))
+    return 0

_pytest/capture.py

@@ -29,7 +29,7 @@ def pytest_addoption(parser):
         help="shortcut for --capture=no.")
 
 
-@pytest.mark.hookwrapper
+@pytest.hookimpl(hookwrapper=True)
 def pytest_load_initial_conftests(early_config, parser, args):
     ns = early_config.known_args_namespace
     pluginmanager = early_config.pluginmanager
@@ -37,13 +37,13 @@ def pytest_load_initial_conftests(early_config, parser, args):
     pluginmanager.register(capman, "capturemanager")
 
     # make sure that capturemanager is properly reset at final shutdown
-    pluginmanager.add_shutdown(capman.reset_capturings)
+    early_config.add_cleanup(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)
+    early_config.add_cleanup(silence_logging_at_shutdown)
 
     # finally trigger conftest loading but while capturing (issue93)
     capman.init_capturings()
@@ -86,8 +86,10 @@ class CaptureManager:
         self.deactivate_funcargs()
         cap = getattr(self, "_capturing", None)
         if cap is not None:
-            outerr = cap.readouterr()
-            cap.suspend_capturing(in_=in_)
+            try:
+                outerr = cap.readouterr()
+            finally:
+                cap.suspend_capturing(in_=in_)
             return outerr
 
     def activate_funcargs(self, pyfuncitem):
@@ -101,7 +103,7 @@ class CaptureManager:
         if capfuncarg is not None:
             capfuncarg.close()
 
-    @pytest.mark.hookwrapper
+    @pytest.hookimpl(hookwrapper=True)
     def pytest_make_collect_report(self, collector):
         if isinstance(collector, pytest.File):
             self.resumecapture()
@@ -115,13 +117,13 @@ class CaptureManager:
         else:
             yield
 
-    @pytest.mark.hookwrapper
+    @pytest.hookimpl(hookwrapper=True)
     def pytest_runtest_setup(self, item):
         self.resumecapture()
         yield
         self.suspendcapture_item(item, "setup")
 
-    @pytest.mark.hookwrapper
+    @pytest.hookimpl(hookwrapper=True)
     def pytest_runtest_call(self, item):
         self.resumecapture()
         self.activate_funcargs(item)
@@ -129,24 +131,24 @@ class CaptureManager:
         #self.deactivate_funcargs() called from suspendcapture()
         self.suspendcapture_item(item, "call")
 
-    @pytest.mark.hookwrapper
+    @pytest.hookimpl(hookwrapper=True)
     def pytest_runtest_teardown(self, item):
         self.resumecapture()
         yield
         self.suspendcapture_item(item, "teardown")
 
-    @pytest.mark.tryfirst
+    @pytest.hookimpl(tryfirst=True)
     def pytest_keyboard_interrupt(self, excinfo):
         self.reset_capturings()
 
-    @pytest.mark.tryfirst
+    @pytest.hookimpl(tryfirst=True)
     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)
+        item.add_report_section(when, "stdout", out)
+        item.add_report_section(when, "stderr", err)
 
 error_capsysfderror = "cannot use capsys and capfd at the same time"
 

_pytest/config.py

@@ -8,11 +8,16 @@ 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.hookspec  # the extension point definitions
+from _pytest._pluggy import PluginManager, HookimplMarker, HookspecMarker
+
+hookimpl = HookimplMarker("pytest")
+hookspec = HookspecMarker("pytest")
 
 # pytest startup
 #
+
+
 class ConftestImportFailure(Exception):
     def __init__(self, path, excinfo):
         Exception.__init__(self, path, excinfo)
@@ -29,16 +34,24 @@ def main(args=None, plugins=None):
                   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)
+        try:
+            config = _prepareconfig(args, plugins)
+        except ConftestImportFailure as e:
+            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:
+            try:
+                config.pluginmanager.check_pending()
+                return config.hook.pytest_cmdline_main(config=config)
+            finally:
+                config._ensure_unconfigure()
+    except UsageError as e:
+        for msg in e.args:
+            sys.stderr.write("ERROR: %s\n" %(msg,))
         return 4
-    else:
-        return config.hook.pytest_cmdline_main(config=config)
 
 class cmdline:  # compatibility namespace
     main = staticmethod(main)
@@ -51,21 +64,36 @@ _preinit = []
 default_plugins = (
      "mark main terminal runner python pdb unittest capture skipping "
      "tmpdir monkeypatch recwarn pastebin helpconfig nose assertion genscript "
-     "junitxml resultlog doctest").split()
+     "junitxml resultlog doctest cacheprovider").split()
+
+builtin_plugins = set(default_plugins)
+builtin_plugins.add("pytester")
+
 
 def _preloadplugins():
     assert not _preinit
-    _preinit.append(get_plugin_manager())
+    _preinit.append(get_config())
 
-def get_plugin_manager():
+def get_config():
     if _preinit:
         return _preinit.pop(0)
     # subsequent calls to main will create a fresh instance
     pluginmanager = PytestPluginManager()
-    pluginmanager.config = Config(pluginmanager) # XXX attr needed?
+    config = Config(pluginmanager)
     for spec in default_plugins:
         pluginmanager.import_plugin(spec)
-    return pluginmanager
+    return config
+
+def get_plugin_manager():
+    """
+    Obtain a new instance of the
+    :py:class:`_pytest.config.PytestPluginManager`, with default plugins
+    already loaded.
+
+    This function can be used by integration with other tools, like hooking
+    into pytest to run tests into an IDE.
+    """
+    return get_config().pluginmanager
 
 def _prepareconfig(args=None, plugins=None):
     if args is None:
@@ -76,7 +104,8 @@ def _prepareconfig(args=None, plugins=None):
         if not isinstance(args, str):
             raise ValueError("not a string or argument list: %r" % (args,))
         args = shlex.split(args)
-    pluginmanager = get_plugin_manager()
+    config = get_config()
+    pluginmanager = config.pluginmanager
     try:
         if plugins:
             for plugin in plugins:
@@ -86,13 +115,31 @@ def _prepareconfig(args=None, plugins=None):
                     pluginmanager.register(plugin)
         return pluginmanager.hook.pytest_cmdline_parse(
                 pluginmanager=pluginmanager, args=args)
-    except Exception:
-        pluginmanager.ensure_shutdown()
+    except BaseException:
+        config._ensure_unconfigure()
         raise
 
+
 class PytestPluginManager(PluginManager):
-    def __init__(self, hookspecs=[hookspec]):
-        super(PytestPluginManager, self).__init__(hookspecs=hookspecs)
+    """
+    Overwrites :py:class:`pluggy.PluginManager` to add pytest-specific
+    functionality:
+
+    * loading plugins from the command line, ``PYTEST_PLUGIN`` env variable and
+      ``pytest_plugins`` global variables found in plugins being loaded;
+    * ``conftest.py`` loading during start-up;
+    """
+    def __init__(self):
+        super(PytestPluginManager, self).__init__("pytest", implprefix="pytest_")
+        self._conftest_plugins = set()
+
+        # state related to local conftest plugins
+        self._path2confmods = {}
+        self._conftestpath2mod = {}
+        self._confcutdir = None
+        self._noconftest = False
+
+        self.add_hookspecs(_pytest.hookspec)
         self.register(self)
         if os.environ.get('PYTEST_DEBUG'):
             err = sys.stderr
@@ -101,21 +148,259 @@ class PytestPluginManager(PluginManager):
                 err = py.io.dupfile(err, encoding=encoding)
             except Exception:
                 pass
-            self.set_tracing(err.write)
+            self.trace.root.setwriter(err.write)
+            self.enable_tracing()
+
+    def addhooks(self, module_or_class):
+        """
+        .. deprecated:: 2.8
+
+        Use :py:meth:`pluggy.PluginManager.add_hookspecs` instead.
+        """
+        warning = dict(code="I2",
+                       fslocation=py.code.getfslineno(sys._getframe(1)),
+                       nodeid=None,
+                       message="use pluginmanager.add_hookspecs instead of "
+                               "deprecated addhooks() method.")
+        self._warn(warning)
+        return self.add_hookspecs(module_or_class)
+
+    def parse_hookimpl_opts(self, plugin, name):
+        # pytest hooks are always prefixed with pytest_
+        # so we avoid accessing possibly non-readable attributes
+        # (see issue #1073)
+        if not name.startswith("pytest_"):
+            return
+        # ignore some historic special names which can not be hooks anyway
+        if name == "pytest_plugins" or name.startswith("pytest_funcarg__"):
+            return
+
+        method = getattr(plugin, name)
+        opts = super(PytestPluginManager, self).parse_hookimpl_opts(plugin, name)
+        if opts is not None:
+            for name in ("tryfirst", "trylast", "optionalhook", "hookwrapper"):
+                opts.setdefault(name, hasattr(method, name))
+        return opts
+
+    def parse_hookspec_opts(self, module_or_class, name):
+        opts = super(PytestPluginManager, self).parse_hookspec_opts(
+                                                module_or_class, name)
+        if opts is None:
+            method = getattr(module_or_class, name)
+            if name.startswith("pytest_"):
+                opts = {"firstresult": hasattr(method, "firstresult"),
+                        "historic": hasattr(method, "historic")}
+        return opts
+
+    def _verify_hook(self, hook, hookmethod):
+        super(PytestPluginManager, self)._verify_hook(hook, hookmethod)
+        if "__multicall__" in hookmethod.argnames:
+            fslineno = py.code.getfslineno(hookmethod.function)
+            warning = dict(code="I1",
+                           fslocation=fslineno,
+                           nodeid=None,
+                           message="%r hook uses deprecated __multicall__ "
+                                   "argument" % (hook.name))
+            self._warn(warning)
+
+    def register(self, plugin, name=None):
+        ret = super(PytestPluginManager, self).register(plugin, name)
+        if ret:
+            self.hook.pytest_plugin_registered.call_historic(
+                      kwargs=dict(plugin=plugin, manager=self))
+        return ret
+
+    def getplugin(self, name):
+        # support deprecated naming because plugins (xdist e.g.) use it
+        return self.get_plugin(name)
+
+    def hasplugin(self, name):
+        """Return True if the plugin with the given name is registered."""
+        return bool(self.get_plugin(name))
 
     def pytest_configure(self, config):
+        # XXX now that the pluginmanager exposes hookimpl(tryfirst...)
+        # we should remove tryfirst/trylast as markers
         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 _warn(self, message):
+        kwargs = message if isinstance(message, dict) else {
+            'code': 'I1',
+            'message': message,
+            'fslocation': None,
+            'nodeid': None,
+        }
+        self.hook.pytest_logwarning.call_historic(kwargs=kwargs)
+
+    #
+    # internal API for local conftest plugin handling
+    #
+    def _set_initial_conftests(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()
+        self._confcutdir = current.join(namespace.confcutdir, abs=True) \
+                                if namespace.confcutdir else None
+        self._noconftest = namespace.noconftest
+        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):
+        if self._noconftest:
+            return []
+        try:
+            return self._path2confmods[path]
+        except KeyError:
+            if path.isfile():
+                clist = self._getconftestmodules(path.dirpath())
+            else:
+                # XXX these days we may rather want to use config.rootdir
+                # and allow users to opt into looking into the rootdir parent
+                # directories instead of requiring to specify confcutdir
+                clist = []
+                for parent in path.parts():
+                    if self._confcutdir and self._confcutdir.relto(parent):
+                        continue
+                    conftestpath = parent.join("conftest.py")
+                    if conftestpath.isfile():
+                        mod = self._importconftest(conftestpath)
+                        clist.append(mod)
+
+            self._path2confmods[path] = clist
+            return clist
+
+    def _rget_with_confmod(self, name, path):
+        modules = self._getconftestmodules(path)
+        for mod in reversed(modules):
+            try:
+                return mod, getattr(mod, name)
+            except AttributeError:
+                continue
+        raise KeyError(name)
+
+    def _importconftest(self, conftestpath):
+        try:
+            return self._conftestpath2mod[conftestpath]
+        except KeyError:
+            pkgpath = conftestpath.pypkgpath()
+            if pkgpath is None:
+                _ensure_removed_sysmodule(conftestpath.purebasename)
+            try:
+                mod = conftestpath.pyimport()
+            except Exception:
+                raise ConftestImportFailure(conftestpath, sys.exc_info())
+
+            self._conftest_plugins.add(mod)
+            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.trace("loaded conftestmodule %r" %(mod))
+            self.consider_conftest(mod)
+            return mod
+
+    #
+    # API for bootstrapping plugin loading
+    #
+    #
+
+    def consider_preparse(self, args):
+        for opt1,opt2 in zip(args, args[1:]):
+            if opt1 == "-p":
+                self.consider_pluginarg(opt2)
+
+    def consider_pluginarg(self, arg):
+        if arg.startswith("no:"):
+            name = arg[3:]
+            self.set_blocked(name)
+            if not name.startswith("pytest_"):
+                self.set_blocked("pytest_" + name)
+        else:
+            self.import_plugin(arg)
+
+    def consider_conftest(self, conftestmodule):
+        if self.register(conftestmodule, name=conftestmodule.__file__):
+            self.consider_module(conftestmodule)
+
+    def consider_env(self):
+        self._import_plugin_specs(os.environ.get("PYTEST_PLUGINS"))
+
+    def consider_module(self, mod):
+        self._import_plugin_specs(getattr(mod, "pytest_plugins", None))
+
+    def _import_plugin_specs(self, spec):
+        if spec:
+            if isinstance(spec, str):
+                spec = spec.split(",")
+            for import_spec in spec:
+                self.import_plugin(import_spec)
+
+    def import_plugin(self, modname):
+        # most often modname refers to builtin modules, e.g. "pytester",
+        # "terminal" or "capture".  Those plugins are registered under their
+        # basename for historic purposes but must be imported with the
+        # _pytest prefix.
+        assert isinstance(modname, str)
+        if self.get_plugin(modname) is not None:
+            return
+        if modname in builtin_plugins:
+            importspec = "_pytest." + modname
+        else:
+            importspec = modname
+        try:
+            __import__(importspec)
+        except ImportError:
+            raise
+        except Exception as e:
+            import pytest
+            if not hasattr(pytest, 'skip') or not isinstance(e, pytest.skip.Exception):
+                raise
+            self._warn("skipped plugin %r: %s" %((modname, e.msg)))
+        else:
+            mod = sys.modules[importspec]
+            self.register(mod, modname)
+            self.consider_module(mod)
 
 
 class Parser:
-    """ Parser for command line arguments and ini-file values.  """
+    """ Parser for command line arguments and ini-file values.
+
+    :ivar extra_info: dict of generic param -> value to display in case
+        there's an error processing the command line arguments.
+    """
 
     def __init__(self, usage=None, processopt=None):
         self._anonymous = OptionGroup("custom options", parser=self)
@@ -124,6 +409,7 @@ class Parser:
         self._usage = usage
         self._inidict = {}
         self._ininames = []
+        self.extra_info = {}
 
     def processoption(self, option):
         if self._processopt:
@@ -177,7 +463,7 @@ class Parser:
 
     def _getparser(self):
         from _pytest._argcomplete import filescompleter
-        optparser = MyOptionParser(self)
+        optparser = MyOptionParser(self, self.extra_info)
         groups = self._groups + [self._anonymous]
         for group in groups:
             if group.options:
@@ -198,9 +484,18 @@ class Parser:
         return getattr(parsedoption, FILE_OR_DIR)
 
     def parse_known_args(self, args):
+        """parses and returns a namespace object with known arguments at this
+        point.
+        """
+        return self.parse_known_and_unknown_args(args)[0]
+
+    def parse_known_and_unknown_args(self, args):
+        """parses and returns a namespace object with known arguments, and
+        the remaining arguments unknown at this point.
+        """
         optparser = self._getparser()
         args = [str(x) for x in args]
-        return optparser.parse_known_args(args)[0]
+        return optparser.parse_known_args(args)
 
     def addini(self, name, help, type=None, default=None):
         """ register an ini-file option.
@@ -402,10 +697,15 @@ class OptionGroup:
 
 
 class MyOptionParser(argparse.ArgumentParser):
-    def __init__(self, parser):
+    def __init__(self, parser, extra_info=None):
+        if not extra_info:
+            extra_info = {}
         self._parser = parser
         argparse.ArgumentParser.__init__(self, usage=parser._usage,
             add_help=False, formatter_class=DropShorterLongHelpFormatter)
+        # extra_info is a dict of (param -> value) to display if there's
+        # an usage error to provide more contextual information to the user
+        self.extra_info = extra_info
 
     def parse_args(self, args=None, namespace=None):
         """allow splitting of positional arguments"""
@@ -413,11 +713,14 @@ class MyOptionParser(argparse.ArgumentParser):
         if argv:
             for arg in argv:
                 if arg and arg[0] == '-':
-                    msg = argparse._('unrecognized arguments: %s')
-                    self.error(msg % ' '.join(argv))
+                    lines = ['unrecognized arguments: %s' % (' '.join(argv))]
+                    for k, v in sorted(self.extra_info.items()):
+                        lines.append('  %s: %s' % (k, v))
+                    self.error('\n'.join(lines))
             getattr(args, FILE_OR_DIR).extend(argv)
         return args
 
+
 class DropShorterLongHelpFormatter(argparse.HelpFormatter):
     """shorten help for long options that differ only in extra hyphens
 
@@ -467,96 +770,6 @@ class DropShorterLongHelpFormatter(argparse.HelpFormatter):
         return action._formatted_action_invocation
 
 
-class Conftest(object):
-    """ the single place for accessing values and interacting
-        towards conftest modules from pytest objects.
-    """
-    def __init__(self, onimport=None):
-        self._path2confmods = {}
-        self._onimport = onimport
-        self._conftestpath2mod = {}
-        self._confcutdir = None
-
-    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()
-        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):
-        try:
-            return self._path2confmods[path]
-        except KeyError:
-            clist = []
-            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
-            return clist
-
-    def rget_with_confmod(self, name, path):
-        modules = self.getconftestmodules(path)
-        for mod in reversed(modules):
-            try:
-                return mod, getattr(mod, name)
-            except AttributeError:
-                continue
-        raise KeyError(name)
-
-    def importconftest(self, conftestpath):
-        try:
-            return self._conftestpath2mod[conftestpath]
-        except KeyError:
-            pkgpath = conftestpath.pypkgpath()
-            if pkgpath is None:
-                _ensure_removed_sysmodule(conftestpath.purebasename)
-            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)
-            if self._onimport:
-                self._onimport(mod)
-            return mod
-
 
 def _ensure_removed_sysmodule(modname):
     try:
@@ -577,6 +790,7 @@ class Notset:
 
 notset = Notset()
 FILE_OR_DIR = 'file_or_dir'
+
 class Config(object):
     """ access to configuration values, pluginmanager and plugin hooks.  """
 
@@ -592,58 +806,52 @@ class Config(object):
         #: a pluginmanager instance
         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._warn = self.pluginmanager._warn
         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:
+        def do_setns(dic):
             import pytest
             setns(pytest, dic)
-        call_plugin(plugin, "pytest_addoption", {'parser': self._parser})
-        if self._configured:
-            call_plugin(plugin, "pytest_configure", {'config': self})
+        self.hook.pytest_namespace.call_historic(do_setns, {})
+        self.hook.pytest_addoption.call_historic(kwargs=dict(parser=self._parser))
 
-    def do_configure(self):
+    def add_cleanup(self, func):
+        """ Add a function to be called when the config object gets out of
+        use (usually coninciding with pytest_unconfigure)."""
+        self._cleanup.append(func)
+
+    def _do_configure(self):
         assert not self._configured
         self._configured = True
-        self.hook.pytest_configure(config=self)
+        self.hook.pytest_configure.call_historic(kwargs=dict(config=self))
 
-    def do_unconfigure(self):
-        assert self._configured
-        self._configured = False
-        self.hook.pytest_unconfigure(config=self)
-        self.pluginmanager.ensure_shutdown()
+    def _ensure_unconfigure(self):
+        if self._configured:
+            self._configured = False
+            self.hook.pytest_unconfigure(config=self)
+            self.hook.pytest_configure._call_history = []
+        while self._cleanup:
+            fin = self._cleanup.pop()
+            fin()
 
-    def warn(self, code, message):
+    def warn(self, code, message, fslocation=None):
         """ generate a warning for this test session. """
-        self.hook.pytest_logwarning(code=code, message=message,
-                                    fslocation=None, nodeid=None)
+        self.hook.pytest_logwarning.call_historic(kwargs=dict(
+            code=code, message=message,
+            fslocation=fslocation, nodeid=None))
 
     def get_terminal_writer(self):
-        return self.pluginmanager.getplugin("terminalreporter")._tw
+        return self.pluginmanager.get_plugin("terminalreporter")._tw
 
     def pytest_cmdline_parse(self, pluginmanager, args):
-        assert self == pluginmanager.config, (self, pluginmanager.config)
+        # REF1 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"
@@ -670,18 +878,13 @@ class Config(object):
     @classmethod
     def fromdictargs(cls, option_dict, args):
         """ constructor useable for subprocesses. """
-        pluginmanager = get_plugin_manager()
-        config = pluginmanager.config
+        config = get_config()
         config._preparse(args, addopts=False)
         config.option.__dict__.update(option_dict)
         for x in config.option.plugins:
             config.pluginmanager.consider_pluginarg(x)
         return config
 
-    def _onimportconftest(self, conftestmodule):
-        self.trace("loaded conftestmodule %r" %(conftestmodule,))
-        self.pluginmanager.consider_conftest(conftestmodule)
-
     def _processopt(self, opt):
         for name in opt._short_opts + opt._long_opts:
             self._opt2dest[name] = opt.dest
@@ -690,18 +893,16 @@ class Config(object):
             if not hasattr(self.option, opt.dest):
                 setattr(self.option, opt.dest, opt.default)
 
-    def _getmatchingplugins(self, fspath):
-        return self.pluginmanager._plugins + \
-               self._conftest.getconftestmodules(fspath)
-
+    @hookimpl(trylast=True)
     def pytest_load_initial_conftests(self, early_config):
-        self._conftest.setinitial(early_config.known_args_namespace)
-    pytest_load_initial_conftests.trylast = True
+        self.pluginmanager._set_initial_conftests(early_config.known_args_namespace)
 
     def _initini(self, args):
-        parsed_args = self._parser.parse_known_args(args)
-        r = determine_setup(parsed_args.inifilename, parsed_args.file_or_dir)
+        ns, unknown_args = self._parser.parse_known_and_unknown_args(args)
+        r = determine_setup(ns.inifilename, ns.file_or_dir + unknown_args)
         self.rootdir, self.inifile, self.inicfg = r
+        self._parser.extra_info['rootdir'] = self.rootdir
+        self._parser.extra_info['inifile'] = self.inifile
         self.invocation_dir = py.path.local()
         self._parser.addini('addopts', 'extra command line options', 'args')
         self._parser.addini('minversion', 'minimally required pytest version')
@@ -713,9 +914,15 @@ class Config(object):
             args[:] = self.getini("addopts") + args
         self._checkversion()
         self.pluginmanager.consider_preparse(args)
-        self.pluginmanager.consider_setuptools_entrypoints()
+        try:
+            self.pluginmanager.load_setuptools_entrypoints("pytest11")
+        except ImportError as e:
+            self.warn("I2", "could not load setuptools entry import: %s" % (e,))
         self.pluginmanager.consider_env()
         self.known_args_namespace = ns = self._parser.parse_known_args(args)
+        if self.known_args_namespace.confcutdir is None and self.inifile:
+            confcutdir = py.path.local(self.inifile).dirname
+            self.known_args_namespace.confcutdir = confcutdir
         try:
             self.hook.pytest_load_initial_conftests(early_config=self,
                     args=args, parser=self._parser)
@@ -724,8 +931,7 @@ class Config(object):
             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)
+                self._warn("could not load initial conftests (%s)\n" % e.path)
             else:
                 raise
 
@@ -746,12 +952,18 @@ class Config(object):
         assert not hasattr(self, 'args'), (
                 "can only parse cmdline args at most once per Config object")
         self._origargs = args
+        self.hook.pytest_addhooks.call_historic(
+                                  kwargs=dict(pluginmanager=self.pluginmanager))
         self._preparse(args)
         # 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(os.getcwd())
+            cwd = os.getcwd()
+            if cwd == self.rootdir:
+                args = self.getini('testpaths')
+            if not args:
+                args = [cwd]
         self.args = args
 
     def addinivalue_line(self, name, line):
@@ -802,7 +1014,7 @@ class Config(object):
 
     def _getconftest_pathlist(self, name, path):
         try:
-            mod, relroots = self._conftest.rget_with_confmod(name, path)
+            mod, relroots = self.pluginmanager._rget_with_confmod(name, path)
         except KeyError:
             return None
         modpath = py.path.local(mod.__file__).dirpath()

_pytest/core.py

@@ -1,543 +0,0 @@
-"""
-pytest PluginManager, basic initialization and tracing.
-"""
-import os
-import sys
-import inspect
-import py
-# 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__))
-
-py3 = sys.version_info > (3,0)
-
-class TagTracer:
-    def __init__(self):
-        self._tag2proc = {}
-        self.writer = None
-        self.indent = 0
-
-    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 and args:
-            lines = self.format_message(tags, args)
-            self.writer(''.join(lines))
-        try:
-            self._tag2proc[tags](tags, args)
-        except KeyError:
-            pass
-
-    def setwriter(self, writer):
-        self.writer = writer
-
-    def setprocessor(self, tags, processor):
-        if isinstance(tags, str):
-            tags = tuple(tags.split(":"))
-        else:
-            assert isinstance(tags, tuple)
-        self._tag2proc[tags] = processor
-
-class TagTracerSub:
-    def __init__(self, root, tags):
-        self.root = root
-        self.tags = tags
-    def __call__(self, *args):
-        self.root.processmessage(self.tags, args)
-    def setmyprocessor(self, processor):
-        self.root.setprocessor(self.tags, processor)
-    def get(self, name):
-        return self.__class__(self.root, self.tags + (name,))
-
-
-def add_method_wrapper(cls, wrapper_func):
-    """ Substitute the function named "wrapperfunc.__name__" at class
-    "cls" with a function that wraps the call to the original function.
-    Return an undo function which can be called to reset the class to use
-    the old method again.
-
-    wrapper_func is called with the same arguments as the method
-    it wraps and its result is used as a wrap_controller for
-    calling the original function.
-    """
-    name = wrapper_func.__name__
-    oldcall = getattr(cls, name)
-    def wrap_exec(*args, **kwargs):
-        gen = wrapper_func(*args, **kwargs)
-        return wrapped_call(gen, lambda: oldcall(*args, **kwargs))
-
-    setattr(cls, name, wrap_exec)
-    return lambda: setattr(cls, name, oldcall)
-
-def raise_wrapfail(wrap_controller, msg):
-    co = wrap_controller.gi_code
-    raise RuntimeError("wrap_controller at %r %s:%d %s" %
-                   (co.co_name, co.co_filename, co.co_firstlineno, msg))
-
-def wrapped_call(wrap_controller, func):
-    """ Wrap calling to a function with a generator which needs to yield
-    exactly once.  The yield point will trigger calling the wrapped function
-    and return its CallOutcome to the yield point.  The generator then needs
-    to finish (raise StopIteration) in order for the wrapped call to complete.
-    """
-    try:
-        next(wrap_controller)   # first yield
-    except StopIteration:
-        raise_wrapfail(wrap_controller, "did not yield")
-    call_outcome = CallOutcome(func)
-    try:
-        wrap_controller.send(call_outcome)
-        raise_wrapfail(wrap_controller, "has second yield")
-    except StopIteration:
-        pass
-    return call_outcome.get_result()
-
-
-class CallOutcome:
-    """ Outcome of a function call, either an exception or a proper result.
-    Calling the ``get_result`` method will return the result or reraise
-    the exception raised when the function was called. """
-    excinfo = None
-    def __init__(self, func):
-        try:
-            self.result = func()
-        except BaseException:
-            self.excinfo = sys.exc_info()
-
-    def force_result(self, result):
-        self.result = result
-        self.excinfo = None
-
-    def get_result(self):
-        if self.excinfo is None:
-            return self.result
-        else:
-            ex = self.excinfo
-            if py3:
-                raise ex[1].with_traceback(ex[2])
-            py.builtin._reraise(*ex)
-
-
-class PluginManager(object):
-    def __init__(self, hookspecs=None, prefix="pytest_"):
-        self._name2plugin = {}
-        self._plugins = []
-        self._conftestplugins = []
-        self._plugin2hookcallers = {}
-        self._warnings = []
-        self.trace = TagTracer().get("pluginmanage")
-        self._plugin_distinfo = []
-        self._shutdown = []
-        self.hook = HookRelay(hookspecs or [], pm=self, prefix=prefix)
-
-    def set_tracing(self, writer):
-        self.trace.root.setwriter(writer)
-        # reconfigure HookCalling to perform tracing
-        assert not hasattr(self, "_wrapping")
-        self._wrapping = True
-
-        def _docall(self, methods, kwargs):
-            trace = self.hookrelay.trace
-            trace.root.indent += 1
-            trace(self.name, kwargs)
-            box = yield
-            if box.excinfo is None:
-                trace("finish", self.name, "-->", box.result)
-            trace.root.indent -= 1
-
-        undo = add_method_wrapper(HookCaller, _docall)
-        self.add_shutdown(undo)
-
-    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, conftest=False):
-        if self._name2plugin.get(name, None) == -1:
-            return
-        name = name or getattr(plugin, '__name__', str(id(plugin)))
-        if self.isregistered(plugin, name):
-            raise ValueError("Plugin already registered: %s=%s\n%s" %(
-                              name, plugin, self._name2plugin))
-        #self.trace("registering", name, plugin)
-        reg = getattr(self, "_registercallback", None)
-        if reg is not None:
-            reg(plugin, name)  # may call addhooks
-        hookcallers = list(self.hook._scan_plugin(plugin))
-        self._plugin2hookcallers[plugin] = hookcallers
-        self._name2plugin[name] = plugin
-        if conftest:
-            self._conftestplugins.append(plugin)
-        else:
-            if not prepend:
-                self._plugins.append(plugin)
-            else:
-                self._plugins.insert(0, plugin)
-        # finally make sure that the methods of the new plugin take part
-        for hookcaller in hookcallers:
-            hookcaller.scan_methods()
-        return True
-
-    def unregister(self, plugin):
-        try:
-            self._plugins.remove(plugin)
-        except KeyError:
-            self._conftestplugins.remove(plugin)
-        for name, value in list(self._name2plugin.items()):
-            if value == plugin:
-                del self._name2plugin[name]
-        hookcallers = self._plugin2hookcallers.pop(plugin)
-        for hookcaller in hookcallers:
-            hookcaller.scan_methods()
-
-    def add_shutdown(self, func):
-        self._shutdown.append(func)
-
-    def ensure_shutdown(self):
-        while self._shutdown:
-            func = self._shutdown.pop()
-            func()
-        self._plugins = self._conftestplugins = []
-        self._name2plugin.clear()
-
-    def isregistered(self, plugin, name=None):
-        if self.getplugin(name) is not None:
-            return True
-        return plugin in self._plugins or plugin in self._conftestplugins
-
-    def addhooks(self, spec, prefix="pytest_"):
-        self.hook._addhooks(spec, prefix=prefix)
-
-    def getplugins(self):
-        return self._plugins + self._conftestplugins
-
-    def skipifmissing(self, name):
-        if not self.hasplugin(name):
-            import pytest
-            pytest.skip("plugin %r is missing" % name)
-
-    def hasplugin(self, name):
-        return bool(self.getplugin(name))
-
-    def getplugin(self, name):
-        if name is None:
-            return None
-        try:
-            return self._name2plugin[name]
-        except KeyError:
-            return self._name2plugin.get("_pytest." + name, None)
-
-    # API for bootstrapping
-    #
-    def _envlist(self, varname):
-        val = os.environ.get(varname, None)
-        if val is not None:
-            return val.split(',')
-        return ()
-
-    def consider_env(self):
-        for spec in self._envlist("PYTEST_PLUGINS"):
-            self.import_plugin(spec)
-
-    def consider_setuptools_entrypoints(self):
-        try:
-            from pkg_resources import iter_entry_points, DistributionNotFound
-        except ImportError:
-            return # XXX issue a warning
-        for ep in iter_entry_points('pytest11'):
-            name = ep.name
-            if name.startswith("pytest_"):
-                name = name[7:]
-            if ep.name in self._name2plugin or name in self._name2plugin:
-                continue
-            try:
-                plugin = ep.load()
-            except DistributionNotFound:
-                continue
-            self._plugin_distinfo.append((ep.dist, plugin))
-            self.register(plugin, name=name)
-
-    def consider_preparse(self, args):
-        for opt1,opt2 in zip(args, args[1:]):
-            if opt1 == "-p":
-                self.consider_pluginarg(opt2)
-
-    def consider_pluginarg(self, arg):
-        if arg.startswith("no:"):
-            name = arg[3:]
-            plugin = self.getplugin(name)
-            if plugin is not None:
-                self.unregister(plugin)
-            self._name2plugin[name] = -1
-        else:
-            if self.getplugin(arg) is None:
-                self.import_plugin(arg)
-
-    def consider_conftest(self, conftestmodule):
-        if self.register(conftestmodule, name=conftestmodule.__file__,
-                         conftest=True):
-            self.consider_module(conftestmodule)
-
-    def consider_module(self, mod):
-        attr = getattr(mod, "pytest_plugins", ())
-        if attr:
-            if not isinstance(attr, (list, tuple)):
-                attr = (attr,)
-            for spec in attr:
-                self.import_plugin(spec)
-
-    def import_plugin(self, modname):
-        assert isinstance(modname, str)
-        if self.getplugin(modname) is not None:
-            return
-        try:
-            mod = importplugin(modname)
-        except KeyboardInterrupt:
-            raise
-        except ImportError:
-            if modname.startswith("pytest_"):
-                return self.import_plugin(modname[7:])
-            raise
-        except:
-            e = sys.exc_info()[1]
-            import pytest
-            if not hasattr(pytest, 'skip') or not isinstance(e, pytest.skip.Exception):
-                raise
-            self._warnings.append("skipped plugin %r: %s" %((modname, e.msg)))
-        else:
-            self.register(mod, modname)
-            self.consider_module(mod)
-
-    def listattr(self, attrname, plugins=None):
-        if plugins is None:
-            plugins = self._plugins + self._conftestplugins
-        l = []
-        last = []
-        wrappers = []
-        for plugin in plugins:
-            try:
-                meth = getattr(plugin, attrname)
-            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)
-        return l
-
-    def call_plugin(self, plugin, methname, kwargs):
-        return MultiCall(methods=self.listattr(methname, plugins=[plugin]),
-                kwargs=kwargs, firstresult=True).execute()
-
-
-def importplugin(importspec):
-    name = importspec
-    try:
-        mod = "_pytest." + name
-        __import__(mod)
-        return sys.modules[mod]
-    except ImportError:
-        __import__(importspec)
-        return sys.modules[importspec]
-
-class MultiCall:
-    """ execute a call into multiple python functions/methods. """
-
-    def __init__(self, methods, kwargs, firstresult=False):
-        self.methods = list(methods)
-        self.kwargs = kwargs
-        self.kwargs["__multicall__"] = self
-        self.results = []
-        self.firstresult = firstresult
-
-    def __repr__(self):
-        status = "%d results, %d meths" % (len(self.results), len(self.methods))
-        return "<MultiCall %s, kwargs=%r>" %(status, self.kwargs)
-
-    def execute(self):
-        all_kwargs = self.kwargs
-        while self.methods:
-            method = self.methods.pop()
-            args = [all_kwargs[argname] for argname in varnames(method)]
-            if hasattr(method, "hookwrapper"):
-                return wrapped_call(method(*args), self.execute)
-            res = method(*args)
-            if res is not None:
-                self.results.append(res)
-                if self.firstresult:
-                    return res
-        if not self.firstresult:
-            return self.results
-
-
-def varnames(func, startindex=None):
-    """ 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 cache["_varnames"]
-    except KeyError:
-        pass
-    if inspect.isclass(func):
-        try:
-            func = func.__init__
-        except AttributeError:
-            return ()
-        startindex = 1
-    else:
-        if not inspect.isfunction(func) and not inspect.ismethod(func):
-            func = getattr(func, '__call__', func)
-        if startindex is None:
-            startindex = int(inspect.ismethod(func))
-
-    rawcode = py.code.getrawcode(func)
-    try:
-        x = rawcode.co_varnames[startindex:rawcode.co_argcount]
-    except AttributeError:
-        x = ()
-    else:
-        defaults = func.__defaults__
-        if defaults:
-            x = x[:-len(defaults)]
-    try:
-        cache["_varnames"] = x
-    except TypeError:
-        pass
-    return x
-
-
-class HookRelay:
-    def __init__(self, hookspecs, pm, prefix="pytest_"):
-        if not isinstance(hookspecs, list):
-            hookspecs = [hookspecs]
-        self._pm = pm
-        self.trace = pm.trace.root.get("hook")
-        self.prefix = prefix
-        for hookspec in hookspecs:
-            self._addhooks(hookspec, prefix)
-
-    def _addhooks(self, hookspec, prefix):
-        added = False
-        isclass = int(inspect.isclass(hookspec))
-        for name, method in vars(hookspec).items():
-            if name.startswith(prefix):
-                firstresult = getattr(method, 'firstresult', False)
-                hc = HookCaller(self, name, firstresult=firstresult,
-                                argnames=varnames(method, startindex=isclass))
-                setattr(self, name, hc)
-                added = True
-                #print ("setting new hook", name)
-        if not added:
-            raise ValueError("did not find new %r hooks in %r" %(
-                prefix, hookspec,))
-
-    def _getcaller(self, name, plugins):
-        caller = getattr(self, name)
-        methods = self._pm.listattr(name, plugins=plugins)
-        if methods:
-            return caller.new_cached_caller(methods)
-        return caller
-
-    def _scan_plugin(self, plugin):
-        def fail(msg, *args):
-            name = getattr(plugin, '__name__', plugin)
-            raise PluginValidationError("plugin %r\n%s" %(name, msg % args))
-
-        for name in dir(plugin):
-            if not name.startswith(self.prefix):
-                continue
-            hook = getattr(self, name, None)
-            method = getattr(plugin, name)
-            if hook is None:
-                is_optional = getattr(method, 'optionalhook', False)
-                if not isgenerichook(name) and not is_optional:
-                    fail("found unknown hook: %r", name)
-                continue
-            for arg in varnames(method):
-                if arg not in hook.argnames:
-                    fail("argument %r not available\n"
-                         "actual definition: %s\n"
-                         "available hookargs: %s",
-                         arg, formatdef(method),
-                           ", ".join(hook.argnames))
-            yield hook
-
-
-class HookCaller:
-    def __init__(self, hookrelay, name, firstresult, argnames, methods=()):
-        self.hookrelay = hookrelay
-        self.name = name
-        self.firstresult = firstresult
-        self.argnames = ["__multicall__"]
-        self.argnames.extend(argnames)
-        assert "self" not in argnames  # sanity check
-        self.methods = methods
-
-    def new_cached_caller(self, methods):
-        return HookCaller(self.hookrelay, self.name, self.firstresult,
-                          argnames=self.argnames, methods=methods)
-
-    def __repr__(self):
-        return "<HookCaller %r>" %(self.name,)
-
-    def scan_methods(self):
-        self.methods = self.hookrelay._pm.listattr(self.name)
-
-    def __call__(self, **kwargs):
-        return self._docall(self.methods, kwargs)
-
-    def callextra(self, methods, **kwargs):
-        return self._docall(self.methods + methods, kwargs)
-
-    def _docall(self, methods, kwargs):
-        return MultiCall(methods, kwargs,
-                         firstresult=self.firstresult).execute()
-
-
-class PluginValidationError(Exception):
-    """ plugin failed validation. """
-
-def isgenerichook(name):
-    return name == "pytest_plugins" or \
-           name.startswith("pytest_funcarg__")
-
-def formatdef(func):
-    return "%s%s" % (
-        func.__name__,
-        inspect.formatargspec(*inspect.getargspec(func))
-    )
-

_pytest/doctest.py

@@ -2,7 +2,7 @@
 from __future__ import absolute_import
 import traceback
 import pytest, py
-from _pytest.python import FixtureRequest, FuncFixtureInfo
+from _pytest.python import FixtureRequest
 from py._code.code import TerminalRepr, ReprFileLocation
 
 def pytest_addoption(parser):
@@ -47,6 +47,7 @@ class DoctestItem(pytest.Item):
         self.dtest = dtest
 
     def runtest(self):
+        _check_all_skipped(self.dtest)
         self.runner.run(self.dtest)
 
     def repr_failure(self, excinfo):
@@ -63,7 +64,7 @@ class DoctestItem(pytest.Item):
                 lineno = test.lineno + example.lineno + 1
             message = excinfo.type.__name__
             reprlocation = ReprFileLocation(filename, lineno, message)
-            checker = doctest.OutputChecker()
+            checker = _get_unicode_checker()
             REPORT_UDIFF = doctest.REPORT_UDIFF
             filelines = py.path.local(filename).readlines(cr=0)
             lines = []
@@ -100,7 +101,8 @@ def _get_flag_lookup():
                 NORMALIZE_WHITESPACE=doctest.NORMALIZE_WHITESPACE,
                 ELLIPSIS=doctest.ELLIPSIS,
                 IGNORE_EXCEPTION_DETAIL=doctest.IGNORE_EXCEPTION_DETAIL,
-                COMPARISON_FLAGS=doctest.COMPARISON_FLAGS)
+                COMPARISON_FLAGS=doctest.COMPARISON_FLAGS,
+                ALLOW_UNICODE=_get_allow_unicode_flag())
 
 def get_optionflags(parent):
     optionflags_str = parent.config.getini("doctest_optionflags")
@@ -110,29 +112,47 @@ def get_optionflags(parent):
         flag_acc |= flag_lookup_table[flag]
     return flag_acc
 
+
 class DoctestTextfile(DoctestItem, pytest.File):
+
     def runtest(self):
         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=get_optionflags(self),
-            extraglobs=dict(getfixture=fixture_request.getfuncargvalue),
-            raise_on_error=True, verbose=0)
+        fixture_request = _setup_fixtures(self)
+
+        # inspired by doctest.testfile; ideally we would use it directly,
+        # but it doesn't support passing a custom checker
+        text = self.fspath.read()
+        filename = str(self.fspath)
+        name = self.fspath.basename
+        globs = dict(getfixture=fixture_request.getfuncargvalue)
+        if '__name__' not in globs:
+            globs['__name__'] = '__main__'
+
+        optionflags = get_optionflags(self)
+        runner = doctest.DebugRunner(verbose=0, optionflags=optionflags,
+                                     checker=_get_unicode_checker())
+
+        parser = doctest.DocTestParser()
+        test = parser.get_doctest(text, globs, name, filename, 0)
+        _check_all_skipped(test)
+        runner.run(test)
+
+
+def _check_all_skipped(test):
+    """raises pytest.skip() if all examples in the given DocTest have the SKIP
+    option set.
+    """
+    import doctest
+    all_skipped = all(x.options.get(doctest.SKIP, False) for x in test.examples)
+    if all_skipped:
+        pytest.skip('all tests skipped by +SKIP option')
+
 
 class DoctestModule(pytest.File):
     def collect(self):
         import doctest
         if self.fspath.basename == "conftest.py":
-            module = self.config._conftest.importconftest(self.fspath)
+            module = self.config.pluginmanager._importconftest(self.fspath)
         else:
             try:
                 module = self.fspath.pyimport()
@@ -142,15 +162,86 @@ class DoctestModule(pytest.File):
                 else:
                     raise
         # satisfy `FixtureRequest` constructor...
-        self.funcargs = {}
-        self._fixtureinfo = FuncFixtureInfo((), [], {})
-        fixture_request = FixtureRequest(self)
+        fixture_request = _setup_fixtures(self)
         doctest_globals = dict(getfixture=fixture_request.getfuncargvalue)
         # uses internal doctest module parsing mechanism
         finder = doctest.DocTestFinder()
         optionflags = get_optionflags(self)
-        runner = doctest.DebugRunner(verbose=0, optionflags=optionflags)
+        runner = doctest.DebugRunner(verbose=0, optionflags=optionflags,
+                                     checker=_get_unicode_checker())
         for test in finder.find(module, module.__name__,
                                 extraglobs=doctest_globals):
             if test.examples:  # skip empty doctests
                 yield DoctestItem(test.name, self, runner, test)
+
+
+def _setup_fixtures(doctest_item):
+    """
+    Used by DoctestTextfile and DoctestModule to setup fixture information.
+    """
+    def func():
+        pass
+
+    doctest_item.funcargs = {}
+    fm = doctest_item.session._fixturemanager
+    doctest_item._fixtureinfo = fm.getfixtureinfo(node=doctest_item, func=func,
+                                                  cls=None, funcargs=False)
+    fixture_request = FixtureRequest(doctest_item)
+    fixture_request._fillfixtures()
+    return fixture_request
+
+
+def _get_unicode_checker():
+    """
+    Returns a doctest.OutputChecker subclass that takes in account the
+    ALLOW_UNICODE option to ignore u'' prefixes in strings. Useful
+    when the same doctest should run in Python 2 and Python 3.
+
+    An inner class is used to avoid importing "doctest" at the module
+    level.
+    """
+    if hasattr(_get_unicode_checker, 'UnicodeOutputChecker'):
+        return _get_unicode_checker.UnicodeOutputChecker()
+
+    import doctest
+    import re
+
+    class UnicodeOutputChecker(doctest.OutputChecker):
+        """
+        Copied from doctest_nose_plugin.py from the nltk project:
+            https://github.com/nltk/nltk
+        """
+
+        _literal_re = re.compile(r"(\W|^)[uU]([rR]?[\'\"])", re.UNICODE)
+
+        def check_output(self, want, got, optionflags):
+            res = doctest.OutputChecker.check_output(self, want, got,
+                                                     optionflags)
+            if res:
+                return True
+
+            if not (optionflags & _get_allow_unicode_flag()):
+                return False
+
+            else:  # pragma: no cover
+                # the code below will end up executed only in Python 2 in
+                # our tests, and our coverage check runs in Python 3 only
+                def remove_u_prefixes(txt):
+                    return re.sub(self._literal_re, r'\1\2', txt)
+
+                want = remove_u_prefixes(want)
+                got = remove_u_prefixes(got)
+                res = doctest.OutputChecker.check_output(self, want, got,
+                                                         optionflags)
+                return res
+
+    _get_unicode_checker.UnicodeOutputChecker = UnicodeOutputChecker
+    return _get_unicode_checker.UnicodeOutputChecker()
+
+
+def _get_allow_unicode_flag():
+    """
+    Registers and returns the ALLOW_UNICODE flag.
+    """
+    import doctest
+    return doctest.register_optionflag('ALLOW_UNICODE')

_pytest/genscript.py

@@ -1,10 +1,9 @@
-""" generate a single-file self-contained version of pytest """
+""" (deprecated) generate a single-file self-contained version of pytest """
 import os
 import sys
 import pkgutil
 
 import py
-
 import _pytest
 
 
@@ -33,6 +32,9 @@ def pkg_to_mapping(name):
         for pyfile in toplevel.visit('*.py'):
             pkg = pkgname(name, toplevel, pyfile)
             name2src[pkg] = pyfile.read()
+        # with wheels py source code might be not be installed
+        # and the resulting genscript is useless, just bail out.
+        assert name2src, "no source code found for %r at %r" %(name, toplevel)
     return name2src
 
 def compress_mapping(mapping):
@@ -70,7 +72,9 @@ def pytest_cmdline_main(config):
     genscript = config.getvalue("genscript")
     if genscript:
         tw = _pytest.config.create_terminal_writer(config)
-        deps =  ['py', '_pytest', 'pytest']
+        tw.line("WARNING: usage of genscript is deprecated.",
+                red=True)
+        deps =  ['py', '_pytest', 'pytest']  # pluggy is vendored
         if sys.version_info < (2,7):
             deps.append("argparse")
             tw.line("generated script will run on python2.6-python3.3++")

_pytest/helpconfig.py

@@ -22,30 +22,28 @@ def pytest_addoption(parser):
                help="store internal tracing debug information in 'pytestdebug.log'.")
 
 
-@pytest.mark.hookwrapper
+@pytest.hookimpl(hookwrapper=True)
 def pytest_cmdline_parse():
     outcome = yield
     config = outcome.get_result()
     if config.option.debug:
         path = os.path.abspath("pytestdebug.log")
-        f = open(path, 'w')
-        config._debugfile = f
-        f.write("versions pytest-%s, py-%s, "
+        debugfile = open(path, 'w')
+        debugfile.write("versions pytest-%s, py-%s, "
                 "python-%s\ncwd=%s\nargs=%s\n\n" %(
             pytest.__version__, py.__version__,
             ".".join(map(str, sys.version_info)),
             os.getcwd(), config._origargs))
-        config.pluginmanager.set_tracing(f.write)
+        config.trace.root.setwriter(debugfile.write)
+        undo_tracing = config.pluginmanager.enable_tracing()
         sys.stderr.write("writing pytestdebug information to %s\n" % path)
-
-@pytest.mark.trylast
-def pytest_unconfigure(config):
-    if hasattr(config, '_debugfile'):
-        config._debugfile.close()
-        sys.stderr.write("wrote pytestdebug information to %s\n" %
-            config._debugfile.name)
-        config.trace.root.setwriter(None)
-
+        def unset_tracing():
+            debugfile.close()
+            sys.stderr.write("wrote pytestdebug information to %s\n" %
+                             debugfile.name)
+            config.trace.root.setwriter(None)
+            undo_tracing()
+        config.add_cleanup(unset_tracing)
 
 def pytest_cmdline_main(config):
     if config.option.version:
@@ -58,14 +56,14 @@ def pytest_cmdline_main(config):
                 sys.stderr.write(line + "\n")
         return 0
     elif config.option.help:
-        config.do_configure()
+        config._do_configure()
         showhelp(config)
-        config.do_unconfigure()
+        config._ensure_unconfigure()
         return 0
 
 def showhelp(config):
-    import _pytest.config
-    tw = _pytest.config.create_terminal_writer(config)
+    reporter = config.pluginmanager.get_plugin('terminalreporter')
+    tw = reporter._tw
     tw.write(config._parser.optparser.format_help())
     tw.line()
     tw.line()
@@ -88,8 +86,9 @@ def showhelp(config):
     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)
+    tw.line(str(reporter.stats))
+    for warningreport in reporter.stats.get('warnings', []):
+        tw.line("warning : " + warningreport.message, red=True)
     return
 
 
@@ -99,10 +98,10 @@ conftest_options = [
 
 def getpluginversioninfo(config):
     lines = []
-    plugininfo = config.pluginmanager._plugin_distinfo
+    plugininfo = config.pluginmanager.list_plugin_distinfo()
     if plugininfo:
         lines.append("setuptools registered plugins:")
-        for dist, plugin in plugininfo:
+        for plugin, dist in plugininfo:
             loc = getattr(plugin, '__file__', repr(plugin))
             content = "%s-%s at %s" % (dist.project_name, dist.version, loc)
             lines.append("  " + content)
@@ -120,7 +119,7 @@ def pytest_report_header(config):
 
     if config.option.traceconfig:
         lines.append("active plugins:")
-        items = config.pluginmanager._name2plugin.items()
+        items = config.pluginmanager.list_name_plugin()
         for name, plugin in items:
             if hasattr(plugin, '__file__'):
                 r = plugin.__file__
@@ -128,5 +127,3 @@ def pytest_report_header(config):
                 r = repr(plugin)
             lines.append("    %-20s: %s" %(name, r))
     return lines
-
-

_pytest/hookspec.py

@@ -1,32 +1,44 @@
 """ hook specifications for pytest plugins, invoked from main.py and builtin plugins.  """
 
+from _pytest._pluggy import HookspecMarker
+
+hookspec = HookspecMarker("pytest")
+
 # -------------------------------------------------------------------------
-# Initialization
+# Initialization hooks called for every plugin
 # -------------------------------------------------------------------------
 
+@hookspec(historic=True)
 def pytest_addhooks(pluginmanager):
-    """called at plugin load time to allow adding new hooks via a call to
-    pluginmanager.registerhooks(module)."""
+    """called at plugin registration time to allow adding new hooks via a call to
+    pluginmanager.add_hookspecs(module_or_class, prefix)."""
 
 
+@hookspec(historic=True)
 def pytest_namespace():
     """return dict of name->object to be made globally available in
-    the pytest namespace.  This hook is called before command line options
-    are parsed.
+    the pytest namespace.  This hook is called at plugin registration
+    time.
     """
 
-def pytest_cmdline_parse(pluginmanager, args):
-    """return initialized config object, parsing the specified args. """
-pytest_cmdline_parse.firstresult = True
+@hookspec(historic=True)
+def pytest_plugin_registered(plugin, manager):
+    """ a new pytest plugin got registered. """
 
-def pytest_cmdline_preparse(config, args):
-    """(deprecated) modify command line arguments before option parsing. """
 
+@hookspec(historic=True)
 def pytest_addoption(parser):
     """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.
+    .. warning::
+
+        This function must be implemented in a :ref:`plugin <pluginorder>`
+        and is called once at the beginning of a test run.
+
+        Implementing this hook from ``conftest.py`` files is **strongly**
+        discouraged because ``conftest.py`` files are lazily loaded and
+        may give strange *unknown option* errors depending on the directory
+        ``py.test`` is invoked from.
 
     :arg parser: To add command line options, call
         :py:func:`parser.addoption(...) <_pytest.config.Parser.addoption>`.
@@ -47,35 +59,43 @@ def pytest_addoption(parser):
     via (deprecated) ``pytest.config``.
     """
 
+@hookspec(historic=True)
+def pytest_configure(config):
+    """ called after command line options have been parsed
+    and all plugins and initial conftest files been loaded.
+    This hook is called for every plugin.
+    """
+
+# -------------------------------------------------------------------------
+# Bootstrapping hooks called for plugins registered early enough:
+# internal and 3rd party plugins as well as directly
+# discoverable conftest.py local plugins.
+# -------------------------------------------------------------------------
+
+@hookspec(firstresult=True)
+def pytest_cmdline_parse(pluginmanager, args):
+    """return initialized config object, parsing the specified args. """
+
+def pytest_cmdline_preparse(config, args):
+    """(deprecated) modify command line arguments before option parsing. """
+
+@hookspec(firstresult=True)
 def pytest_cmdline_main(config):
     """ called for performing the main command line action. The default
     implementation will invoke the configure hooks and runtest_mainloop. """
-pytest_cmdline_main.firstresult = True
 
 def pytest_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
-        and all plugins and initial conftest files been loaded.
-    """
-
-def pytest_unconfigure(config):
-    """ called before test process is exited.  """
-
-def pytest_runtestloop(session):
-    """ called for performing the main runtest loop
-    (after collection finished). """
-pytest_runtestloop.firstresult = True
 
 # -------------------------------------------------------------------------
 # collection hooks
 # -------------------------------------------------------------------------
 
+@hookspec(firstresult=True)
 def pytest_collection(session):
     """ perform the collection protocol for the given session. """
-pytest_collection.firstresult = True
 
 def pytest_collection_modifyitems(session, config, items):
     """ called after collection has been performed, may filter or re-order
@@ -84,16 +104,16 @@ def pytest_collection_modifyitems(session, config, items):
 def pytest_collection_finish(session):
     """ called after collection has been performed and modified. """
 
+@hookspec(firstresult=True)
 def pytest_ignore_collect(path, config):
     """ return True to prevent considering this path for collection.
     This hook is consulted for all files and directories prior to calling
     more specific hooks.
     """
-pytest_ignore_collect.firstresult = True
 
+@hookspec(firstresult=True)
 def pytest_collect_directory(path, parent):
     """ called before traversing a directory for collection files. """
-pytest_collect_directory.firstresult = True
 
 def pytest_collect_file(path, parent):
     """ return collection Node or None for the given path. Any new node
@@ -112,29 +132,29 @@ def pytest_collectreport(report):
 def pytest_deselected(items):
     """ called for test items deselected by keyword. """
 
+@hookspec(firstresult=True)
 def pytest_make_collect_report(collector):
     """ perform ``collector.collect()`` and return a CollectReport. """
-pytest_make_collect_report.firstresult = True
 
 # -------------------------------------------------------------------------
 # Python test function related hooks
 # -------------------------------------------------------------------------
 
+@hookspec(firstresult=True)
 def pytest_pycollect_makemodule(path, parent):
     """ return a Module collector or None for the given path.
     This hook will be called for each matching test module path.
     The pytest_collect_file hook needs to be used if you want to
     create test modules for files that do not match as a test module.
     """
-pytest_pycollect_makemodule.firstresult = True
 
+@hookspec(firstresult=True)
 def pytest_pycollect_makeitem(collector, name, obj):
     """ return custom item/collector for a python object in a module, or None.  """
-pytest_pycollect_makeitem.firstresult = True
 
+@hookspec(firstresult=True)
 def pytest_pyfunc_call(pyfuncitem):
     """ call underlying test function. """
-pytest_pyfunc_call.firstresult = True
 
 def pytest_generate_tests(metafunc):
     """ generate (multiple) parametrized calls to a test function."""
@@ -142,9 +162,16 @@ def pytest_generate_tests(metafunc):
 # -------------------------------------------------------------------------
 # generic runtest related hooks
 # -------------------------------------------------------------------------
+
+@hookspec(firstresult=True)
+def pytest_runtestloop(session):
+    """ called for performing the main runtest loop
+    (after collection finished). """
+
 def pytest_itemstart(item, node):
     """ (deprecated, use pytest_runtest_logstart). """
 
+@hookspec(firstresult=True)
 def pytest_runtest_protocol(item, nextitem):
     """ implements the runtest_setup/call/teardown protocol for
     the given test item, including capturing exceptions and calling
@@ -158,7 +185,6 @@ def pytest_runtest_protocol(item, nextitem):
 
     :return boolean: True if no further hook implementations should be invoked.
     """
-pytest_runtest_protocol.firstresult = True
 
 def pytest_runtest_logstart(nodeid, location):
     """ signal the start of running a single test item. """
@@ -178,12 +204,12 @@ def pytest_runtest_teardown(item, nextitem):
                    so that nextitem only needs to call setup-functions.
     """
 
+@hookspec(firstresult=True)
 def pytest_runtest_makereport(item, call):
     """ return a :py:class:`_pytest.runner.TestReport` object
     for the given :py:class:`pytest.Item` and
     :py:class:`_pytest.runner.CallInfo`.
     """
-pytest_runtest_makereport.firstresult = True
 
 def pytest_runtest_logreport(report):
     """ process a test setup/call/teardown report relating to
@@ -199,6 +225,9 @@ def pytest_sessionstart(session):
 def pytest_sessionfinish(session, exitstatus):
     """ whole test run finishes. """
 
+def pytest_unconfigure(config):
+    """ called before test process is exited.  """
+
 
 # -------------------------------------------------------------------------
 # hooks for customising the assert methods
@@ -220,13 +249,15 @@ def pytest_assertrepr_compare(config, op, left, right):
 def pytest_report_header(config, startdir):
     """ return a string to be displayed as header info for terminal reporting."""
 
+@hookspec(firstresult=True)
 def pytest_report_teststatus(report):
     """ return result-category, shortletter and verbose word for reporting."""
-pytest_report_teststatus.firstresult = True
 
 def pytest_terminal_summary(terminalreporter):
     """ add additional section in terminal summary reporting.  """
 
+
+@hookspec(historic=True)
 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
@@ -236,17 +267,14 @@ def pytest_logwarning(message, code, nodeid, fslocation):
 # doctest hooks
 # -------------------------------------------------------------------------
 
+@hookspec(firstresult=True)
 def pytest_doctest_prepare_content(content):
     """ return processed content for a given doctest"""
-pytest_doctest_prepare_content.firstresult = True
 
 # -------------------------------------------------------------------------
 # error handling and internal debugging hooks
 # -------------------------------------------------------------------------
 
-def pytest_plugin_registered(plugin, manager):
-    """ a new pytest plugin got registered. """
-
 def pytest_internalerror(excrepr, excinfo):
     """ called for internal errors. """
 

_pytest/junitxml.py

@@ -1,5 +1,7 @@
 """ report test results in JUnit-XML format, for use with Hudson and build integration servers.
 
+Output conforms to https://github.com/jenkinsci/xunit-plugin/blob/master/src/main/resources/org/jenkinsci/plugins/xunit/types/model/xsd/junit-10.xsd
+
 Based on initial code from Ross Lawley.
 """
 import py
@@ -7,6 +9,7 @@ import os
 import re
 import sys
 import time
+import pytest
 
 # Python 2.X and 3.X compatibility
 if sys.version_info[0] < 3:
@@ -51,6 +54,20 @@ def bin_xml_escape(arg):
             return unicode('#x%04X') % i
     return py.xml.raw(illegal_xml_re.sub(repl, py.xml.escape(arg)))
 
+@pytest.fixture
+def record_xml_property(request):
+    """Fixture that adds extra xml properties to the tag for the calling test.
+    The fixture is callable with (name, value), with value being automatically
+    xml-encoded.
+    """
+    def inner(name, value):
+        if hasattr(request.config, "_xml"):
+            request.config._xml.add_custom_property(name, value)
+        msg = 'record_xml_property is an experimental feature'
+        request.config.warn(code='C3', message=msg,
+                            fslocation=request.node.location[:2])
+    return inner
+
 def pytest_addoption(parser):
     group = parser.getgroup("terminal reporting")
     group.addoption('--junitxml', '--junit-xml', action="store",
@@ -73,7 +90,6 @@ def pytest_unconfigure(config):
         del config._xml
         config.pluginmanager.unregister(xml)
 
-
 def mangle_testnames(names):
     names = [x.replace(".py", "") for x in names if x != '()']
     names[0] = names[0].replace("/", '.')
@@ -85,19 +101,34 @@ class LogXML(object):
         self.logfile = os.path.normpath(os.path.abspath(logfile))
         self.prefix = prefix
         self.tests = []
+        self.tests_by_nodeid = {}  # nodeid -> Junit.testcase
+        self.durations = {}  # nodeid -> total duration (setup+call+teardown)
         self.passed = self.skipped = 0
         self.failed = self.errors = 0
+        self.custom_properties = {}
+
+    def add_custom_property(self, name, value):
+        self.custom_properties[str(name)] = bin_xml_escape(str(value))
 
     def _opentestcase(self, report):
         names = mangle_testnames(report.nodeid.split("::"))
         classnames = names[:-1]
         if self.prefix:
             classnames.insert(0, self.prefix)
-        self.tests.append(Junit.testcase(
-            classname=".".join(classnames),
-            name=bin_xml_escape(names[-1]),
-            time=getattr(report, 'duration', 0)
-        ))
+        attrs = {
+            "classname": ".".join(classnames),
+            "name": bin_xml_escape(names[-1]),
+            "file": report.location[0],
+            "time": self.durations.get(report.nodeid, 0),
+        }
+        if report.location[1] is not None:
+            attrs["line"] = report.location[1]
+        testcase = Junit.testcase(**attrs)
+        custom_properties = self.pop_custom_properties()
+        if custom_properties:
+            testcase.append(custom_properties)
+        self.tests.append(testcase)
+        self.tests_by_nodeid[report.nodeid] = testcase
 
     def _write_captured_output(self, report):
         for capname in ('out', 'err'):
@@ -112,6 +143,21 @@ class LogXML(object):
     def append(self, obj):
         self.tests[-1].append(obj)
 
+    def pop_custom_properties(self):
+        """Return a Junit node containing custom properties set for
+        the current test, if any, and reset the current custom properties.
+        """
+        if self.custom_properties:
+            result = Junit.properties(
+                [
+                    Junit.property(name=name, value=value)
+                    for name, value in self.custom_properties.items()
+                ]
+            )
+            self.custom_properties.clear()
+            return result
+        return None
+
     def append_pass(self, report):
         self.passed += 1
         self._write_captured_output(report)
@@ -170,8 +216,30 @@ class LogXML(object):
         self._write_captured_output(report)
 
     def pytest_runtest_logreport(self, report):
+        """handle a setup/call/teardown report, generating the appropriate
+        xml tags as necessary.
+
+        note: due to plugins like xdist, this hook may be called in interlaced
+        order with reports from other nodes. for example:
+
+        usual call order:
+            -> setup node1
+            -> call node1
+            -> teardown node1
+            -> setup node2
+            -> call node2
+            -> teardown node2
+
+        possible call order in xdist:
+            -> setup node1
+            -> call node1
+            -> setup node2
+            -> call node2
+            -> teardown node2
+            -> teardown node1
+        """
         if report.passed:
-            if report.when == "call": # ignore setup/teardown
+            if report.when == "call":  # ignore setup/teardown
                 self._opentestcase(report)
                 self.append_pass(report)
         elif report.failed:
@@ -183,6 +251,19 @@ class LogXML(object):
         elif report.skipped:
             self._opentestcase(report)
             self.append_skipped(report)
+        self.update_testcase_duration(report)
+
+    def update_testcase_duration(self, report):
+        """accumulates total duration for nodeid from given report and updates
+        the Junit.testcase with the new total if already created.
+        """
+        total = self.durations.get(report.nodeid, 0.0)
+        total += getattr(report, 'duration', 0.0)
+        self.durations[report.nodeid] = total
+
+        testcase = self.tests_by_nodeid.get(report.nodeid)
+        if testcase is not None:
+            testcase.attr.time = total
 
     def pytest_collectreport(self, report):
         if not report.passed:

_pytest/main.py

@@ -19,12 +19,15 @@ EXIT_TESTSFAILED = 1
 EXIT_INTERRUPTED = 2
 EXIT_INTERNALERROR = 3
 EXIT_USAGEERROR = 4
+EXIT_NOTESTSCOLLECTED = 5
 
 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}', '*.egg'])
+    parser.addini("testpaths", "directories to search for tests when no files or directories are given in the command line.",
+        type="args", default=[])
     #parser.addini("dirpatterns",
     #    "patterns specifying possible locations of test files",
     #    type="linelist", default=["**/test_*.txt",
@@ -54,6 +57,9 @@ def pytest_addoption(parser):
     group.addoption('--confcutdir', dest="confcutdir", default=None,
         metavar="dir",
         help="only load conftest.py's relative to specified dir.")
+    group.addoption('--noconftest', action="store_true",
+        dest="noconftest", default=False,
+        help="Don't load any conftest.py files.")
 
     group = parser.getgroup("debugconfig",
         "test session debugging and configuration")
@@ -77,16 +83,13 @@ def wrap_session(config, doit):
     initstate = 0
     try:
         try:
-            config.do_configure()
+            config._do_configure()
             initstate = 1
             config.hook.pytest_sessionstart(session=session)
             initstate = 2
-            doit(config, session)
+            session.exitstatus = doit(config, session) or 0
         except pytest.UsageError:
-            args = sys.exc_info()[1].args
-            for msg in args:
-                sys.stderr.write("ERROR: %s\n" %(msg,))
-            session.exitstatus = EXIT_USAGEERROR
+            raise
         except KeyboardInterrupt:
             excinfo = py.code.ExceptionInfo()
             config.hook.pytest_keyboard_interrupt(excinfo=excinfo)
@@ -97,9 +100,7 @@ def wrap_session(config, doit):
             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()
@@ -107,9 +108,7 @@ def wrap_session(config, doit):
             config.hook.pytest_sessionfinish(
                 session=session,
                 exitstatus=session.exitstatus)
-        if initstate >= 1:
-            config.do_unconfigure()
-        config.pluginmanager.ensure_shutdown()
+        config._ensure_unconfigure()
     return session.exitstatus
 
 def pytest_cmdline_main(config):
@@ -121,6 +120,11 @@ def _main(config, session):
     config.hook.pytest_collection(session=session)
     config.hook.pytest_runtestloop(session=session)
 
+    if session.testsfailed:
+        return EXIT_TESTSFAILED
+    elif session.testscollected == 0:
+        return EXIT_NOTESTSCOLLECTED
+
 def pytest_collection(session):
     return session.perform_collect()
 
@@ -153,18 +157,17 @@ def pytest_ignore_collect(path, config):
         ignore_paths.extend([py.path.local(x) for x in excludeopt])
     return path in ignore_paths
 
-class FSHookProxy(object):
-    def __init__(self, fspath, config):
+class FSHookProxy:
+    def __init__(self, fspath, pm, remove_mods):
         self.fspath = fspath
-        self.config = config
+        self.pm = pm
+        self.remove_mods = remove_mods
 
     def __getattr__(self, name):
-        plugins = self.config._getmatchingplugins(self.fspath)
-        x = self.config.hook._getcaller(name, plugins)
+        x = self.pm.subset_hook_caller(name, remove_plugins=self.remove_mods)
         self.__dict__[name] = x
         return x
 
-
 def compatproperty(name):
     def fget(self):
         # deprecated - use pytest.name
@@ -277,9 +280,9 @@ class Node(object):
         else:
             fslocation = "%s:%s" % fslocation[:2]
 
-        self.ihook.pytest_logwarning(code=code, message=message,
-                                     nodeid=self.nodeid,
-                                     fslocation=fslocation)
+        self.ihook.pytest_logwarning.call_historic(kwargs=dict(
+            code=code, message=message,
+            nodeid=self.nodeid, fslocation=fslocation))
 
     # methods for ordering nodes
     @property
@@ -364,9 +367,6 @@ class Node(object):
     def listnames(self):
         return [x.name for x in self.listchain()]
 
-    def getplugins(self):
-        return self.config._getmatchingplugins(self.fspath)
-
     def addfinalizer(self, fin):
         """ register a function to be called when this node is finalized.
 
@@ -512,28 +512,31 @@ class Session(FSCollector):
     def __init__(self, config):
         FSCollector.__init__(self, config.rootdir, parent=None,
                              config=config, session=self)
-        self.config.pluginmanager.register(self, name="session", prepend=True)
-        self._testsfailed = 0
+        self._fs2hookproxy = {}
+        self.testsfailed = 0
+        self.testscollected = 0
         self.shouldstop = False
         self.trace = config.trace.root.get("collection")
         self._norecursepatterns = config.getini("norecursedirs")
         self.startdir = py.path.local()
-        self._fs2hookproxy = {}
+        self.config.pluginmanager.register(self, name="session")
 
     def _makeid(self):
         return ""
 
+    @pytest.hookimpl(tryfirst=True)
     def pytest_collectstart(self):
         if self.shouldstop:
             raise self.Interrupted(self.shouldstop)
 
+    @pytest.hookimpl(tryfirst=True)
     def pytest_runtest_logreport(self, report):
         if report.failed and not hasattr(report, 'wasxfail'):
-            self._testsfailed += 1
+            self.testsfailed += 1
             maxfail = self.config.getvalue("maxfail")
-            if maxfail and self._testsfailed >= maxfail:
+            if maxfail and self.testsfailed >= maxfail:
                 self.shouldstop = "stopping after %d failures" % (
-                    self._testsfailed)
+                    self.testsfailed)
     pytest_collectreport = pytest_runtest_logreport
 
     def isinitpath(self, path):
@@ -543,8 +546,20 @@ class Session(FSCollector):
         try:
             return self._fs2hookproxy[fspath]
         except KeyError:
-            self._fs2hookproxy[fspath] = x = FSHookProxy(fspath, self.config)
-            return x
+            # check if we have the common case of running
+            # hooks with all conftest.py filesall conftest.py
+            pm = self.config.pluginmanager
+            my_conftestmodules = pm._getconftestmodules(fspath)
+            remove_mods = pm._conftest_plugins.difference(my_conftestmodules)
+            if remove_mods:
+                # one or more conftests are not in use at this fspath
+                proxy = FSHookProxy(fspath, pm, remove_mods)
+            else:
+                # all plugis are active for this fspath
+                proxy = self.config.hook
+
+            self._fs2hookproxy[fspath] = proxy
+            return proxy
 
     def perform_collect(self, args=None, genitems=True):
         hook = self.config.hook
@@ -554,6 +569,7 @@ class Session(FSCollector):
                 config=self.config, items=items)
         finally:
             hook.pytest_collection_finish(session=self)
+        self.testscollected = len(items)
         return items
 
     def _perform_collect(self, args, genitems):
@@ -727,5 +743,3 @@ class Session(FSCollector):
                     for x in self.genitems(subnode):
                         yield x
             node.ihook.pytest_collectreport(report=rep)
-
-

_pytest/mark.py

@@ -45,14 +45,14 @@ def pytest_addoption(parser):
 def pytest_cmdline_main(config):
     import _pytest.config
     if config.option.markers:
-        config.do_configure()
+        config._do_configure()
         tw = _pytest.config.create_terminal_writer(config)
         for line in config.getini("markers"):
             name, rest = line.split(":", 1)
             tw.write("@pytest.mark.%s:" % name, bold=True)
             tw.line(rest)
             tw.line()
-        config.do_unconfigure()
+        config._ensure_unconfigure()
         return 0
 pytest_cmdline_main.tryfirst = True
 
@@ -291,7 +291,7 @@ class MarkInfo:
         #: positional argument list, empty if none specified
         self.args = args
         #: keyword argument dictionary, empty if nothing specified
-        self.kwargs = kwargs
+        self.kwargs = kwargs.copy()
         self._arglist = [(args, kwargs.copy())]
 
     def __repr__(self):

_pytest/monkeypatch.py

@@ -27,7 +27,7 @@ def pytest_funcarg__monkeypatch(request):
 
 
 
-def derive_importpath(import_path):
+def derive_importpath(import_path, raising):
     import pytest
     if not isinstance(import_path, _basestring) or "." not in import_path:
         raise TypeError("must be absolute import path string, not %r" %
@@ -51,7 +51,8 @@ def derive_importpath(import_path):
                     attr = rest.pop()
                     obj = getattr(obj, attr)
                 attr = rest[0]
-                getattr(obj, attr)
+                if raising:
+                    getattr(obj, attr)
             except AttributeError:
                 __tracebackhide__ = True
                 pytest.fail("object %r has no attribute %r" % (obj, attr))
@@ -71,6 +72,7 @@ class monkeypatch:
         self._setattr = []
         self._setitem = []
         self._cwd = None
+        self._savesyspath = None
 
     def setattr(self, target, name, value=notset, raising=True):
         """ Set attribute value on target, memorizing the old value.
@@ -95,7 +97,7 @@ class monkeypatch:
                    "setattr(target, value) with target being a dotted "
                    "import string")
             value = name
-            name, target = derive_importpath(target)
+            name, target = derive_importpath(target, raising)
 
         oldval = getattr(target, name, notset)
         if raising and oldval is notset:
@@ -124,7 +126,7 @@ class monkeypatch:
                 raise TypeError("use delattr(target, name) or "
                                 "delattr(target) with target being a dotted "
                                 "import string")
-            name, target = derive_importpath(target)
+            name, target = derive_importpath(target, raising)
 
         if not hasattr(target, name):
             if raising:
@@ -172,13 +174,13 @@ class monkeypatch:
 
     def syspath_prepend(self, path):
         """ Prepend ``path`` to ``sys.path`` list of import locations. """
-        if not hasattr(self, '_savesyspath'):
+        if self._savesyspath is None:
             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
+        """ 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()
@@ -190,7 +192,17 @@ class monkeypatch:
     def undo(self):
         """ Undo previous changes.  This call consumes the
         undo stack. Calling it a second time has no effect unless
-        you do more monkeypatching after the undo call."""
+        you do more monkeypatching after the undo call.
+        
+        There is generally no need to call `undo()`, since it is
+        called automatically during tear-down.
+        
+        Note that the same `monkeypatch` fixture is used across a
+        single test function invocation. If `monkeypatch` is used both by
+        the test function itself and one of the test fixtures,
+        calling `undo()` will undo all of the changes made in
+        both functions.
+        """
         for obj, name, value in self._setattr:
             if value is not notset:
                 setattr(obj, name, value)
@@ -206,9 +218,9 @@ class monkeypatch:
             else:
                 dictionary[name] = value
         self._setitem[:] = []
-        if hasattr(self, '_savesyspath'):
+        if self._savesyspath is not None:
             sys.path[:] = self._savesyspath
-            del self._savesyspath
+            self._savesyspath = None
 
         if self._cwd is not None:
             os.chdir(self._cwd)

_pytest/nose.py

@@ -24,7 +24,7 @@ def pytest_runtest_makereport(item, call):
         call.excinfo = call2.excinfo
 
 
-@pytest.mark.trylast
+@pytest.hookimpl(trylast=True)
 def pytest_runtest_setup(item):
     if is_potential_nosetest(item):
         if isinstance(item.parent, pytest.Generator):

_pytest/pastebin.py

@@ -11,7 +11,7 @@ def pytest_addoption(parser):
         choices=['failed', 'all'],
         help="send failed|all info to bpaste.net pastebin service.")
 
-@pytest.mark.trylast
+@pytest.hookimpl(trylast=True)
 def pytest_configure(config):
     if config.option.pastebin == "all":
         tr = config.pluginmanager.getplugin('terminalreporter')

_pytest/pytester.py

@@ -1,5 +1,7 @@
 """ (disabled by default) support for testing pytest and pytest plugins. """
+import gc
 import sys
+import traceback
 import os
 import codecs
 import re
@@ -11,10 +13,142 @@ import subprocess
 import py
 import pytest
 from py.builtin import print_
-from _pytest.core import HookCaller, add_method_wrapper
 
 from _pytest.main import Session, EXIT_OK
 
+
+def pytest_addoption(parser):
+    # group = parser.getgroup("pytester", "pytester (self-tests) options")
+    parser.addoption('--lsof',
+           action="store_true", dest="lsof", default=False,
+           help=("run FD checks if lsof is available"))
+
+    parser.addoption('--runpytest', default="inprocess", dest="runpytest",
+           choices=("inprocess", "subprocess", ),
+           help=("run pytest sub runs in tests using an 'inprocess' "
+                 "or 'subprocess' (python -m main) method"))
+
+
+def pytest_configure(config):
+    # This might be called multiple times. Only take the first.
+    global _pytest_fullpath
+    try:
+        _pytest_fullpath
+    except NameError:
+        _pytest_fullpath = os.path.abspath(pytest.__file__.rstrip("oc"))
+        _pytest_fullpath = _pytest_fullpath.replace("$py.class", ".py")
+
+    if config.getvalue("lsof"):
+        checker = LsofFdLeakChecker()
+        if checker.matching_platform():
+            config.pluginmanager.register(checker)
+
+
+class LsofFdLeakChecker(object):
+    def get_open_files(self):
+        out = self._exec_lsof()
+        open_files = self._parse_lsof_output(out)
+        return open_files
+
+    def _exec_lsof(self):
+        pid = os.getpid()
+        return py.process.cmdexec("lsof -Ffn0 -p %d" % pid)
+
+    def _parse_lsof_output(self, out):
+        def isopen(line):
+            return line.startswith('f') and ("deleted" not in line and
+                'mem' not in line and "txt" not in line and 'cwd' not in line)
+
+        open_files = []
+
+        for line in out.split("\n"):
+            if isopen(line):
+                fields = line.split('\0')
+                fd = fields[0][1:]
+                filename = fields[1][1:]
+                if filename.startswith('/'):
+                    open_files.append((fd, filename))
+
+        return open_files
+
+    def matching_platform(self):
+        try:
+            py.process.cmdexec("lsof -v")
+        except (py.process.cmdexec.Error, UnicodeDecodeError):
+            # cmdexec may raise UnicodeDecodeError on Windows systems
+            # with locale other than english:
+            # https://bitbucket.org/pytest-dev/py/issues/66
+            return False
+        else:
+            return True
+
+    @pytest.hookimpl(hookwrapper=True, tryfirst=True)
+    def pytest_runtest_item(self, item):
+        lines1 = self.get_open_files()
+        yield
+        if hasattr(sys, "pypy_version_info"):
+            gc.collect()
+        lines2 = self.get_open_files()
+
+        new_fds = set([t[0] for t in lines2]) - set([t[0] for t in lines1])
+        leaked_files = [t for t in lines2 if t[0] in new_fds]
+        if leaked_files:
+            error = []
+            error.append("***** %s FD leakage detected" % len(leaked_files))
+            error.extend([str(f) for f in leaked_files])
+            error.append("*** Before:")
+            error.extend([str(f) for f in lines1])
+            error.append("*** After:")
+            error.extend([str(f) for f in lines2])
+            error.append(error[0])
+            error.append("*** function %s:%s: %s " % item.location)
+            pytest.fail("\n".join(error), pytrace=False)
+
+
+# XXX copied from execnet's conftest.py - needs to be merged
+winpymap = {
+    'python2.7': r'C:\Python27\python.exe',
+    'python2.6': r'C:\Python26\python.exe',
+    'python3.1': r'C:\Python31\python.exe',
+    'python3.2': r'C:\Python32\python.exe',
+    'python3.3': r'C:\Python33\python.exe',
+    'python3.4': r'C:\Python34\python.exe',
+    'python3.5': r'C:\Python35\python.exe',
+}
+
+def getexecutable(name, cache={}):
+    try:
+        return cache[name]
+    except KeyError:
+        executable = py.path.local.sysfind(name)
+        if executable:
+            if name == "jython":
+                import subprocess
+                popen = subprocess.Popen([str(executable), "--version"],
+                    universal_newlines=True, stderr=subprocess.PIPE)
+                out, err = popen.communicate()
+                if not err or "2.5" not in err:
+                    executable = None
+                if "2.5.2" in err:
+                    executable = None # http://bugs.jython.org/issue1790
+        cache[name] = executable
+        return executable
+
+@pytest.fixture(params=['python2.6', 'python2.7', 'python3.3', "python3.4",
+                        'pypy', 'pypy3'])
+def anypython(request):
+    name = request.param
+    executable = getexecutable(name)
+    if executable is None:
+        if sys.platform == "win32":
+            executable = winpymap.get(name, None)
+            if executable:
+                executable = py.path.local(executable)
+                if executable.check():
+                    return executable
+        pytest.skip("no suitable %s found" % (name,))
+    return executable
+
 # used at least by pytest-xdist plugin
 @pytest.fixture
 def _pytest(request):
@@ -39,23 +173,6 @@ def get_public_names(l):
     return [x for x in l if x[0] != "_"]
 
 
-def pytest_addoption(parser):
-    group = parser.getgroup("pylib")
-    group.addoption('--no-tools-on-path',
-           action="store_true", dest="notoolsonpath", default=False,
-           help=("discover tools on PATH instead of going through py.cmdline.")
-    )
-
-def pytest_configure(config):
-    # This might be called multiple times. Only take the first.
-    global _pytest_fullpath
-    try:
-        _pytest_fullpath
-    except NameError:
-        _pytest_fullpath = os.path.abspath(pytest.__file__.rstrip("oc"))
-        _pytest_fullpath = _pytest_fullpath.replace("$py.class", ".py")
-
-
 class ParsedCall:
     def __init__(self, name, kwargs):
         self.__dict__.update(kwargs)
@@ -68,15 +185,24 @@ class ParsedCall:
 
 
 class HookRecorder:
+    """Record all hooks called in a plugin manager.
+
+    This wraps all the hook calls in the plugin manager, recording
+    each call before propagating the normal calls.
+
+    """
+
     def __init__(self, pluginmanager):
         self._pluginmanager = pluginmanager
         self.calls = []
 
-        def _docall(hookcaller, methods, kwargs):
-            self.calls.append(ParsedCall(hookcaller.name, kwargs))
-            yield
-        self._undo_wrapping = add_method_wrapper(HookCaller, _docall)
-        pluginmanager.add_shutdown(self._undo_wrapping)
+        def before(hook_name, hook_impls, kwargs):
+            self.calls.append(ParsedCall(hook_name, kwargs))
+
+        def after(outcome, hook_name, hook_impls, kwargs):
+            pass
+
+        self._undo_wrapping = pluginmanager.add_hookcall_monitoring(before, after)
 
     def finish_recording(self):
         self._undo_wrapping()
@@ -186,18 +312,36 @@ class HookRecorder:
         self.calls[:] = []
 
 
-def pytest_funcarg__linecomp(request):
+@pytest.fixture
+def linecomp(request):
     return LineComp()
 
+
 def pytest_funcarg__LineMatcher(request):
     return LineMatcher
 
-def pytest_funcarg__testdir(request):
-    tmptestdir = TmpTestdir(request)
-    return tmptestdir
 
-rex_outcome = re.compile("(\d+) (\w+)")
+@pytest.fixture
+def testdir(request, tmpdir_factory):
+    return Testdir(request, tmpdir_factory)
+
+
+rex_outcome = re.compile("(\d+) ([\w-]+)")
 class RunResult:
+    """The result of running a command.
+
+    Attributes:
+
+    :ret: The return value.
+    :outlines: List of lines captured from stdout.
+    :errlines: List of lines captures from stderr.
+    :stdout: :py:class:`LineMatcher` of stdout, use ``stdout.str()`` to
+       reconstruct stdout or the commonly used
+       ``stdout.fnmatch_lines()`` method.
+    :stderrr: :py:class:`LineMatcher` of stderr.
+    :duration: Duration in seconds.
+
+    """
     def __init__(self, ret, outlines, errlines, duration):
         self.ret = ret
         self.outlines = outlines
@@ -207,6 +351,8 @@ class RunResult:
         self.duration = duration
 
     def parseoutcomes(self):
+        """ Return a dictionary of outcomestring->num from parsing
+        the terminal output that the test process produced."""
         for line in reversed(self.outlines):
             if 'seconds' in line:
                 outcomes = rex_outcome.findall(line)
@@ -216,12 +362,41 @@ class RunResult:
                         d[cat] = int(num)
                     return d
 
-class TmpTestdir:
-    def __init__(self, request):
+    def assert_outcomes(self, passed=0, skipped=0, failed=0):
+        """ assert that the specified outcomes appear with the respective
+        numbers (0 means it didn't occur) in the text output from a test run."""
+        d = self.parseoutcomes()
+        assert passed == d.get("passed", 0)
+        assert skipped == d.get("skipped", 0)
+        assert failed == d.get("failed", 0)
+
+
+
+class Testdir:
+    """Temporary test directory with tools to test/run py.test itself.
+
+    This is based on the ``tmpdir`` fixture but provides a number of
+    methods which aid with testing py.test itself.  Unless
+    :py:meth:`chdir` is used all methods will use :py:attr:`tmpdir` as
+    current working directory.
+
+    Attributes:
+
+    :tmpdir: The :py:class:`py.path.local` instance of the temporary
+       directory.
+
+    :plugins: A list of plugins to use with :py:meth:`parseconfig` and
+       :py:meth:`runpytest`.  Initially this is an empty list but
+       plugins can be added to the list.  The type of items to add to
+       the list depend on the method which uses them so refer to them
+       for details.
+
+    """
+
+    def __init__(self, request, tmpdir_factory):
         self.request = request
-        self.Config = request.config.__class__
         # XXX remove duplication with tmpdir plugin
-        basetmp = request.config._tmpdirhandler.ensuretemp("testdir")
+        basetmp = tmpdir_factory.ensuretemp("testdir")
         name = request.function.__name__
         for i in range(100):
             try:
@@ -231,32 +406,58 @@ class TmpTestdir:
             break
         self.tmpdir = tmpdir
         self.plugins = []
-        self._syspathremove = []
+        self._savesyspath = (list(sys.path), list(sys.meta_path))
+        self._savemodulekeys = set(sys.modules)
         self.chdir() # always chdir
         self.request.addfinalizer(self.finalize)
+        method = self.request.config.getoption("--runpytest")
+        if method == "inprocess":
+            self._runpytest_method = self.runpytest_inprocess
+        elif method == "subprocess":
+            self._runpytest_method = self.runpytest_subprocess
 
     def __repr__(self):
-        return "<TmpTestdir %r>" % (self.tmpdir,)
+        return "<Testdir %r>" % (self.tmpdir,)
 
     def finalize(self):
-        for p in self._syspathremove:
-            sys.path.remove(p)
+        """Clean up global state artifacts.
+
+        Some methods modify the global interpreter state and this
+        tries to clean this up.  It does not remove the temporary
+        directory however so it can be looked at after the test run
+        has finished.
+
+        """
+        sys.path[:], sys.meta_path[:] = self._savesyspath
         if hasattr(self, '_olddir'):
             self._olddir.chdir()
-        # delete modules that have been loaded from tmpdir
-        for name, mod in list(sys.modules.items()):
-            if mod:
-                fn = getattr(mod, '__file__', None)
-                if fn and fn.startswith(str(self.tmpdir)):
-                    del sys.modules[name]
+        self.delete_loaded_modules()
+
+    def delete_loaded_modules(self):
+        """Delete modules that have been loaded during a test.
+
+        This allows the interpreter to catch module changes in case
+        the module is re-imported.
+        """
+        for name in set(sys.modules).difference(self._savemodulekeys):
+            # it seems zope.interfaces is keeping some state
+            # (used by twisted related tests)
+            if name != "zope.interface":
+                del sys.modules[name]
 
     def make_hook_recorder(self, pluginmanager):
+        """Create a new :py:class:`HookRecorder` for a PluginManager."""
         assert not hasattr(pluginmanager, "reprec")
         pluginmanager.reprec = reprec = HookRecorder(pluginmanager)
         self.request.addfinalizer(reprec.finish_recording)
         return reprec
 
     def chdir(self):
+        """Cd into the temporary directory.
+
+        This is done automatically upon instantiation.
+
+        """
         old = self.tmpdir.chdir()
         if not hasattr(self, '_olddir'):
             self._olddir = old
@@ -285,42 +486,95 @@ class TmpTestdir:
                 ret = p
         return ret
 
-
     def makefile(self, ext, *args, **kwargs):
+        """Create a new file in the testdir.
+
+        ext: The extension the file should use, including the dot.
+           E.g. ".py".
+
+        args: All args will be treated as strings and joined using
+           newlines.  The result will be written as contents to the
+           file.  The name of the file will be based on the test
+           function requesting this fixture.
+           E.g. "testdir.makefile('.txt', 'line1', 'line2')"
+
+        kwargs: Each keyword is the name of a file, while the value of
+           it will be written as contents of the file.
+           E.g. "testdir.makefile('.ini', pytest='[pytest]\naddopts=-rs\n')"
+
+        """
         return self._makefile(ext, args, kwargs)
 
     def makeconftest(self, source):
+        """Write a contest.py file with 'source' as contents."""
         return self.makepyfile(conftest=source)
 
     def makeini(self, source):
+        """Write a tox.ini file with 'source' as contents."""
         return self.makefile('.ini', tox=source)
 
     def getinicfg(self, source):
+        """Return the pytest section from the tox.ini config file."""
         p = self.makeini(source)
         return py.iniconfig.IniConfig(p)['pytest']
 
     def makepyfile(self, *args, **kwargs):
+        """Shortcut for .makefile() with a .py extension."""
         return self._makefile('.py', args, kwargs)
 
     def maketxtfile(self, *args, **kwargs):
+        """Shortcut for .makefile() with a .txt extension."""
         return self._makefile('.txt', args, kwargs)
 
     def syspathinsert(self, path=None):
+        """Prepend a directory to sys.path, defaults to :py:attr:`tmpdir`.
+
+        This is undone automatically after the test.
+        """
         if path is None:
             path = self.tmpdir
         sys.path.insert(0, str(path))
-        self._syspathremove.append(str(path))
+        # a call to syspathinsert() usually means that the caller
+        # wants to import some dynamically created files.
+        # with python3 we thus invalidate import caches.
+        self._possibly_invalidate_import_caches()
+
+    def _possibly_invalidate_import_caches(self):
+        # invalidate caches if we can (py33 and above)
+        try:
+            import importlib
+        except ImportError:
+            pass
+        else:
+            if hasattr(importlib, "invalidate_caches"):
+                importlib.invalidate_caches()
 
     def mkdir(self, name):
+        """Create a new (sub)directory."""
         return self.tmpdir.mkdir(name)
 
     def mkpydir(self, name):
+        """Create a new python package.
+
+        This creates a (sub)direcotry with an empty ``__init__.py``
+        file so that is recognised as a python package.
+
+        """
         p = self.mkdir(name)
         p.ensure("__init__.py")
         return p
 
     Session = Session
     def getnode(self, config, arg):
+        """Return the collection node of a file.
+
+        :param config: :py:class:`_pytest.config.Config` instance, see
+           :py:meth:`parseconfig` and :py:meth:`parseconfigure` to
+           create the configuration.
+
+        :param arg: A :py:class:`py.path.local` instance of the file.
+
+        """
         session = Session(config)
         assert '::' not in str(arg)
         p = py.path.local(arg)
@@ -330,6 +584,15 @@ class TmpTestdir:
         return res
 
     def getpathnode(self, path):
+        """Return the collection node of a file.
+
+        This is like :py:meth:`getnode` but uses
+        :py:meth:`parseconfigure` to create the (configured) py.test
+        Config instance.
+
+        :param path: A :py:class:`py.path.local` instance of the file.
+
+        """
         config = self.parseconfigure(path)
         session = Session(config)
         x = session.fspath.bestrelpath(path)
@@ -339,6 +602,12 @@ class TmpTestdir:
         return res
 
     def genitems(self, colitems):
+        """Generate all test items from a collection node.
+
+        This recurses into the collection node and returns a list of
+        all the test items contained within.
+
+        """
         session = colitems[0].session
         result = []
         for colitem in colitems:
@@ -346,6 +615,14 @@ class TmpTestdir:
         return result
 
     def runitem(self, source):
+        """Run the "test_func" Item.
+
+        The calling test instance (the class which contains the test
+        method) must provide a ``.getrunner()`` method which should
+        return a runner which can run the test protocol for a single
+        item, like e.g. :py:func:`_pytest.runner.runtestprotocol`.
+
+        """
         # used from runner functional tests
         item = self.getitem(source)
         # the test class where we are called from wants to provide the runner
@@ -354,68 +631,176 @@ class TmpTestdir:
         return runner(item)
 
     def inline_runsource(self, source, *cmdlineargs):
+        """Run a test module in process using ``pytest.main()``.
+
+        This run writes "source" into a temporary file and runs
+        ``pytest.main()`` on it, returning a :py:class:`HookRecorder`
+        instance for the result.
+
+        :param source: The source code of the test module.
+
+        :param cmdlineargs: Any extra command line arguments to use.
+
+        :return: :py:class:`HookRecorder` instance of the result.
+
+        """
         p = self.makepyfile(source)
         l = list(cmdlineargs) + [p]
         return self.inline_run(*l)
 
-    def inline_runsource1(self, *args):
-        args = list(args)
-        source = args.pop()
-        p = self.makepyfile(source)
-        l = list(args) + [p]
-        reprec = self.inline_run(*l)
-        reports = reprec.getreports("pytest_runtest_logreport")
-        assert len(reports) == 3, reports # setup/call/teardown
-        return reports[1]
-
     def inline_genitems(self, *args):
-        return self.inprocess_run(list(args) + ['--collectonly'])
+        """Run ``pytest.main(['--collectonly'])`` in-process.
 
-    def inprocess_run(self, args, plugins=()):
-        rec = self.inline_run(*args, plugins=plugins)
+        Retuns a tuple of the collected items and a
+        :py:class:`HookRecorder` instance.
+
+        This runs the :py:func:`pytest.main` function to run all of
+        py.test inside the test process itself like
+        :py:meth:`inline_run`.  However the return value is a tuple of
+        the collection items and a :py:class:`HookRecorder` instance.
+
+        """
+        rec = self.inline_run("--collect-only", *args)
         items = [x.item for x in rec.getcalls("pytest_itemcollected")]
         return items, rec
 
     def inline_run(self, *args, **kwargs):
+        """Run ``pytest.main()`` in-process, returning a HookRecorder.
+
+        This runs the :py:func:`pytest.main` function to run all of
+        py.test inside the test process itself.  This means it can
+        return a :py:class:`HookRecorder` instance which gives more
+        detailed results from then run then can be done by matching
+        stdout/stderr from :py:meth:`runpytest`.
+
+        :param args: Any command line arguments to pass to
+           :py:func:`pytest.main`.
+
+        :param plugin: (keyword-only) Extra plugin instances the
+           ``pytest.main()`` instance should use.
+
+        :return: A :py:class:`HookRecorder` instance.
+
+        """
         rec = []
         class Collect:
             def pytest_configure(x, config):
                 rec.append(self.make_hook_recorder(config.pluginmanager))
+
         plugins = kwargs.get("plugins") or []
         plugins.append(Collect())
         ret = pytest.main(list(args), plugins=plugins)
-        assert len(rec) == 1
-        reprec = rec[0]
+        self.delete_loaded_modules()
+        if len(rec) == 1:
+            reprec = rec.pop()
+        else:
+            class reprec:
+                pass
         reprec.ret = ret
+
+        # typically we reraise keyboard interrupts from the child run
+        # because it's our user requesting interruption of the testing
+        if ret == 2 and not kwargs.get("no_reraise_ctrlc"):
+            calls = reprec.getcalls("pytest_keyboard_interrupt")
+            if calls and calls[-1].excinfo.type == KeyboardInterrupt:
+                raise KeyboardInterrupt()
         return reprec
 
-    def parseconfig(self, *args):
+    def runpytest_inprocess(self, *args, **kwargs):
+        """ Return result of running pytest in-process, providing a similar
+        interface to what self.runpytest() provides. """
+        if kwargs.get("syspathinsert"):
+            self.syspathinsert()
+        now = time.time()
+        capture = py.io.StdCapture()
+        try:
+            try:
+                reprec = self.inline_run(*args, **kwargs)
+            except SystemExit as e:
+                class reprec:
+                    ret = e.args[0]
+            except Exception:
+                traceback.print_exc()
+                class reprec:
+                    ret = 3
+        finally:
+            out, err = capture.reset()
+            sys.stdout.write(out)
+            sys.stderr.write(err)
+
+        res = RunResult(reprec.ret,
+                        out.split("\n"), err.split("\n"),
+                        time.time()-now)
+        res.reprec = reprec
+        return res
+
+    def runpytest(self, *args, **kwargs):
+        """ Run pytest inline or in a subprocess, depending on the command line
+        option "--runpytest" and return a :py:class:`RunResult`.
+
+        """
+        args = self._ensure_basetemp(args)
+        return self._runpytest_method(*args, **kwargs)
+
+    def _ensure_basetemp(self, args):
         args = [str(x) for x in args]
         for x in args:
             if str(x).startswith('--basetemp'):
+                #print ("basedtemp exists: %s" %(args,))
                 break
         else:
             args.append("--basetemp=%s" % self.tmpdir.dirpath('basetemp'))
+            #print ("added basetemp: %s" %(args,))
+        return args
+
+    def parseconfig(self, *args):
+        """Return a new py.test Config instance from given commandline args.
+
+        This invokes the py.test bootstrapping code in _pytest.config
+        to create a new :py:class:`_pytest.core.PluginManager` and
+        call the pytest_cmdline_parse hook to create new
+        :py:class:`_pytest.config.Config` instance.
+
+        If :py:attr:`plugins` has been populated they should be plugin
+        modules which will be registered with the PluginManager.
+
+        """
+        args = self._ensure_basetemp(args)
+
         import _pytest.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)
+        self.request.addfinalizer(config._ensure_unconfigure)
         return config
 
     def parseconfigure(self, *args):
+        """Return a new py.test configured Config instance.
+
+        This returns a new :py:class:`_pytest.config.Config` instance
+        like :py:meth:`parseconfig`, but also calls the
+        pytest_configure hook.
+
+        """
         config = self.parseconfig(*args)
-        config.do_configure()
-        self.request.addfinalizer(config.do_unconfigure)
+        config._do_configure()
+        self.request.addfinalizer(config._ensure_unconfigure)
         return config
 
     def getitem(self,  source, funcname="test_func"):
+        """Return the test item for a test function.
+
+        This writes the source to a python file and runs py.test's
+        collection on the resulting module, returning the test item
+        for the requested function name.
+
+        :param source: The module source.
+
+        :param funcname: The name of the test function for which the
+           Item must be returned.
+
+        """
         items = self.getitems(source)
         for item in items:
             if item.name == funcname:
@@ -424,10 +809,32 @@ class TmpTestdir:
                   funcname, source, items)
 
     def getitems(self,  source):
+        """Return all test items collected from the module.
+
+        This writes the source to a python file and runs py.test's
+        collection on the resulting module, returning all test items
+        contained within.
+
+        """
         modcol = self.getmodulecol(source)
         return self.genitems([modcol])
 
     def getmodulecol(self,  source, configargs=(), withinit=False):
+        """Return the module collection node for ``source``.
+
+        This writes ``source`` to a file using :py:meth:`makepyfile`
+        and then runs the py.test collection on it, returning the
+        collection node for the test module.
+
+        :param source: The source code of the module to collect.
+
+        :param configargs: Any extra arguments to pass to
+           :py:meth:`parseconfigure`.
+
+        :param withinit: Whether to also write a ``__init__.py`` file
+           to the temporarly directory to ensure it is a package.
+
+        """
         kw = {self.request.function.__name__: py.code.Source(source).strip()}
         path = self.makepyfile(**kw)
         if withinit:
@@ -437,11 +844,30 @@ class TmpTestdir:
         return node
 
     def collect_by_name(self, modcol, name):
+        """Return the collection node for name from the module collection.
+
+        This will search a module collection node for a collection
+        node matching the given name.
+
+        :param modcol: A module collection node, see
+           :py:meth:`getmodulecol`.
+
+        :param name: The name of the node to return.
+
+        """
         for colitem in modcol._memocollect():
             if colitem.name == name:
                 return colitem
 
     def popen(self, cmdargs, stdout, stderr, **kw):
+        """Invoke subprocess.Popen.
+
+        This calls subprocess.Popen making sure the current working
+        directory is the PYTHONPATH.
+
+        You probably want to use :py:meth:`run` instead.
+
+        """
         env = os.environ.copy()
         env['PYTHONPATH'] = os.pathsep.join(filter(None, [
             str(os.getcwd()), env.get('PYTHONPATH', '')]))
@@ -450,13 +876,22 @@ class TmpTestdir:
                                 stdout=stdout, stderr=stderr, **kw)
 
     def run(self, *cmdargs):
+        """Run a command with arguments.
+
+        Run a process using subprocess.Popen saving the stdout and
+        stderr.
+
+        Returns a :py:class:`RunResult`.
+
+        """
         return self._run(*cmdargs)
 
     def _run(self, *cmdargs):
         cmdargs = [str(x) for x in cmdargs]
         p1 = self.tmpdir.join("stdout")
         p2 = self.tmpdir.join("stderr")
-        print_("running", cmdargs, "curdir=", py.path.local())
+        print_("running:", ' '.join(cmdargs))
+        print_("     in:", str(py.path.local()))
         f1 = codecs.open(str(p1), "w", encoding="utf8")
         f2 = codecs.open(str(p2), "w", encoding="utf8")
         try:
@@ -486,38 +921,35 @@ class TmpTestdir:
         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 _getpytestargs(self):
+        # we cannot use "(sys.executable,script)"
+        # because on windows the script is e.g. a py.test.exe
+        return (sys.executable, _pytest_fullpath,) # noqa
 
-    def _getpybinargs(self, scriptname):
-        if not self.request.config.getvalue("notoolsonpath"):
-            # 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:
-            pytest.skip("cannot run %r with --no-tools-on-path" % scriptname)
+    def runpython(self, script):
+        """Run a python script using sys.executable as interpreter.
 
-    def runpython(self, script, prepend=True):
-        if prepend:
-            s = self._getsysprepend()
-            if s:
-                script.write(s + "\n" + script.read())
+        Returns a :py:class:`RunResult`.
+        """
         return self.run(sys.executable, script)
 
-    def _getsysprepend(self):
-        if self.request.config.getvalue("notoolsonpath"):
-            s = "import sys;sys.path.insert(0,%r);" % str(py._pydir.dirpath())
-        else:
-            s = ""
-        return s
-
     def runpython_c(self, command):
-        command = self._getsysprepend() + command
+        """Run python -c "command", return a :py:class:`RunResult`."""
         return self.run(sys.executable, "-c", command)
 
-    def runpytest(self, *args):
+    def runpytest_subprocess(self, *args, **kwargs):
+        """Run py.test as a subprocess with given arguments.
+
+        Any plugins added to the :py:attr:`plugins` list will added
+        using the ``-p`` command line option.  Addtionally
+        ``--basetemp`` is used put any temporary files and directories
+        in a numbered directory prefixed with "runpytest-" so they do
+        not conflict with the normal numberd pytest location for
+        temporary files and directories.
+
+        Returns a :py:class:`RunResult`.
+
+        """
         p = py.path.local.make_numbered_dir(prefix="runpytest-",
             keep=None, rootdir=self.tmpdir)
         args = ('--basetemp=%s' % p, ) + args
@@ -530,17 +962,28 @@ class TmpTestdir:
         plugins = [x for x in self.plugins if isinstance(x, str)]
         if plugins:
             args = ('-p', plugins[0]) + args
-        return self.runpybin("py.test", *args)
+        args = self._getpytestargs() + args
+        return self.run(*args)
 
     def spawn_pytest(self, string, expect_timeout=10.0):
-        if self.request.config.getvalue("notoolsonpath"):
-            pytest.skip("--no-tools-on-path prevents running pexpect-spawn tests")
+        """Run py.test using pexpect.
+
+        This makes sure to use the right py.test and sets up the
+        temporary directory locations.
+
+        The pexpect child is returned.
+
+        """
         basetemp = self.tmpdir.mkdir("pexpect")
-        invoke = " ".join(map(str, self._getpybinargs("py.test")))
+        invoke = " ".join(map(str, self._getpytestargs()))
         cmd = "%s --basetemp=%s %s" % (invoke, basetemp, string)
         return self.spawn(cmd, expect_timeout=expect_timeout)
 
     def spawn(self, cmd, expect_timeout=10.0):
+        """Run a command using pexpect.
+
+        The pexpect child is returned.
+        """
         pexpect = pytest.importorskip("pexpect", "3.0")
         if hasattr(sys, 'pypy_version_info') and '64' in platform.machine():
             pytest.skip("pypy-64 bit not supported")
@@ -577,11 +1020,23 @@ class LineComp:
         lines1 = val.split("\n")
         return LineMatcher(lines1).fnmatch_lines(lines2)
 
+
 class LineMatcher:
+    """Flexible matching of text.
+
+    This is a convenience class to test large texts like the output of
+    commands.
+
+    The constructor takes a list of lines without their trailing
+    newlines, i.e. ``text.splitlines()``.
+
+    """
+
     def __init__(self,  lines):
         self.lines = lines
 
     def str(self):
+        """Return the entire original text."""
         return "\n".join(self.lines)
 
     def _getlines(self, lines2):
@@ -592,6 +1047,12 @@ class LineMatcher:
         return lines2
 
     def fnmatch_lines_random(self, lines2):
+        """Check lines exist in the output.
+
+        The argument is a list of lines which have to occur in the
+        output, in any order.  Each line can contain glob whildcards.
+
+        """
         lines2 = self._getlines(lines2)
         for line in lines2:
             for x in self.lines:
@@ -602,12 +1063,24 @@ class LineMatcher:
                 raise ValueError("line %r not found in output" % line)
 
     def get_lines_after(self, fnline):
+        """Return all lines following the given line in the text.
+
+        The given line can contain glob wildcards.
+        """
         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):
+        """Search the text for matching lines.
+
+        The argument is a list of lines which have to match and can
+        use glob wildcards.  If they do not match an pytest.fail() is
+        called.  The matches and non-matches are also printed on
+        stdout.
+
+        """
         def show(arg1, arg2):
             py.builtin.print_(arg1, arg2, file=sys.stderr)
         lines2 = self._getlines(lines2)

_pytest/python.py

@@ -1,4 +1,5 @@
 """ Python test discovery, setup and run of test functions. """
+import re
 import fnmatch
 import functools
 import py
@@ -8,8 +9,18 @@ import pytest
 from _pytest.mark import MarkDecorator, MarkerError
 from py._code.code import TerminalRepr
 
+try:
+    import enum
+except ImportError:  # pragma: no cover
+    # Only available in Python 3.4+ or as a backport
+    enum = None
+
 import _pytest
-cutdir = py.path.local(_pytest.__file__).dirpath()
+import _pytest._pluggy as pluggy
+
+cutdir2 = py.path.local(_pytest.__file__).dirpath()
+cutdir1 = py.path.local(pluggy.__file__.rstrip("oc"))
+
 
 NoneType = type(None)
 NOTSET = object()
@@ -18,9 +29,31 @@ isclass = inspect.isclass
 callable = py.builtin.callable
 # used to work around a python2 exception info leak
 exc_clear = getattr(sys, 'exc_clear', lambda: None)
+# The type of re.compile objects is not exposed in Python.
+REGEX_TYPE = type(re.compile(''))
+
+_PY3 = sys.version_info > (3, 0)
+_PY2 = not _PY3
+
+
+if hasattr(inspect, 'signature'):
+    def _format_args(func):
+        return str(inspect.signature(func))
+else:
+    def _format_args(func):
+        return inspect.formatargspec(*inspect.getargspec(func))
+
+
+def _has_positional_arg(func):
+    return func.__code__.co_argcount
+
+
+def filter_traceback(entry):
+    return entry.path != cutdir1 and not entry.path.relto(cutdir2)
+
 
 def get_real_func(obj):
-    """gets the real function object of the (possibly) wrapped object by
+    """ gets the real function object of the (possibly) wrapped object by
     functools.wraps or functools.partial.
     """
     while hasattr(obj, "__wrapped__"):
@@ -47,6 +80,17 @@ def getimfunc(func):
         except AttributeError:
             return func
 
+def safe_getattr(object, name, default):
+    """ Like getattr but return default upon any Exception.
+
+    Attribute access can potentially fail for 'evil' Python objects.
+    See issue214
+    """
+    try:
+        return getattr(object, name, default)
+    except Exception:
+        return default
+
 
 class FixtureFunctionMarker:
     def __init__(self, scope, params,
@@ -145,6 +189,12 @@ def pytest_addoption(parser):
         help="prefixes or glob names for Python test function and "
              "method discovery")
 
+    group.addoption("--import-mode", default="prepend",
+        choices=["prepend", "append"], dest="importmode",
+        help="prepend/append to sys.path when importing test modules, "
+             "default is to prepend.")
+
+
 def pytest_cmdline_main(config):
     if config.option.showfixtures:
         showfixtures(config)
@@ -152,10 +202,13 @@ def pytest_cmdline_main(config):
 
 
 def pytest_generate_tests(metafunc):
-    # this misspelling is common - raise a specific error to alert the user
-    if hasattr(metafunc.function, 'parameterize'):
-        msg = "{0} has 'parameterize', spelling should be 'parametrize'"
-        raise MarkerError(msg.format(metafunc.function.__name__))
+    # those alternative spellings are common - raise a specific error to alert
+    # the user
+    alt_spellings = ['parameterize', 'parametrise', 'parameterise']
+    for attr in alt_spellings:
+        if hasattr(metafunc.function, attr):
+            msg = "{0} has '{1}', spelling should be 'parametrize'"
+            raise MarkerError(msg.format(metafunc.function.__name__, attr))
     try:
         markers = metafunc.function.parametrize
     except AttributeError:
@@ -182,7 +235,7 @@ def pytest_configure(config):
 def pytest_sessionstart(session):
     session._fixturemanager = FixtureManager(session)
 
-@pytest.mark.trylast
+@pytest.hookimpl(trylast=True)
 def pytest_namespace():
     raises.Exception = pytest.fail.Exception
     return {
@@ -201,7 +254,7 @@ def pytestconfig(request):
     return request.config
 
 
-@pytest.mark.trylast
+@pytest.hookimpl(trylast=True)
 def pytest_pyfunc_call(pyfuncitem):
     testfunction = pyfuncitem.obj
     if pyfuncitem._isyieldedfunction():
@@ -229,7 +282,7 @@ def pytest_collect_file(path, parent):
 def pytest_pycollect_makemodule(path, parent):
     return Module(path, parent)
 
-@pytest.mark.hookwrapper
+@pytest.hookimpl(hookwrapper=True)
 def pytest_pycollect_makeitem(collector, name, obj):
     outcome = yield
     res = outcome.get_result()
@@ -237,11 +290,10 @@ def pytest_pycollect_makeitem(collector, name, obj):
         raise StopIteration
     # nothing was collected elsewhere, let's do it here
     if isclass(obj):
-        if collector.classnamefilter(name):
+        if collector.istestclass(obj, name):
             Class = collector._getcustomclass("Class")
             outcome.force_result(Class(name, parent=collector))
-    elif collector.funcnamefilter(name) and hasattr(obj, "__call__") and\
-        getfixturemarker(obj) is None:
+    elif collector.istestfunction(obj, name):
         # mock seems to store unbound methods (issue473), normalize it
         obj = getattr(obj, "__func__", obj)
         if not isfunction(obj):
@@ -327,9 +379,24 @@ class PyCollector(PyobjMixin, pytest.Collector):
     def funcnamefilter(self, name):
         return self._matches_prefix_or_glob_option('python_functions', name)
 
+    def isnosetest(self, obj):
+        """ Look for the __test__ attribute, which is applied by the
+        @nose.tools.istest decorator
+        """
+        return safe_getattr(obj, '__test__', False)
+
     def classnamefilter(self, name):
         return self._matches_prefix_or_glob_option('python_classes', name)
 
+    def istestfunction(self, obj, name):
+        return (
+            (self.funcnamefilter(name) or self.isnosetest(obj))
+            and safe_getattr(obj, "__call__", False) and getfixturemarker(obj) is None
+        )
+
+    def istestclass(self, obj, name):
+        return self.classnamefilter(name) or self.isnosetest(obj)
+
     def _matches_prefix_or_glob_option(self, option_name, name):
         """
         checks if the given name matches the prefix or glob-pattern defined
@@ -385,13 +452,16 @@ class PyCollector(PyobjMixin, pytest.Collector):
         fixtureinfo = fm.getfixtureinfo(self, funcobj, cls)
         metafunc = Metafunc(funcobj, fixtureinfo, self.config,
                             cls=cls, module=module)
-        try:
-            methods = [module.pytest_generate_tests]
-        except AttributeError:
-            methods = []
+        methods = []
+        if hasattr(module, "pytest_generate_tests"):
+            methods.append(module.pytest_generate_tests)
         if hasattr(cls, "pytest_generate_tests"):
             methods.append(cls().pytest_generate_tests)
-        self.ihook.pytest_generate_tests.callextra(methods, metafunc=metafunc)
+        if methods:
+            self.ihook.pytest_generate_tests.call_extra(methods,
+                                                        dict(metafunc=metafunc))
+        else:
+            self.ihook.pytest_generate_tests(metafunc=metafunc)
 
         Function = self._getcustomclass("Function")
         if not metafunc._calls:
@@ -469,6 +539,19 @@ class FuncFixtureInfo:
         self.names_closure = names_closure
         self.name2fixturedefs = name2fixturedefs
 
+
+def _marked(func, mark):
+    """ Returns True if :func: is already marked with :mark:, False otherwise.
+    This can happen if marker is applied to class and the test file is
+    invoked more than once.
+    """
+    try:
+        func_mark = getattr(func, mark.name)
+    except AttributeError:
+        return False
+    return mark.args == func_mark.args and mark.kwargs == func_mark.kwargs
+
+
 def transfer_markers(funcobj, cls, mod):
     # XXX this should rather be code in the mark plugin or the mark
     # plugin should merge with the python plugin.
@@ -479,9 +562,11 @@ def transfer_markers(funcobj, cls, mod):
             continue
         if isinstance(pytestmark, list):
             for mark in pytestmark:
-                mark(funcobj)
+                if not _marked(funcobj, mark):
+                    mark(funcobj)
         else:
-            pytestmark(funcobj)
+            if not _marked(funcobj, pytestmark):
+                pytestmark(funcobj)
 
 class Module(pytest.File, PyCollector):
     """ Collector for test classes and functions. """
@@ -494,8 +579,9 @@ class Module(pytest.File, PyCollector):
 
     def _importtestmodule(self):
         # we assume we are only called once per module
+        importmode = self.config.getoption("--import-mode")
         try:
-            mod = self.fspath.pyimport(ensuresyspath=True)
+            mod = self.fspath.pyimport(ensuresyspath=importmode)
         except SyntaxError:
             raise self.CollectError(
                 py.code.ExceptionInfo().getrepr(style="short"))
@@ -523,7 +609,7 @@ class Module(pytest.File, PyCollector):
             #XXX: nose compat hack, move to nose plugin
             # if it takes a positional arg, its probably a pytest style one
             # so we pass the current module object
-            if inspect.getargspec(setup_module)[0]:
+            if _has_positional_arg(setup_module):
                 setup_module(self.obj)
             else:
                 setup_module()
@@ -534,7 +620,7 @@ class Module(pytest.File, PyCollector):
             #XXX: nose compat hack, move to nose plugin
             # if it takes a positional arg, it's probably a pytest style one
             # so we pass the current module object
-            if inspect.getargspec(fin)[0]:
+            if _has_positional_arg(fin):
                 finalizer = lambda: fin(self.obj)
             else:
                 finalizer = fin
@@ -611,7 +697,11 @@ class FunctionMixin(PyobjMixin):
             if ntraceback == traceback:
                 ntraceback = ntraceback.cut(path=path)
                 if ntraceback == traceback:
-                    ntraceback = ntraceback.cut(excludepath=cutdir)
+                    #ntraceback = ntraceback.cut(excludepath=cutdir2)
+                    ntraceback = ntraceback.filter(filter_traceback)
+                    if not ntraceback:
+                        ntraceback = traceback
+
             excinfo.traceback = ntraceback.filter()
             # issue364: mark all but first and last frames to
             # only show a single-line message for each frame
@@ -746,11 +836,12 @@ class CallSpec2(object):
     def id(self):
         return "-".join(map(str, filter(None, self._idlist)))
 
-    def setmulti(self, valtype, argnames, valset, id, keywords, scopenum,
+    def setmulti(self, valtypes, argnames, valset, id, keywords, scopenum,
                  param_index):
         for arg,val in zip(argnames, valset):
             self._checkargnotcontained(arg)
-            getattr(self, valtype)[arg] = val
+            valtype_for_arg = valtypes[arg]
+            getattr(self, valtype_for_arg)[arg] = val
             self.indices[arg] = param_index
             self._arg2scopenum[arg] = scopenum
             if val is _notexists:
@@ -781,6 +872,27 @@ class FuncargnamesCompatAttr:
         return self.fixturenames
 
 class Metafunc(FuncargnamesCompatAttr):
+    """
+    Metafunc objects are passed to the ``pytest_generate_tests`` hook.
+    They help to inspect a test function and to generate tests according to
+    test configuration or values specified in the class or module where a
+    test function is defined.
+
+    :ivar fixturenames: set of fixture names required by the test function
+
+    :ivar function: underlying python test function
+
+    :ivar cls: class object where the test function is defined in or ``None``.
+
+    :ivar module: the module object where the test function is defined in.
+
+    :ivar config: access to the :class:`_pytest.config.Config` object for the
+        test session.
+
+    :ivar funcargnames:
+        .. deprecated:: 2.3
+            Use ``fixturenames`` instead.
+    """
     def __init__(self, function, fixtureinfo, config, cls=None, module=None):
         self.config = config
         self.module = module
@@ -796,19 +908,21 @@ class Metafunc(FuncargnamesCompatAttr):
         """ Add new invocations to the underlying test function using the list
         of argvalues for the given argnames.  Parametrization is performed
         during the collection phase.  If you need to setup expensive resources
-        see about setting indirect=True to do it rather at test setup time.
+        see about setting indirect to do it rather at test setup time.
 
         :arg argnames: a comma-separated string denoting one or more argument
                        names, or a list/tuple of argument strings.
 
         :arg argvalues: The list of argvalues determines how often a
             test is invoked with different argument values.  If only one
-            argname was specified argvalues is a list of simple values.  If N
+            argname was specified argvalues is a list of values.  If N
             argnames were specified, argvalues must be a list of N-tuples,
             where each tuple-element specifies a value for its respective
             argname.
 
-        :arg indirect: if True each argvalue corresponding to an argname will
+        :arg indirect: The list of argnames or boolean. A list of arguments'
+            names (subset of argnames). If True the list contains all names from
+            the argnames. Each argvalue corresponding to an argname in this list will
             be passed as request.param to its respective argname fixture
             function so that it can perform more expensive setups during the
             setup phase of a test rather than at collection time.
@@ -853,13 +967,22 @@ class Metafunc(FuncargnamesCompatAttr):
         if scope is None:
             scope = "function"
         scopenum = scopes.index(scope)
-        if not indirect:
-            #XXX should we also check for the opposite case?
-            for arg in argnames:
-                if arg not in self.fixturenames:
-                    raise ValueError("%r uses no fixture %r" %(
+        valtypes = {}
+        for arg in argnames:
+            if arg not in self.fixturenames:
+                raise ValueError("%r uses no fixture %r" %(self.function, arg))
+
+        if indirect is True:
+            valtypes = dict.fromkeys(argnames, "params")
+        elif indirect is False:
+            valtypes = dict.fromkeys(argnames, "funcargs")
+        elif isinstance(indirect, (tuple, list)):
+            valtypes = dict.fromkeys(argnames, "funcargs")
+            for arg in indirect:
+                if arg not in argnames:
+                    raise ValueError("indirect given to %r: fixture %r doesn't exist" %(
                                      self.function, arg))
-        valtype = indirect and "params" or "funcargs"
+                valtypes[arg] = "params"
         idfn = None
         if callable(ids):
             idfn = ids
@@ -874,7 +997,7 @@ class Metafunc(FuncargnamesCompatAttr):
             for param_index, valset in enumerate(argvalues):
                 assert len(valset) == len(argnames)
                 newcallspec = callspec.copy(self)
-                newcallspec.setmulti(valtype, argnames, valset, ids[param_index],
+                newcallspec.setmulti(valtypes, argnames, valset, ids[param_index],
                                      newkeywords.get(param_index, {}), scopenum,
                                      param_index)
                 newcalls.append(newcallspec)
@@ -917,6 +1040,35 @@ class Metafunc(FuncargnamesCompatAttr):
         self._calls.append(cs)
 
 
+if _PY3:
+    def _escape_bytes(val):
+        """
+        If val is pure ascii, returns it as a str(), otherwise escapes
+        into a sequence of escaped bytes:
+        b'\xc3\xb4\xc5\xd6' -> u'\\xc3\\xb4\\xc5\\xd6'
+
+        note:
+           the obvious "v.decode('unicode-escape')" will return
+           valid utf-8 unicode if it finds them in the string, but we
+           want to return escaped bytes for any byte, even if they match
+           a utf-8 string.
+        """
+        # source: http://goo.gl/bGsnwC
+        import codecs
+        encoded_bytes, _ = codecs.escape_encode(val)
+        return encoded_bytes.decode('ascii')
+else:
+    def _escape_bytes(val):
+        """
+        In py2 bytes and str are the same, so return it unchanged if it
+        is a full ascii string, otherwise escape it into its binary form.
+        """
+        try:
+            return val.encode('ascii')
+        except UnicodeDecodeError:
+            return val.encode('string-escape')
+
+
 def _idval(val, argname, idx, idfn):
     if idfn:
         try:
@@ -925,8 +1077,25 @@ def _idval(val, argname, idx, idfn):
                 return s
         except Exception:
             pass
-    if isinstance(val, (float, int, str, bool, NoneType)):
+
+    if isinstance(val, bytes):
+        return _escape_bytes(val)
+    elif isinstance(val, (float, int, str, bool, NoneType)):
         return str(val)
+    elif isinstance(val, REGEX_TYPE):
+        return val.pattern
+    elif enum is not None and isinstance(val, enum.Enum):
+        return str(val)
+    elif isclass(val) and hasattr(val, '__name__'):
+        return val.__name__
+    elif _PY2 and isinstance(val, unicode):
+        # special case for python 2: if a unicode string is
+        # convertible to ascii, return it as an str() object instead
+        try:
+            return str(val)
+        except UnicodeDecodeError:
+            # fallthrough
+            pass
     return str(argname)+str(idx)
 
 def _idvalset(idx, valset, argnames, idfn):
@@ -1001,8 +1170,8 @@ def getlocation(function, curdir):
 
 # builtin pytest.raises helper
 
-def raises(ExpectedException, *args, **kwargs):
-    """ assert that a code block/function call raises @ExpectedException
+def raises(expected_exception, *args, **kwargs):
+    """ assert that a code block/function call raises @expected_exception
     and raise a failure exception otherwise.
 
     This helper produces a ``py.code.ExceptionInfo()`` object.
@@ -1050,23 +1219,23 @@ def raises(ExpectedException, *args, **kwargs):
 
     """
     __tracebackhide__ = True
-    if ExpectedException is AssertionError:
+    if expected_exception is AssertionError:
         # we want to catch a AssertionError
         # replace our subclass with the builtin one
-        # see https://bitbucket.org/pytest-dev/pytest/issue/176/pytestraises
+        # see https://github.com/pytest-dev/pytest/issues/176
         from _pytest.assertion.util import BuiltinAssertionError \
-            as ExpectedException
+            as expected_exception
     msg = ("exceptions must be old-style classes or"
            " derived from BaseException, not %s")
-    if isinstance(ExpectedException, tuple):
-        for exc in ExpectedException:
-            if not inspect.isclass(exc):
+    if isinstance(expected_exception, tuple):
+        for exc in expected_exception:
+            if not isclass(exc):
                 raise TypeError(msg % type(exc))
-    elif not inspect.isclass(ExpectedException):
-        raise TypeError(msg % type(ExpectedException))
+    elif not isclass(expected_exception):
+        raise TypeError(msg % type(expected_exception))
 
     if not args:
-        return RaisesContext(ExpectedException)
+        return RaisesContext(expected_exception)
     elif isinstance(args[0], str):
         code, = args
         assert isinstance(code, str)
@@ -1079,19 +1248,19 @@ def raises(ExpectedException, *args, **kwargs):
             py.builtin.exec_(code, frame.f_globals, loc)
             # XXX didn'T mean f_globals == f_locals something special?
             #     this is destroyed here ...
-        except ExpectedException:
+        except expected_exception:
             return py.code.ExceptionInfo()
     else:
         func = args[0]
         try:
             func(*args[1:], **kwargs)
-        except ExpectedException:
+        except expected_exception:
             return py.code.ExceptionInfo()
     pytest.fail("DID NOT RAISE")
 
 class RaisesContext(object):
-    def __init__(self, ExpectedException):
-        self.ExpectedException = ExpectedException
+    def __init__(self, expected_exception):
+        self.expected_exception = expected_exception
         self.excinfo = None
 
     def __enter__(self):
@@ -1110,7 +1279,7 @@ class RaisesContext(object):
                 exc_type, value, traceback = tp
                 tp = exc_type, exc_type(value), traceback
         self.excinfo.__init__(tp)
-        return issubclass(self.excinfo.type, self.ExpectedException)
+        return issubclass(self.excinfo.type, self.expected_exception)
 
 #
 #  the basic pytest Function item
@@ -1309,7 +1478,7 @@ class FixtureRequest(FuncargnamesCompatAttr):
         return self._pyfuncitem.session
 
     def addfinalizer(self, finalizer):
-        """add finalizer/teardown function to be called after the
+        """ add finalizer/teardown function to be called after the
         last test within the requesting test context finished
         execution. """
         # XXX usually this method is shadowed by fixturedef specific ones
@@ -1473,7 +1642,7 @@ class FixtureRequest(FuncargnamesCompatAttr):
             factory = fixturedef.func
             fs, lineno = getfslineno(factory)
             p = self._pyfuncitem.session.fspath.bestrelpath(fs)
-            args = inspect.formatargspec(*inspect.getargspec(factory))
+            args = _format_args(factory)
             lines.append("%s:%d:  def %s%s" %(
                 p, lineno, factory.__name__, args))
         return lines
@@ -1631,7 +1800,6 @@ class FixtureManager:
         self.session = session
         self.config = session.config
         self._arg2fixturedefs = {}
-        self._seenplugins = set()
         self._holderobjseen = set()
         self._arg2finish = {}
         self._nodeid_and_autousenames = [("", self.config.getini("usefixtures"))]
@@ -1656,11 +1824,7 @@ class FixtureManager:
                                                               node)
         return FuncFixtureInfo(argnames, names_closure, arg2fixturedefs)
 
-    ### XXX this hook should be called for historic events like pytest_configure
-    ### so that we don't have to do the below pytest_configure hook
     def pytest_plugin_registered(self, plugin):
-        if plugin in self._seenplugins:
-            return
         nodeid = None
         try:
             p = py.path.local(plugin.__file__)
@@ -1675,13 +1839,6 @@ class FixtureManager:
                 if p.sep != "/":
                     nodeid = nodeid.replace(p.sep, "/")
         self.parsefactories(plugin, nodeid)
-        self._seenplugins.add(plugin)
-
-    @pytest.mark.tryfirst
-    def pytest_configure(self, config):
-        plugins = config.pluginmanager.getplugins()
-        for plugin in plugins:
-            self.pytest_plugin_registered(plugin)
 
     def _getautousenames(self, nodeid):
         """ return a tuple of fixture names to be used. """
@@ -1735,7 +1892,10 @@ class FixtureManager:
                 if fixturedef.params is not None:
                     func_params = getattr(getattr(metafunc.function, 'parametrize', None), 'args', [[None]])
                     # skip directly parametrized arguments
-                    if argname not in func_params and argname not in func_params[0]:
+                    argnames = func_params[0]
+                    if not isinstance(argnames, (tuple, list)):
+                        argnames = [x.strip() for x in argnames.split(",") if x.strip()]
+                    if argname not in func_params and argname not in argnames:
                         metafunc.parametrize(argname, fixturedef.params,
                                              indirect=True, scope=fixturedef.scope,
                                              ids=fixturedef.ids)
@@ -1758,14 +1918,14 @@ class FixtureManager:
         autousenames = []
         for name in dir(holderobj):
             obj = getattr(holderobj, name, None)
-            if not callable(obj):
-                continue
             # fixture functions have a pytest_funcarg__ prefix (pre-2.3 style)
             # or are "@pytest.fixture" marked
             marker = getfixturemarker(obj)
             if marker is None:
                 if not name.startswith(self._argprefix):
                     continue
+                if not callable(obj):
+                    continue
                 marker = defaultfuncargprefixmarker
                 name = name[len(self._argprefix):]
             elif not isinstance(marker, FixtureFunctionMarker):

_pytest/recwarn.py

@@ -1,10 +1,14 @@
 """ recording warnings during test function execution. """
 
+import inspect
+import py
 import sys
 import warnings
+import pytest
 
 
-def pytest_funcarg__recwarn(request):
+@pytest.yield_fixture
+def recwarn(request):
     """Return a WarningsRecorder instance that provides these methods:
 
     * ``pop(category=None)``: return last warning matching the category.
@@ -13,83 +17,174 @@ def pytest_funcarg__recwarn(request):
     See http://docs.python.org/library/warnings.html for information
     on warning categories.
     """
-    if sys.version_info >= (2,7):
-        oldfilters = warnings.filters[:]
-        warnings.simplefilter('default')
-        def reset_filters():
-            warnings.filters[:] = oldfilters
-        request.addfinalizer(reset_filters)
     wrec = WarningsRecorder()
-    request.addfinalizer(wrec.finalize)
-    return wrec
+    with wrec:
+        warnings.simplefilter('default')
+        yield wrec
+
 
 def pytest_namespace():
-    return {'deprecated_call': deprecated_call}
+    return {'deprecated_call': deprecated_call,
+            'warns': warns}
+
 
 def deprecated_call(func, *args, **kwargs):
-    """ assert that calling ``func(*args, **kwargs)``
-    triggers a DeprecationWarning.
+    """Assert that ``func(*args, **kwargs)`` triggers a DeprecationWarning.
     """
-    l = []
-    oldwarn_explicit = getattr(warnings, 'warn_explicit')
-    def warn_explicit(*args, **kwargs):
-        l.append(args)
-        oldwarn_explicit(*args, **kwargs)
-    oldwarn = getattr(warnings, 'warn')
-    def warn(*args, **kwargs):
-        l.append(args)
-        oldwarn(*args, **kwargs)
-
-    warnings.warn_explicit = warn_explicit
-    warnings.warn = warn
-    try:
+    wrec = WarningsRecorder()
+    with wrec:
+        warnings.simplefilter('always')  # ensure all warnings are triggered
         ret = func(*args, **kwargs)
-    finally:
-        warnings.warn_explicit = oldwarn_explicit
-        warnings.warn = oldwarn
-    if not l:
+
+    depwarnings = (DeprecationWarning, PendingDeprecationWarning)
+    if not any(r.category in depwarnings for r in wrec):
         __tracebackhide__ = True
-        raise AssertionError("%r did not produce DeprecationWarning" %(func,))
+        raise AssertionError("%r did not produce DeprecationWarning" % (func,))
+
     return ret
 
 
-class RecordedWarning:
-    def __init__(self, message, category, filename, lineno, line):
+def warns(expected_warning, *args, **kwargs):
+    """Assert that code raises a particular class of warning.
+
+    Specifically, the input @expected_warning can be a warning class or
+    tuple of warning classes, and the code must return that warning
+    (if a single class) or one of those warnings (if a tuple).
+
+    This helper produces a list of ``warnings.WarningMessage`` objects,
+    one for each warning raised.
+
+    This function can be used as a context manager, or any of the other ways
+    ``pytest.raises`` can be used::
+
+        >>> with warns(RuntimeWarning):
+        ...    warnings.warn("my warning", RuntimeWarning)
+    """
+    wcheck = WarningsChecker(expected_warning)
+    if not args:
+        return wcheck
+    elif isinstance(args[0], str):
+        code, = args
+        assert isinstance(code, str)
+        frame = sys._getframe(1)
+        loc = frame.f_locals.copy()
+        loc.update(kwargs)
+
+        with wcheck:
+            code = py.code.Source(code).compile()
+            py.builtin.exec_(code, frame.f_globals, loc)
+    else:
+        func = args[0]
+        with wcheck:
+            return func(*args[1:], **kwargs)
+
+
+class RecordedWarning(object):
+    def __init__(self, message, category, filename, lineno, file, line):
         self.message = message
         self.category = category
         self.filename = filename
         self.lineno = lineno
+        self.file = file
         self.line = line
 
-class WarningsRecorder:
-    def __init__(self):
-        self.list = []
-        def showwarning(message, category, filename, lineno, line=0):
-            self.list.append(RecordedWarning(
-                message, category, filename, lineno, line))
-            try:
-                self.old_showwarning(message, category,
-                    filename, lineno, line=line)
-            except TypeError:
-                # < python2.6
-                self.old_showwarning(message, category, filename, lineno)
-        self.old_showwarning = warnings.showwarning
-        warnings.showwarning = showwarning
+
+class WarningsRecorder(object):
+    """A context manager to record raised warnings.
+
+    Adapted from `warnings.catch_warnings`.
+    """
+
+    def __init__(self, module=None):
+        self._module = sys.modules['warnings'] if module is None else module
+        self._entered = False
+        self._list = []
+
+    @property
+    def list(self):
+        """The list of recorded warnings."""
+        return self._list
+
+    def __getitem__(self, i):
+        """Get a recorded warning by index."""
+        return self._list[i]
+
+    def __iter__(self):
+        """Iterate through the recorded warnings."""
+        return iter(self._list)
+
+    def __len__(self):
+        """The number of recorded warnings."""
+        return len(self._list)
 
     def pop(self, cls=Warning):
-        """ pop the first recorded warning, raise exception if not exists."""
-        for i, w in enumerate(self.list):
+        """Pop the first recorded warning, raise exception if not exists."""
+        for i, w in enumerate(self._list):
             if issubclass(w.category, cls):
-                return self.list.pop(i)
+                return self._list.pop(i)
         __tracebackhide__ = True
-        assert 0, "%r not found in %r" %(cls, self.list)
-
-    #def resetregistry(self):
-    #    warnings.onceregistry.clear()
-    #    warnings.__warningregistry__.clear()
+        raise AssertionError("%r not found in warning list" % cls)
 
     def clear(self):
-        self.list[:] = []
+        """Clear the list of recorded warnings."""
+        self._list[:] = []
 
-    def finalize(self):
-        warnings.showwarning = self.old_showwarning
+    def __enter__(self):
+        if self._entered:
+            __tracebackhide__ = True
+            raise RuntimeError("Cannot enter %r twice" % self)
+        self._entered = True
+        self._filters = self._module.filters
+        self._module.filters = self._filters[:]
+        self._showwarning = self._module.showwarning
+
+        def showwarning(message, category, filename, lineno,
+                        file=None, line=None):
+            self._list.append(RecordedWarning(
+                message, category, filename, lineno, file, line))
+
+            # still perform old showwarning functionality
+            self._showwarning(
+                message, category, filename, lineno, file=file, line=line)
+
+        self._module.showwarning = showwarning
+
+        # allow the same warning to be raised more than once
+        self._module.simplefilter('always', append=True)
+
+        return self
+
+    def __exit__(self, *exc_info):
+        if not self._entered:
+            __tracebackhide__ = True
+            raise RuntimeError("Cannot exit %r without entering first" % self)
+        self._module.filters = self._filters
+        self._module.showwarning = self._showwarning
+
+
+class WarningsChecker(WarningsRecorder):
+    def __init__(self, expected_warning=None, module=None):
+        super(WarningsChecker, self).__init__(module=module)
+
+        msg = ("exceptions must be old-style classes or "
+               "derived from Warning, not %s")
+        if isinstance(expected_warning, tuple):
+            for exc in expected_warning:
+                if not inspect.isclass(exc):
+                    raise TypeError(msg % type(exc))
+        elif inspect.isclass(expected_warning):
+            expected_warning = (expected_warning,)
+        elif expected_warning is not None:
+            raise TypeError(msg % type(expected_warning))
+
+        self.expected_warning = expected_warning
+
+    def __exit__(self, *exc_info):
+        super(WarningsChecker, self).__exit__(*exc_info)
+
+        # only check if we're not currently handling an exception
+        if all(a is None for a in exc_info):
+            if self.expected_warning is not None:
+                if not any(r.category in self.expected_warning for r in self):
+                    __tracebackhide__ = True
+                    pytest.fail("DID NOT WARN")

_pytest/runner.py

@@ -226,7 +226,7 @@ def pytest_runtest_makereport(item, call):
                 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))
+        sections.append(("Captured %s %s" %(key, rwhen), content))
     return TestReport(item.nodeid, item.location,
                       keywords, outcome, longrepr, when,
                       sections, duration)

_pytest/skipping.py

@@ -145,7 +145,7 @@ class MarkEvaluator:
         return expl
 
 
-@pytest.mark.tryfirst
+@pytest.hookimpl(tryfirst=True)
 def pytest_runtest_setup(item):
     evalskip = MarkEvaluator(item, 'skipif')
     if evalskip.istrue():
@@ -164,7 +164,7 @@ def check_xfail_no_run(item):
             if not evalxfail.get('run', True):
                 pytest.xfail("[NOTRUN] " + evalxfail.getexplanation())
 
-@pytest.mark.hookwrapper
+@pytest.hookimpl(hookwrapper=True)
 def pytest_runtest_makereport(item, call):
     outcome = yield
     rep = outcome.get_result()

_pytest/standalonetemplate.py

@@ -68,6 +68,11 @@ class DictImporter(object):
         return res
 
 if __name__ == "__main__":
+    try:
+        import pkg_resources  # noqa
+    except ImportError:
+        sys.stderr.write("ERROR: setuptools not installed\n")
+        sys.exit(2)
     if sys.version_info >= (3, 0):
         exec("def do_exec(co, loc): exec(co, loc)\n")
         import pickle
@@ -80,6 +85,5 @@ if __name__ == "__main__":
 
     importer = DictImporter(sources)
     sys.meta_path.insert(0, importer)
-
     entry = "@ENTRY@"
     do_exec(entry, locals()) # noqa

_pytest/terminal.py

@@ -2,10 +2,15 @@
 
 This is a good source for looking at the various reporting hooks.
 """
+from _pytest.main import EXIT_OK, EXIT_TESTSFAILED, EXIT_INTERRUPTED, \
+    EXIT_USAGEERROR, EXIT_NOTESTSCOLLECTED
 import pytest
 import py
 import sys
 import time
+import platform
+
+import _pytest._pluggy as pluggy
 
 
 def pytest_addoption(parser):
@@ -17,7 +22,7 @@ def pytest_addoption(parser):
     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 (w)warnings.")
+              "(E)error, (s)skipped, (x)failed, (X)passed (w)pytest-warnings (a)all.")
     group._addoption('-l', '--showlocals',
          action="store_true", dest="showlocals", default=False,
          help="show locals in tracebacks (disabled by default).")
@@ -62,8 +67,10 @@ def getreportopt(config):
     reportchars = config.option.reportchars
     if reportchars:
         for char in reportchars:
-            if char not in reportopts:
+            if char not in reportopts and char != 'a':
                 reportopts += char
+            elif char == 'a':
+                reportopts = 'fEsxXw'
     return reportopts
 
 def pytest_report_teststatus(report):
@@ -162,6 +169,8 @@ class TerminalReporter:
 
     def pytest_logwarning(self, code, fslocation, message, nodeid):
         warnings = self.stats.setdefault("warnings", [])
+        if isinstance(fslocation, tuple):
+            fslocation = "%s:%d" % fslocation
         warning = WarningReport(code=code, fslocation=fslocation,
                                 message=message, nodeid=nodeid)
         warnings.append(warning)
@@ -263,18 +272,19 @@ class TerminalReporter:
     def pytest_collection_modifyitems(self):
         self.report_collect(True)
 
-    @pytest.mark.trylast
+    @pytest.hookimpl(trylast=True)
     def pytest_sessionstart(self, session):
         self._sessionstarttime = time.time()
         if not self.showheader:
             return
         self.write_sep("=", "test session starts", bold=True)
-        verinfo = ".".join(map(str, sys.version_info[:3]))
+        verinfo = platform.python_version()
         msg = "platform %s -- Python %s" % (sys.platform, verinfo)
         if hasattr(sys, 'pypy_version_info'):
             verinfo = ".".join(map(str, sys.pypy_version_info[:3]))
             msg += "[pypy-%s-%s]" % (verinfo, sys.pypy_version_info[3])
-        msg += " -- py-%s -- pytest-%s" % (py.__version__, pytest.__version__)
+        msg += ", pytest-%s, py-%s, pluggy-%s" % (
+               pytest.__version__, py.__version__, pluggy.__version__)
         if self.verbosity > 0 or self.config.option.debug or \
            getattr(self.config.option, 'pastebin', None):
             msg += " -- " + str(sys.executable)
@@ -290,15 +300,12 @@ class TerminalReporter:
         if config.inifile:
             inifile = config.rootdir.bestrelpath(config.inifile)
         lines = ["rootdir: %s, inifile: %s" %(config.rootdir, inifile)]
-        plugininfo = config.pluginmanager._plugin_distinfo
+
+        plugininfo = config.pluginmanager.list_plugin_distinfo()
         if plugininfo:
-            l = []
-            for dist, plugin in plugininfo:
-                name = dist.project_name
-                if name.startswith("pytest-"):
-                    name = name[7:]
-                l.append(name)
-            lines.append("plugins: %s" % ", ".join(l))
+
+            lines.append(
+                "plugins: %s" % ", ".join(_plugin_nameversions(plugininfo)))
         return lines
 
     def pytest_collection_finish(self, session):
@@ -348,17 +355,20 @@ class TerminalReporter:
                 indent = (len(stack) - 1) * "  "
                 self._tw.line("%s%s" % (indent, col))
 
-    @pytest.mark.hookwrapper
+    @pytest.hookimpl(hookwrapper=True)
     def pytest_sessionfinish(self, exitstatus):
         outcome = yield
         outcome.get_result()
         self._tw.line("")
-        if exitstatus in (0, 1, 2, 4):
+        summary_exit_codes = (
+            EXIT_OK, EXIT_TESTSFAILED, EXIT_INTERRUPTED, EXIT_USAGEERROR,
+            EXIT_NOTESTSCOLLECTED)
+        if exitstatus in summary_exit_codes:
             self.summary_errors()
             self.summary_failures()
             self.summary_warnings()
             self.config.hook.pytest_terminal_summary(terminalreporter=self)
-        if exitstatus == 2:
+        if exitstatus == EXIT_INTERRUPTED:
             self._report_keyboardinterrupt()
             del self._keyboardinterrupt_memo
         self.summary_deselected()
@@ -431,7 +441,7 @@ class TerminalReporter:
             warnings = self.stats.get("warnings")
             if not warnings:
                 return
-            self.write_sep("=", "warning summary")
+            self.write_sep("=", "pytest-warning summary")
             for w in warnings:
                 self._tw.line("W%s %s %s" % (w.code,
                               w.fslocation, w.message))
@@ -479,26 +489,9 @@ class TerminalReporter:
 
     def summary_stats(self):
         session_duration = time.time() - self._sessionstarttime
-
-        keys = ("failed passed skipped deselected "
-               "xfailed xpassed warnings").split()
-        for key in self.stats.keys():
-            if key not in keys:
-                keys.append(key)
-        parts = []
-        for key in keys:
-            if key: # setup/teardown reports have an empty key, ignore them
-                val = self.stats.get(key, None)
-                if val:
-                    parts.append("%d %s" % (len(val), key))
-        line = ", ".join(parts)
+        (line, color) = build_summary_stats_line(self.stats)
         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:
-            markup = {'green': True, 'bold': True}
+        markup = {color: True, 'bold': True}
 
         if self.verbosity >= 0:
             self.write_sep("=", msg, **markup)
@@ -534,3 +527,46 @@ def flatten(l):
         else:
             yield x
 
+def build_summary_stats_line(stats):
+    keys = ("failed passed skipped deselected "
+           "xfailed xpassed warnings error").split()
+    key_translation = {'warnings': 'pytest-warnings'}
+    unknown_key_seen = False
+    for key in stats.keys():
+        if key not in keys:
+            if key: # setup/teardown reports have an empty key, ignore them
+                keys.append(key)
+                unknown_key_seen = True
+    parts = []
+    for key in keys:
+        val = stats.get(key, None)
+        if val:
+            key_name = key_translation.get(key, key)
+            parts.append("%d %s" % (len(val), key_name))
+    line = ", ".join(parts)
+
+    if 'failed' in stats or 'error' in stats:
+        color = 'red'
+    elif 'warnings' in stats or unknown_key_seen:
+        color = 'yellow'
+    elif 'passed' in stats:
+        color = 'green'
+    else:
+        color = 'yellow'
+
+    return (line, color)
+
+
+def _plugin_nameversions(plugininfo):
+    l = []
+    for plugin, dist in plugininfo:
+        # gets us name and version!
+        name = '{dist.project_name}-{dist.version}'.format(dist=dist)
+        # questionable convenience, but it keeps things short
+        if name.startswith("pytest-"):
+            name = name[7:]
+        # we decided to print python package names
+        # they can have more than one plugin
+        if name not in l:
+            l.append(name)
+    return l

_pytest/tmpdir.py

@@ -6,7 +6,12 @@ import py
 from _pytest.monkeypatch import monkeypatch
 
 
-class TempdirHandler:
+class TempdirFactory:
+    """Factory for temporary directories under the common base temp directory.
+
+    The base directory can be configured using the ``--basetemp`` option.
+    """
+
     def __init__(self, config):
         self.config = config
         self.trace = config.trace.get("tmpdir")
@@ -22,6 +27,10 @@ class TempdirHandler:
         return self.getbasetemp().ensure(string, dir=dir)
 
     def mktemp(self, basename, numbered=True):
+        """Create a subdirectory of the base temporary directory and return it.
+        If ``numbered``, ensure the directory is unique by adding a number
+        prefix greater than any existing one.
+        """
         basetemp = self.getbasetemp()
         if not numbered:
             p = basetemp.mkdir(basename)
@@ -43,11 +52,14 @@ class TempdirHandler:
                     basetemp.remove()
                 basetemp.mkdir()
             else:
-                # use a sub-directory in the temproot to speed-up
-                # make_numbered_dir() call
-                import getpass
                 temproot = py.path.local.get_temproot()
-                rootdir = temproot.join('pytest-%s' % getpass.getuser())
+                user = get_user()
+                if user:
+                    # use a sub-directory in the temproot to speed-up
+                    # make_numbered_dir() call
+                    rootdir = temproot.join('pytest-of-%s' % user)
+                else:
+                    rootdir = temproot
                 rootdir.ensure(dir=1)
                 basetemp = py.path.local.make_numbered_dir(prefix='pytest-',
                                                            rootdir=rootdir)
@@ -58,15 +70,44 @@ class TempdirHandler:
     def finish(self):
         self.trace("finish")
 
+
+def get_user():
+    """Return the current user name, or None if getuser() does not work
+    in the current environment (see #1010).
+    """
+    import getpass
+    try:
+        return getpass.getuser()
+    except (ImportError, KeyError):
+        return None
+
+# backward compatibility
+TempdirHandler = TempdirFactory
+
+
 def pytest_configure(config):
+    """Create a TempdirFactory and attach it to the config object.
+
+    This is to comply with existing plugins which expect the handler to be
+    available at pytest_configure time, but ideally should be moved entirely
+    to the tmpdir_factory session fixture.
+    """
     mp = monkeypatch()
-    t = TempdirHandler(config)
+    t = TempdirFactory(config)
     config._cleanup.extend([mp.undo, t.finish])
     mp.setattr(config, '_tmpdirhandler', t, raising=False)
     mp.setattr(pytest, 'ensuretemp', t.ensuretemp, raising=False)
 
+
+@pytest.fixture(scope='session')
+def tmpdir_factory(request):
+    """Return a TempdirFactory instance for the test session.
+    """
+    return request.config._tmpdirhandler
+
+
 @pytest.fixture
-def tmpdir(request):
+def tmpdir(request, tmpdir_factory):
     """return a temporary directory path object
     which is unique to each test function invocation,
     created as a sub directory of the base temporary
@@ -78,5 +119,5 @@ def tmpdir(request):
     MAXVAL = 30
     if len(name) > MAXVAL:
         name = name[:MAXVAL]
-    x = request.config._tmpdirhandler.mktemp(name, numbered=True)
+    x = tmpdir_factory.mktemp(name, numbered=True)
     return x

_pytest/unittest.py

@@ -143,7 +143,7 @@ class TestCaseFunction(pytest.Function):
         if traceback:
             excinfo.traceback = traceback
 
-@pytest.mark.tryfirst
+@pytest.hookimpl(tryfirst=True)
 def pytest_runtest_makereport(item, call):
     if isinstance(item, TestCaseFunction):
         if item._excinfo:
@@ -155,7 +155,7 @@ def pytest_runtest_makereport(item, call):
 
 # twisted trial support
 
-@pytest.mark.hookwrapper
+@pytest.hookimpl(hookwrapper=True)
 def pytest_runtest_protocol(item):
     if isinstance(item, TestCaseFunction) and \
        'twisted.trial.unittest' in sys.modules:

_pytest/vendored_packages/README.md

@@ -0,0 +1,13 @@
+This directory vendors the `pluggy` module.
+
+For a more detailed discussion for the reasons to vendoring this 
+package, please see [this issue](https://github.com/pytest-dev/pytest/issues/944).
+
+To update the current version, execute:
+
+```
+$ pip install -U pluggy==<version> --no-compile --target=_pytest/vendored_packages
+```
+
+And commit the modified files. The `pluggy-<version>.dist-info` directory 
+created by `pip` should be ignored.

_pytest/vendored_packages/pluggy-0.3.1.dist-info/DESCRIPTION.rst

@@ -0,0 +1,10 @@
+Plugin registration and hook calling for Python
+===============================================
+
+This is the plugin manager as used by pytest but stripped
+of pytest specific details.
+
+During the 0.x series this plugin does not have much documentation
+except extensive docstrings in the pluggy.py module.
+
+

_pytest/vendored_packages/pluggy-0.3.1.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.0
+Name: pluggy
+Version: 0.3.1
+Summary: plugin and hook calling mechanisms for python
+Home-page: UNKNOWN
+Author: Holger Krekel
+Author-email: holger at merlinux.eu
+License: MIT license
+Platform: unix
+Platform: linux
+Platform: osx
+Platform: win32
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+
+Plugin registration and hook calling for Python
+===============================================
+
+This is the plugin manager as used by pytest but stripped
+of pytest specific details.
+
+During the 0.x series this plugin does not have much documentation
+except extensive docstrings in the pluggy.py module.
+
+

_pytest/vendored_packages/pluggy-0.3.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+pluggy.py,sha256=v_RfWzyW6DPU1cJu_EFoL_OHq3t13qloVdR6UaMCXQA,29862
+pluggy-0.3.1.dist-info/top_level.txt,sha256=xKSCRhai-v9MckvMuWqNz16c1tbsmOggoMSwTgcpYHE,7
+pluggy-0.3.1.dist-info/pbr.json,sha256=xX3s6__wOcAyF-AZJX1sdZyW6PUXT-FkfBlM69EEUCg,47
+pluggy-0.3.1.dist-info/RECORD,,
+pluggy-0.3.1.dist-info/metadata.json,sha256=nLKltOT78dMV-00uXD6Aeemp4xNsz2q59j6ORSDeLjw,1027
+pluggy-0.3.1.dist-info/METADATA,sha256=1b85Ho2u4iK30M099k7axMzcDDhLcIMb-A82JUJZnSo,1334
+pluggy-0.3.1.dist-info/WHEEL,sha256=AvR0WeTpDaxT645bl5FQxUK6NPsTls2ttpcGJg3j1Xg,110
+pluggy-0.3.1.dist-info/DESCRIPTION.rst,sha256=P5Akh1EdIBR6CeqtV2P8ZwpGSpZiTKPw0NyS7jEiD-g,306

_pytest/vendored_packages/pluggy-0.3.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.24.0)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

_pytest/vendored_packages/pluggy-0.3.1.dist-info/metadata.json

@@ -0,0 +1 @@
+{"license": "MIT license", "name": "pluggy", "metadata_version": "2.0", "generator": "bdist_wheel (0.24.0)", "summary": "plugin and hook calling mechanisms for python", "platform": "unix", "version": "0.3.1", "extensions": {"python.details": {"document_names": {"description": "DESCRIPTION.rst"}, "contacts": [{"role": "author", "email": "holger at merlinux.eu", "name": "Holger Krekel"}]}}, "classifiers": ["Development Status :: 4 - Beta", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Operating System :: POSIX", "Operating System :: Microsoft :: Windows", "Operating System :: MacOS :: MacOS X", "Topic :: Software Development :: Testing", "Topic :: Software Development :: Libraries", "Topic :: Utilities", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5"]}

_pytest/vendored_packages/pluggy-0.3.1.dist-info/pbr.json

@@ -0,0 +1 @@
+{"is_release": false, "git_version": "7d4c9cd"}

_pytest/vendored_packages/pluggy-0.3.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pluggy

_pytest/vendored_packages/pluggy.py

@@ -0,0 +1,777 @@
+"""
+PluginManager, basic initialization and tracing.
+
+pluggy is the cristallized core of plugin management as used
+by some 150 plugins for pytest.
+
+Pluggy uses semantic versioning. Breaking changes are only foreseen for
+Major releases (incremented X in "X.Y.Z").  If you want to use pluggy in
+your project you should thus use a dependency restriction like
+"pluggy>=0.1.0,<1.0" to avoid surprises.
+
+pluggy is concerned with hook specification, hook implementations and hook
+calling.  For any given hook specification a hook call invokes up to N implementations.
+A hook implementation can influence its position and type of execution:
+if attributed "tryfirst" or "trylast" it will be tried to execute
+first or last.  However, if attributed "hookwrapper" an implementation
+can wrap all calls to non-hookwrapper implementations.  A hookwrapper
+can thus execute some code ahead and after the execution of other hooks.
+
+Hook specification is done by way of a regular python function where
+both the function name and the names of all its arguments are significant.
+Each hook implementation function is verified against the original specification
+function, including the names of all its arguments.  To allow for hook specifications
+to evolve over the livetime of a project, hook implementations can
+accept less arguments.  One can thus add new arguments and semantics to
+a hook specification by adding another argument typically without breaking
+existing hook implementations.
+
+The chosen approach is meant to let a hook designer think carefuly about
+which objects are needed by an extension writer.  By contrast, subclass-based
+extension mechanisms often expose a lot more state and behaviour than needed,
+thus restricting future developments.
+
+Pluggy currently consists of functionality for:
+
+- a way to register new hook specifications.  Without a hook
+  specification no hook calling can be performed.
+
+- a registry of plugins which contain hook implementation functions.  It
+  is possible to register plugins for which a hook specification is not yet
+  known and validate all hooks when the system is in a more referentially
+  consistent state.  Setting an "optionalhook" attribution to a hook
+  implementation will avoid PluginValidationError's if a specification
+  is missing.  This allows to have optional integration between plugins.
+
+- a "hook" relay object from which you can launch 1:N calls to
+  registered hook implementation functions
+
+- a mechanism for ordering hook implementation functions
+
+- mechanisms for two different type of 1:N calls: "firstresult" for when
+  the call should stop when the first implementation returns a non-None result.
+  And the other (default) way of guaranteeing that all hook implementations
+  will be called and their non-None result collected.
+
+- mechanisms for "historic" extension points such that all newly
+  registered functions will receive all hook calls that happened
+  before their registration.
+
+- a mechanism for discovering plugin objects which are based on
+  setuptools based entry points.
+
+- a simple tracing mechanism, including tracing of plugin calls and
+  their arguments.
+
+"""
+import sys
+import inspect
+
+__version__ = '0.3.1'
+__all__ = ["PluginManager", "PluginValidationError",
+           "HookspecMarker", "HookimplMarker"]
+
+_py3 = sys.version_info > (3, 0)
+
+
+class HookspecMarker:
+    """ Decorator helper class for marking functions as hook specifications.
+
+    You can instantiate it with a project_name to get a decorator.
+    Calling PluginManager.add_hookspecs later will discover all marked functions
+    if the PluginManager uses the same project_name.
+    """
+
+    def __init__(self, project_name):
+        self.project_name = project_name
+
+    def __call__(self, function=None, firstresult=False, historic=False):
+        """ if passed a function, directly sets attributes on the function
+        which will make it discoverable to add_hookspecs().  If passed no
+        function, returns a decorator which can be applied to a function
+        later using the attributes supplied.
+
+        If firstresult is True the 1:N hook call (N being the number of registered
+        hook implementation functions) will stop at I<=N when the I'th function
+        returns a non-None result.
+
+        If historic is True calls to a hook will be memorized and replayed
+        on later registered plugins.
+
+        """
+        def setattr_hookspec_opts(func):
+            if historic and firstresult:
+                raise ValueError("cannot have a historic firstresult hook")
+            setattr(func, self.project_name + "_spec",
+                   dict(firstresult=firstresult, historic=historic))
+            return func
+
+        if function is not None:
+            return setattr_hookspec_opts(function)
+        else:
+            return setattr_hookspec_opts
+
+
+class HookimplMarker:
+    """ Decorator helper class for marking functions as hook implementations.
+
+    You can instantiate with a project_name to get a decorator.
+    Calling PluginManager.register later will discover all marked functions
+    if the PluginManager uses the same project_name.
+    """
+    def __init__(self, project_name):
+        self.project_name = project_name
+
+    def __call__(self, function=None, hookwrapper=False, optionalhook=False,
+                 tryfirst=False, trylast=False):
+
+        """ if passed a function, directly sets attributes on the function
+        which will make it discoverable to register().  If passed no function,
+        returns a decorator which can be applied to a function later using
+        the attributes supplied.
+
+        If optionalhook is True a missing matching hook specification will not result
+        in an error (by default it is an error if no matching spec is found).
+
+        If tryfirst is True this hook implementation will run as early as possible
+        in the chain of N hook implementations for a specfication.
+
+        If trylast is True this hook implementation will run as late as possible
+        in the chain of N hook implementations.
+
+        If hookwrapper is True the hook implementations needs to execute exactly
+        one "yield".  The code before the yield is run early before any non-hookwrapper
+        function is run.  The code after the yield is run after all non-hookwrapper
+        function have run.  The yield receives an ``_CallOutcome`` object representing
+        the exception or result outcome of the inner calls (including other hookwrapper
+        calls).
+
+        """
+        def setattr_hookimpl_opts(func):
+            setattr(func, self.project_name + "_impl",
+                   dict(hookwrapper=hookwrapper, optionalhook=optionalhook,
+                        tryfirst=tryfirst, trylast=trylast))
+            return func
+
+        if function is None:
+            return setattr_hookimpl_opts
+        else:
+            return setattr_hookimpl_opts(function)
+
+
+def normalize_hookimpl_opts(opts):
+    opts.setdefault("tryfirst", False)
+    opts.setdefault("trylast", False)
+    opts.setdefault("hookwrapper", False)
+    opts.setdefault("optionalhook", False)
+
+
+class _TagTracer:
+    def __init__(self):
+        self._tag2proc = {}
+        self.writer = None
+        self.indent = 0
+
+    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 and args:
+            lines = self.format_message(tags, args)
+            self.writer(''.join(lines))
+        try:
+            self._tag2proc[tags](tags, args)
+        except KeyError:
+            pass
+
+    def setwriter(self, writer):
+        self.writer = writer
+
+    def setprocessor(self, tags, processor):
+        if isinstance(tags, str):
+            tags = tuple(tags.split(":"))
+        else:
+            assert isinstance(tags, tuple)
+        self._tag2proc[tags] = processor
+
+
+class _TagTracerSub:
+    def __init__(self, root, tags):
+        self.root = root
+        self.tags = tags
+
+    def __call__(self, *args):
+        self.root.processmessage(self.tags, args)
+
+    def setmyprocessor(self, processor):
+        self.root.setprocessor(self.tags, processor)
+
+    def get(self, name):
+        return self.__class__(self.root, self.tags + (name,))
+
+
+def _raise_wrapfail(wrap_controller, msg):
+    co = wrap_controller.gi_code
+    raise RuntimeError("wrap_controller at %r %s:%d %s" %
+                   (co.co_name, co.co_filename, co.co_firstlineno, msg))
+
+
+def _wrapped_call(wrap_controller, func):
+    """ Wrap calling to a function with a generator which needs to yield
+    exactly once.  The yield point will trigger calling the wrapped function
+    and return its _CallOutcome to the yield point.  The generator then needs
+    to finish (raise StopIteration) in order for the wrapped call to complete.
+    """
+    try:
+        next(wrap_controller)   # first yield
+    except StopIteration:
+        _raise_wrapfail(wrap_controller, "did not yield")
+    call_outcome = _CallOutcome(func)
+    try:
+        wrap_controller.send(call_outcome)
+        _raise_wrapfail(wrap_controller, "has second yield")
+    except StopIteration:
+        pass
+    return call_outcome.get_result()
+
+
+class _CallOutcome:
+    """ Outcome of a function call, either an exception or a proper result.
+    Calling the ``get_result`` method will return the result or reraise
+    the exception raised when the function was called. """
+    excinfo = None
+
+    def __init__(self, func):
+        try:
+            self.result = func()
+        except BaseException:
+            self.excinfo = sys.exc_info()
+
+    def force_result(self, result):
+        self.result = result
+        self.excinfo = None
+
+    def get_result(self):
+        if self.excinfo is None:
+            return self.result
+        else:
+            ex = self.excinfo
+            if _py3:
+                raise ex[1].with_traceback(ex[2])
+            _reraise(*ex)  # noqa
+
+if not _py3:
+    exec("""
+def _reraise(cls, val, tb):
+    raise cls, val, tb
+""")
+
+
+class _TracedHookExecution:
+    def __init__(self, pluginmanager, before, after):
+        self.pluginmanager = pluginmanager
+        self.before = before
+        self.after = after
+        self.oldcall = pluginmanager._inner_hookexec
+        assert not isinstance(self.oldcall, _TracedHookExecution)
+        self.pluginmanager._inner_hookexec = self
+
+    def __call__(self, hook, hook_impls, kwargs):
+        self.before(hook.name, hook_impls, kwargs)
+        outcome = _CallOutcome(lambda: self.oldcall(hook, hook_impls, kwargs))
+        self.after(outcome, hook.name, hook_impls, kwargs)
+        return outcome.get_result()
+
+    def undo(self):
+        self.pluginmanager._inner_hookexec = self.oldcall
+
+
+class PluginManager(object):
+    """ Core Pluginmanager class which manages registration
+    of plugin objects and 1:N hook calling.
+
+    You can register new hooks by calling ``addhooks(module_or_class)``.
+    You can register plugin objects (which contain hooks) by calling
+    ``register(plugin)``.  The Pluginmanager is initialized with a
+    prefix that is searched for in the names of the dict of registered
+    plugin objects.  An optional excludefunc allows to blacklist names which
+    are not considered as hooks despite a matching prefix.
+
+    For debugging purposes you can call ``enable_tracing()``
+    which will subsequently send debug information to the trace helper.
+    """
+
+    def __init__(self, project_name, implprefix=None):
+        """ if implprefix is given implementation functions
+        will be recognized if their name matches the implprefix. """
+        self.project_name = project_name
+        self._name2plugin = {}
+        self._plugin2hookcallers = {}
+        self._plugin_distinfo = []
+        self.trace = _TagTracer().get("pluginmanage")
+        self.hook = _HookRelay(self.trace.root.get("hook"))
+        self._implprefix = implprefix
+        self._inner_hookexec = lambda hook, methods, kwargs: \
+            _MultiCall(methods, kwargs, hook.spec_opts).execute()
+
+    def _hookexec(self, hook, methods, kwargs):
+        # called from all hookcaller instances.
+        # enable_tracing will set its own wrapping function at self._inner_hookexec
+        return self._inner_hookexec(hook, methods, kwargs)
+
+    def register(self, plugin, name=None):
+        """ Register a plugin and return its canonical name or None if the name
+        is blocked from registering.  Raise a ValueError if the plugin is already
+        registered. """
+        plugin_name = name or self.get_canonical_name(plugin)
+
+        if plugin_name in self._name2plugin or plugin in self._plugin2hookcallers:
+            if self._name2plugin.get(plugin_name, -1) is None:
+                return  # blocked plugin, return None to indicate no registration
+            raise ValueError("Plugin already registered: %s=%s\n%s" %
+                            (plugin_name, plugin, self._name2plugin))
+
+        # XXX if an error happens we should make sure no state has been
+        # changed at point of return
+        self._name2plugin[plugin_name] = plugin
+
+        # register matching hook implementations of the plugin
+        self._plugin2hookcallers[plugin] = hookcallers = []
+        for name in dir(plugin):
+            hookimpl_opts = self.parse_hookimpl_opts(plugin, name)
+            if hookimpl_opts is not None:
+                normalize_hookimpl_opts(hookimpl_opts)
+                method = getattr(plugin, name)
+                hookimpl = HookImpl(plugin, plugin_name, method, hookimpl_opts)
+                hook = getattr(self.hook, name, None)
+                if hook is None:
+                    hook = _HookCaller(name, self._hookexec)
+                    setattr(self.hook, name, hook)
+                elif hook.has_spec():
+                    self._verify_hook(hook, hookimpl)
+                    hook._maybe_apply_history(hookimpl)
+                hook._add_hookimpl(hookimpl)
+                hookcallers.append(hook)
+        return plugin_name
+
+    def parse_hookimpl_opts(self, plugin, name):
+        method = getattr(plugin, name)
+        res = getattr(method, self.project_name + "_impl", None)
+        if res is not None and not isinstance(res, dict):
+            # false positive
+            res = None
+        elif res is None and self._implprefix and name.startswith(self._implprefix):
+            res = {}
+        return res
+
+    def unregister(self, plugin=None, name=None):
+        """ unregister a plugin object and all its contained hook implementations
+        from internal data structures. """
+        if name is None:
+            assert plugin is not None, "one of name or plugin needs to be specified"
+            name = self.get_name(plugin)
+
+        if plugin is None:
+            plugin = self.get_plugin(name)
+
+        # if self._name2plugin[name] == None registration was blocked: ignore
+        if self._name2plugin.get(name):
+            del self._name2plugin[name]
+
+        for hookcaller in self._plugin2hookcallers.pop(plugin, []):
+            hookcaller._remove_plugin(plugin)
+
+        return plugin
+
+    def set_blocked(self, name):
+        """ block registrations of the given name, unregister if already registered. """
+        self.unregister(name=name)
+        self._name2plugin[name] = None
+
+    def is_blocked(self, name):
+        """ return True if the name blogs registering plugins of that name. """
+        return name in self._name2plugin and self._name2plugin[name] is None
+
+    def add_hookspecs(self, module_or_class):
+        """ add new hook specifications defined in the given module_or_class.
+        Functions are recognized if they have been decorated accordingly. """
+        names = []
+        for name in dir(module_or_class):
+            spec_opts = self.parse_hookspec_opts(module_or_class, name)
+            if spec_opts is not None:
+                hc = getattr(self.hook, name, None)
+                if hc is None:
+                    hc = _HookCaller(name, self._hookexec, module_or_class, spec_opts)
+                    setattr(self.hook, name, hc)
+                else:
+                    # plugins registered this hook without knowing the spec
+                    hc.set_specification(module_or_class, spec_opts)
+                    for hookfunction in (hc._wrappers + hc._nonwrappers):
+                        self._verify_hook(hc, hookfunction)
+                names.append(name)
+
+        if not names:
+            raise ValueError("did not find any %r hooks in %r" %
+                             (self.project_name, module_or_class))
+
+    def parse_hookspec_opts(self, module_or_class, name):
+        method = getattr(module_or_class, name)
+        return getattr(method, self.project_name + "_spec", None)
+
+    def get_plugins(self):
+        """ return the set of registered plugins. """
+        return set(self._plugin2hookcallers)
+
+    def is_registered(self, plugin):
+        """ Return True if the plugin is already registered. """
+        return plugin in self._plugin2hookcallers
+
+    def get_canonical_name(self, plugin):
+        """ Return canonical name for a plugin object. Note that a plugin
+        may be registered under a different name which was specified
+        by the caller of register(plugin, name). To obtain the name
+        of an registered plugin use ``get_name(plugin)`` instead."""
+        return getattr(plugin, "__name__", None) or str(id(plugin))
+
+    def get_plugin(self, name):
+        """ Return a plugin or None for the given name. """
+        return self._name2plugin.get(name)
+
+    def get_name(self, plugin):
+        """ Return name for registered plugin or None if not registered. """
+        for name, val in self._name2plugin.items():
+            if plugin == val:
+                return name
+
+    def _verify_hook(self, hook, hookimpl):
+        if hook.is_historic() and hookimpl.hookwrapper:
+            raise PluginValidationError(
+                "Plugin %r\nhook %r\nhistoric incompatible to hookwrapper" %
+                (hookimpl.plugin_name, hook.name))
+
+        for arg in hookimpl.argnames:
+            if arg not in hook.argnames:
+                raise PluginValidationError(
+                    "Plugin %r\nhook %r\nargument %r not available\n"
+                    "plugin definition: %s\n"
+                    "available hookargs: %s" %
+                    (hookimpl.plugin_name, hook.name, arg,
+                    _formatdef(hookimpl.function), ", ".join(hook.argnames)))
+
+    def check_pending(self):
+        """ Verify that all hooks which have not been verified against
+        a hook specification are optional, otherwise raise PluginValidationError"""
+        for name in self.hook.__dict__:
+            if name[0] != "_":
+                hook = getattr(self.hook, name)
+                if not hook.has_spec():
+                    for hookimpl in (hook._wrappers + hook._nonwrappers):
+                        if not hookimpl.optionalhook:
+                            raise PluginValidationError(
+                                "unknown hook %r in plugin %r" %
+                                (name, hookimpl.plugin))
+
+    def load_setuptools_entrypoints(self, entrypoint_name):
+        """ Load modules from querying the specified setuptools entrypoint name.
+        Return the number of loaded plugins. """
+        from pkg_resources import iter_entry_points, DistributionNotFound
+        for ep in iter_entry_points(entrypoint_name):
+            # is the plugin registered or blocked?
+            if self.get_plugin(ep.name) or self.is_blocked(ep.name):
+                continue
+            try:
+                plugin = ep.load()
+            except DistributionNotFound:
+                continue
+            self.register(plugin, name=ep.name)
+            self._plugin_distinfo.append((plugin, ep.dist))
+        return len(self._plugin_distinfo)
+
+    def list_plugin_distinfo(self):
+        """ return list of distinfo/plugin tuples for all setuptools registered
+        plugins. """
+        return list(self._plugin_distinfo)
+
+    def list_name_plugin(self):
+        """ return list of name/plugin pairs. """
+        return list(self._name2plugin.items())
+
+    def get_hookcallers(self, plugin):
+        """ get all hook callers for the specified plugin. """
+        return self._plugin2hookcallers.get(plugin)
+
+    def add_hookcall_monitoring(self, before, after):
+        """ add before/after tracing functions for all hooks
+        and return an undo function which, when called,
+        will remove the added tracers.
+
+        ``before(hook_name, hook_impls, kwargs)`` will be called ahead
+        of all hook calls and receive a hookcaller instance, a list
+        of HookImpl instances and the keyword arguments for the hook call.
+
+        ``after(outcome, hook_name, hook_impls, kwargs)`` receives the
+        same arguments as ``before`` but also a :py:class:`_CallOutcome`` object
+        which represents the result of the overall hook call.
+        """
+        return _TracedHookExecution(self, before, after).undo
+
+    def enable_tracing(self):
+        """ enable tracing of hook calls and return an undo function. """
+        hooktrace = self.hook._trace
+
+        def before(hook_name, methods, kwargs):
+            hooktrace.root.indent += 1
+            hooktrace(hook_name, kwargs)
+
+        def after(outcome, hook_name, methods, kwargs):
+            if outcome.excinfo is None:
+                hooktrace("finish", hook_name, "-->", outcome.result)
+            hooktrace.root.indent -= 1
+
+        return self.add_hookcall_monitoring(before, after)
+
+    def subset_hook_caller(self, name, remove_plugins):
+        """ Return a new _HookCaller instance for the named method
+        which manages calls to all registered plugins except the
+        ones from remove_plugins. """
+        orig = getattr(self.hook, name)
+        plugins_to_remove = [plug for plug in remove_plugins if hasattr(plug, name)]
+        if plugins_to_remove:
+            hc = _HookCaller(orig.name, orig._hookexec, orig._specmodule_or_class,
+                             orig.spec_opts)
+            for hookimpl in (orig._wrappers + orig._nonwrappers):
+                plugin = hookimpl.plugin
+                if plugin not in plugins_to_remove:
+                    hc._add_hookimpl(hookimpl)
+                    # we also keep track of this hook caller so it
+                    # gets properly removed on plugin unregistration
+                    self._plugin2hookcallers.setdefault(plugin, []).append(hc)
+            return hc
+        return orig
+
+
+class _MultiCall:
+    """ execute a call into multiple python functions/methods. """
+
+    # XXX note that the __multicall__ argument is supported only
+    # for pytest compatibility reasons.  It was never officially
+    # supported there and is explicitely deprecated since 2.8
+    # so we can remove it soon, allowing to avoid the below recursion
+    # in execute() and simplify/speed up the execute loop.
+
+    def __init__(self, hook_impls, kwargs, specopts={}):
+        self.hook_impls = hook_impls
+        self.kwargs = kwargs
+        self.kwargs["__multicall__"] = self
+        self.specopts = specopts
+
+    def execute(self):
+        all_kwargs = self.kwargs
+        self.results = results = []
+        firstresult = self.specopts.get("firstresult")
+
+        while self.hook_impls:
+            hook_impl = self.hook_impls.pop()
+            args = [all_kwargs[argname] for argname in hook_impl.argnames]
+            if hook_impl.hookwrapper:
+                return _wrapped_call(hook_impl.function(*args), self.execute)
+            res = hook_impl.function(*args)
+            if res is not None:
+                if firstresult:
+                    return res
+                results.append(res)
+
+        if not firstresult:
+            return results
+
+    def __repr__(self):
+        status = "%d meths" % (len(self.hook_impls),)
+        if hasattr(self, "results"):
+            status = ("%d results, " % len(self.results)) + status
+        return "<_MultiCall %s, kwargs=%r>" % (status, self.kwargs)
+
+
+def varnames(func, startindex=None):
+    """ 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 cache["_varnames"]
+    except KeyError:
+        pass
+    if inspect.isclass(func):
+        try:
+            func = func.__init__
+        except AttributeError:
+            return ()
+        startindex = 1
+    else:
+        if not inspect.isfunction(func) and not inspect.ismethod(func):
+            func = getattr(func, '__call__', func)
+        if startindex is None:
+            startindex = int(inspect.ismethod(func))
+
+    try:
+        rawcode = func.__code__
+    except AttributeError:
+        return ()
+    try:
+        x = rawcode.co_varnames[startindex:rawcode.co_argcount]
+    except AttributeError:
+        x = ()
+    else:
+        defaults = func.__defaults__
+        if defaults:
+            x = x[:-len(defaults)]
+    try:
+        cache["_varnames"] = x
+    except TypeError:
+        pass
+    return x
+
+
+class _HookRelay:
+    """ hook holder object for performing 1:N hook calls where N is the number
+    of registered plugins.
+
+    """
+
+    def __init__(self, trace):
+        self._trace = trace
+
+
+class _HookCaller(object):
+    def __init__(self, name, hook_execute, specmodule_or_class=None, spec_opts=None):
+        self.name = name
+        self._wrappers = []
+        self._nonwrappers = []
+        self._hookexec = hook_execute
+        if specmodule_or_class is not None:
+            assert spec_opts is not None
+            self.set_specification(specmodule_or_class, spec_opts)
+
+    def has_spec(self):
+        return hasattr(self, "_specmodule_or_class")
+
+    def set_specification(self, specmodule_or_class, spec_opts):
+        assert not self.has_spec()
+        self._specmodule_or_class = specmodule_or_class
+        specfunc = getattr(specmodule_or_class, self.name)
+        argnames = varnames(specfunc, startindex=inspect.isclass(specmodule_or_class))
+        assert "self" not in argnames  # sanity check
+        self.argnames = ["__multicall__"] + list(argnames)
+        self.spec_opts = spec_opts
+        if spec_opts.get("historic"):
+            self._call_history = []
+
+    def is_historic(self):
+        return hasattr(self, "_call_history")
+
+    def _remove_plugin(self, plugin):
+        def remove(wrappers):
+            for i, method in enumerate(wrappers):
+                if method.plugin == plugin:
+                    del wrappers[i]
+                    return True
+        if remove(self._wrappers) is None:
+            if remove(self._nonwrappers) is None:
+                raise ValueError("plugin %r not found" % (plugin,))
+
+    def _add_hookimpl(self, hookimpl):
+        if hookimpl.hookwrapper:
+            methods = self._wrappers
+        else:
+            methods = self._nonwrappers
+
+        if hookimpl.trylast:
+            methods.insert(0, hookimpl)
+        elif hookimpl.tryfirst:
+            methods.append(hookimpl)
+        else:
+            # find last non-tryfirst method
+            i = len(methods) - 1
+            while i >= 0 and methods[i].tryfirst:
+                i -= 1
+            methods.insert(i + 1, hookimpl)
+
+    def __repr__(self):
+        return "<_HookCaller %r>" % (self.name,)
+
+    def __call__(self, **kwargs):
+        assert not self.is_historic()
+        return self._hookexec(self, self._nonwrappers + self._wrappers, kwargs)
+
+    def call_historic(self, proc=None, kwargs=None):
+        self._call_history.append((kwargs or {}, proc))
+        # historizing hooks don't return results
+        self._hookexec(self, self._nonwrappers + self._wrappers, kwargs)
+
+    def call_extra(self, methods, kwargs):
+        """ Call the hook with some additional temporarily participating
+        methods using the specified kwargs as call parameters. """
+        old = list(self._nonwrappers), list(self._wrappers)
+        for method in methods:
+            opts = dict(hookwrapper=False, trylast=False, tryfirst=False)
+            hookimpl = HookImpl(None, "<temp>", method, opts)
+            self._add_hookimpl(hookimpl)
+        try:
+            return self(**kwargs)
+        finally:
+            self._nonwrappers, self._wrappers = old
+
+    def _maybe_apply_history(self, method):
+        if self.is_historic():
+            for kwargs, proc in self._call_history:
+                res = self._hookexec(self, [method], kwargs)
+                if res and proc is not None:
+                    proc(res[0])
+
+
+class HookImpl:
+    def __init__(self, plugin, plugin_name, function, hook_impl_opts):
+        self.function = function
+        self.argnames = varnames(self.function)
+        self.plugin = plugin
+        self.opts = hook_impl_opts
+        self.plugin_name = plugin_name
+        self.__dict__.update(hook_impl_opts)
+
+
+class PluginValidationError(Exception):
+    """ plugin failed validation. """
+
+
+if hasattr(inspect, 'signature'):
+    def _formatdef(func):
+        return "%s%s" % (
+            func.__name__,
+            str(inspect.signature(func))
+        )
+else:
+    def _formatdef(func):
+        return "%s%s" % (
+            func.__name__,
+            inspect.formatargspec(*inspect.getargspec(func))
+        )

appveyor.yml

@@ -1,10 +1,4 @@
 environment:
-  global:
-    # SDK v7.0 MSVC Express 2008's SetEnv.cmd script will fail if the
-    # /E:ON and /V:ON options are not enabled in the batch script intepreter
-    # See: http://stackoverflow.com/a/13751649/163740
-    CMD_IN_ENV: "cmd /E:ON /V:ON /C .\\appveyor\\run_with_env.cmd"
-
   matrix:
 
     # Pre-installed Python versions, which Appveyor may upgrade to
@@ -40,6 +34,16 @@ environment:
       PYTHON_ARCH: "64"
       TESTENV: "py34"
 
+    - PYTHON: "C:\\Python35"
+      PYTHON_VERSION: "3.5.x" # currently 3.5.0
+      PYTHON_ARCH: "32"
+      TESTENV: "py35"
+
+    - PYTHON: "C:\\Python35-x64"
+      PYTHON_VERSION: "3.5.x" # currently 3.5.0
+      PYTHON_ARCH: "64"
+      TESTENV: "py35"
+
     # Also test a Python version not pre-installed
     # See: https://github.com/ogrisel/python-appveyor-demo/issues/10
 
@@ -48,6 +52,18 @@ environment:
       PYTHON_ARCH: "32"
       TESTENV: "py26"
 
+    # xdist testing
+
+    - PYTHON: "C:\\Python27"
+      PYTHON_VERSION: "2.7.x" # currently 2.7.9
+      PYTHON_ARCH: "32"
+      TESTENV: "py27-xdist"
+
+    - PYTHON: "C:\\Python35"
+      PYTHON_VERSION: "3.5.x" # currently 3.5.0
+      PYTHON_ARCH: "32"
+      TESTENV: "py35-xdist"
+
 
 install:
   - ECHO "Filesystem root:"
@@ -73,10 +89,10 @@ install:
   # compiled extensions and are not provided as pre-built wheel packages,
   # pip will build them from source using the MSVC compiler matching the
   # target Python version and architecture
-  - "%CMD_IN_ENV% pip install tox"
+  - C:\Python27\python -m pip install tox
 
 build: false  # Not a C# project, build stuff at the test step instead.
 
 test_script:
   # Build the compiled extension and run the project tests
-  - "%CMD_IN_ENV% tox -e %TESTENV%"
+  - C:\Python27\python -m tox -e %TESTENV%

appveyor/run_with_env.cmd

@@ -1,47 +0,0 @@
-:: To build extensions for 64 bit Python 3, we need to configure environment
-:: variables to use the MSVC 2010 C++ compilers from GRMSDKX_EN_DVD.iso of:
-:: MS Windows SDK for Windows 7 and .NET Framework 4 (SDK v7.1)
-::
-:: To build extensions for 64 bit Python 2, we need to configure environment
-:: variables to use the MSVC 2008 C++ compilers from GRMSDKX_EN_DVD.iso of:
-:: MS Windows SDK for Windows 7 and .NET Framework 3.5 (SDK v7.0)
-::
-:: 32 bit builds do not require specific environment configurations.
-::
-:: Note: this script needs to be run with the /E:ON and /V:ON flags for the
-:: cmd interpreter, at least for (SDK v7.0)
-::
-:: More details at:
-:: https://github.com/cython/cython/wiki/64BitCythonExtensionsOnWindows
-:: http://stackoverflow.com/a/13751649/163740
-::
-:: Author: Olivier Grisel
-:: License: CC0 1.0 Universal: http://creativecommons.org/publicdomain/zero/1.0/
-@ECHO OFF
-
-SET COMMAND_TO_RUN=%*
-SET WIN_SDK_ROOT=C:\Program Files\Microsoft SDKs\Windows
-
-SET MAJOR_PYTHON_VERSION="%PYTHON_VERSION:~0,1%"
-IF %MAJOR_PYTHON_VERSION% == "2" (
-    SET WINDOWS_SDK_VERSION="v7.0"
-) ELSE IF %MAJOR_PYTHON_VERSION% == "3" (
-    SET WINDOWS_SDK_VERSION="v7.1"
-) ELSE (
-    ECHO Unsupported Python version: "%MAJOR_PYTHON_VERSION%"
-    EXIT 1
-)
-
-IF "%PYTHON_ARCH%"=="64" (
-    ECHO Configuring Windows SDK %WINDOWS_SDK_VERSION% for Python %MAJOR_PYTHON_VERSION% on a 64 bit architecture
-    SET DISTUTILS_USE_SDK=1
-    SET MSSdk=1
-    "%WIN_SDK_ROOT%\%WINDOWS_SDK_VERSION%\Setup\WindowsSdkVer.exe" -q -version:%WINDOWS_SDK_VERSION%
-    "%WIN_SDK_ROOT%\%WINDOWS_SDK_VERSION%\Bin\SetEnv.cmd" /x64 /release
-    ECHO Executing: %COMMAND_TO_RUN%
-    call %COMMAND_TO_RUN% || EXIT 1
-) ELSE (
-    ECHO Using default MSVC build environment for 32 bit architecture
-    ECHO Executing: %COMMAND_TO_RUN%
-    call %COMMAND_TO_RUN% || EXIT 1
-)

doc/en/Makefile

@@ -12,6 +12,13 @@ PAPEROPT_a4     = -D latex_paper_size=a4
 PAPEROPT_letter = -D latex_paper_size=letter
 ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
 
+REGENDOC_ARGS := \
+	--normalize "/={8,} (.*) ={8,}/======= \1 ========/" \
+	--normalize "/_{8,} (.*) _{8,}/_______ \1 ________/" \
+	--normalize "/in \d+.\d+ seconds/in 0.12 seconds/" \
+	--normalize "@/tmp/pytest-of-.*/pytest-\d+@PYTEST_TMPDIR@" \
+
+
 
 .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest
 
@@ -46,7 +53,7 @@ installall: clean install installpdf
 	@echo "done"
 
 regen:
-	PYTHONDONTWRITEBYTECODE=1 COLUMNS=76 regendoc --update *.txt */*.txt
+	PYTHONDONTWRITEBYTECODE=1 COLUMNS=76 regendoc --update *.rst */*.rst ${REGENDOC_ARGS}
 
 html:
 	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html

doc/en/_getdoctarget.py

@@ -6,7 +6,7 @@ def get_version_string():
     fn = py.path.local(__file__).join("..", "..", "..",
                                       "_pytest", "__init__.py")
     for line in fn.readlines():
-        if "version" in line:
+        if "version" in line and not line.strip().startswith('#'):
             return eval(line.split("=")[-1])
 
 def get_minor_version_string():

doc/en/adopt.rst

@@ -9,7 +9,7 @@ We will pair experienced pytest users with open source projects, for a month's e
 In 2015 we are trying this for the first time. In February and March 2015 we will gather volunteers on both sides, in April we will do the work, and in May we will evaluate how it went. This effort is being coordinated by Brianna Laugher. If you have any questions or comments, you can raise them on the `@pytestdotorg twitter account <https://twitter.com/pytestdotorg>`_ the `issue tracker`_ or the `pytest-dev mailing list`_.
 
 
-.. _`issue tracker`: https://bitbucket.org/pytest-dev/pytest/issue/676/adopt-pytest-month-2015
+.. _`issue tracker`: https://github.com/pytest-dev/pytest/issues/676
 .. _`pytest-dev mailing list`: https://mail.python.org/mailman/listinfo/pytest-dev
 
 

doc/en/announce/index.rst

@@ -5,6 +5,7 @@ Release announcements
 .. toctree::
    :maxdepth: 2
 
+   release-2.7.2
    release-2.7.1
    release-2.7.0
    release-2.6.3

doc/en/apiref.txt

@@ -1,27 +0,0 @@
-
-.. _apiref:
-
-pytest reference documentation
-================================================
-
-.. toctree::
-   :maxdepth: 2
-
-   builtin.txt
-   customize.txt
-   assert.txt
-   fixture.txt
-   yieldfixture.txt
-   parametrize.txt
-   xunit_setup.txt
-   capture.txt
-   monkeypatch.txt
-   xdist.txt
-   tmpdir.txt
-   mark.txt
-   skipping.txt
-   recwarn.txt
-   unittest.txt
-   nose.txt
-   doctest.txt
-

doc/en/assert.rst

@@ -25,15 +25,15 @@ to assert that your function returns a certain value. If this assertion fails
 you will see the return value of the function call::
 
     $ py.test test_assert1.py
-    =========================== test session starts ============================
-    platform linux -- Python 3.4.1 -- py-1.4.27 -- pytest-2.7.1
-    rootdir: /tmp/doc-exec-87, inifile: 
+    ======= test session starts ========
+    platform linux -- Python 3.4.3, pytest-2.8.1, py-1.4.30, pluggy-0.3.1
+    rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     
     test_assert1.py F
     
-    ================================= FAILURES =================================
-    ______________________________ test_function _______________________________
+    ======= FAILURES ========
+    _______ test_function ________
     
         def test_function():
     >       assert f() == 4
@@ -41,7 +41,7 @@ you will see the return value of the function call::
     E        +  where 3 = f()
     
     test_assert1.py:5: AssertionError
-    ========================= 1 failed in 0.01 seconds =========================
+    ======= 1 failed in 0.12 seconds ========
 
 ``pytest`` has support for showing the values of the most common subexpressions
 including calls, attributes, comparisons, and binary and unary
@@ -114,6 +114,16 @@ like documenting unfixed bugs (where the test describes what "should" happen)
 or bugs in dependencies.
 
 
+.. _`assertwarns`:
+
+Assertions about expected warnings
+-----------------------------------------
+
+.. versionadded:: 2.8
+
+You can check that code raises a particular warning using
+:ref:`pytest.warns <warns>`.
+
 
 .. _newreport:
 
@@ -135,15 +145,15 @@ when it encounters comparisons.  For example::
 if you run this module::
 
     $ py.test test_assert2.py
-    =========================== test session starts ============================
-    platform linux -- Python 3.4.1 -- py-1.4.27 -- pytest-2.7.1
-    rootdir: /tmp/doc-exec-87, inifile: 
+    ======= test session starts ========
+    platform linux -- Python 3.4.3, pytest-2.8.1, py-1.4.30, pluggy-0.3.1
+    rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     
     test_assert2.py F
     
-    ================================= FAILURES =================================
-    ___________________________ test_set_comparison ____________________________
+    ======= FAILURES ========
+    _______ test_set_comparison ________
     
         def test_set_comparison():
             set1 = set("1308")
@@ -157,7 +167,7 @@ if you run this module::
     E         Use -v to get the full diff
     
     test_assert2.py:5: AssertionError
-    ========================= 1 failed in 0.01 seconds =========================
+    ======= 1 failed in 0.12 seconds ========
 
 Special comparisons are done for a number of cases:
 
@@ -190,7 +200,10 @@ now, given this test module::
    # content of test_foocompare.py
    class Foo:
        def __init__(self, val):
-            self.val = val
+           self.val = val
+
+       def __eq__(self, other):
+           return self.val == other.val
 
    def test_compare():
        f1 = Foo(1)
@@ -202,8 +215,8 @@ the conftest file::
 
    $ py.test -q test_foocompare.py
    F
-   ================================= FAILURES =================================
-   _______________________________ test_compare _______________________________
+   ======= FAILURES ========
+   _______ test_compare ________
    
        def test_compare():
            f1 = Foo(1)
@@ -212,8 +225,8 @@ the conftest file::
    E       assert Comparing Foo instances:
    E            vals: 1 != 2
    
-   test_foocompare.py:8: AssertionError
-   1 failed in 0.01 seconds
+   test_foocompare.py:11: AssertionError
+   1 failed in 0.12 seconds
 
 .. _assert-details:
 .. _`assert introspection`:
@@ -228,9 +241,7 @@ 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, ``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.
+to run ``pytest``.
 
 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

doc/en/builtin.rst

@@ -73,6 +73,16 @@ You can ask for available builtin or project-custom
 :ref:`fixtures <fixtures>` by typing::
 
     $ py.test -q --fixtures
+    cache
+        Return a cache object that can persist state between testing sessions.
+        
+        cache.get(key, default)
+        cache.set(key, value)
+        
+        Keys must be strings not containing a "/" separator. Add a unique identifier
+        (such as plugin/app name) to avoid clashes with other cache users.
+        
+        Values can be any object handled by the json stdlib module.
     capsys
         enables capturing of writes to sys.stdout/sys.stderr and makes
         captured output available via ``capsys.readouterr()`` method calls
@@ -81,6 +91,10 @@ You can ask for available builtin or project-custom
         enables capturing of writes to file descriptors 1 and 2 and makes
         captured output available via ``capfd.readouterr()`` method calls
         which return a ``(out, err)`` tuple.
+    record_xml_property
+        Fixture that adds extra xml properties to the tag for the calling test.
+        The fixture is callable with (name, value), with value being automatically
+        xml-encoded.
     monkeypatch
         The returned ``monkeypatch`` funcarg provides these
         helper methods to modify objects, dictionaries or os.environ::
@@ -108,6 +122,8 @@ You can ask for available builtin or project-custom
         
         See http://docs.python.org/library/warnings.html for information
         on warning categories.
+    tmpdir_factory
+        Return a TempdirFactory instance for the test session.
     tmpdir
         return a temporary directory path object
         which is unique to each test function invocation,
@@ -115,4 +131,4 @@ You can ask for available builtin or project-custom
         directory.  The returned object is a `py.path.local`_
         path object.
     
-     in 0.00 seconds
+     in 0.12 seconds

doc/en/cache.rst

@@ -0,0 +1,271 @@
+Cache: working with cross-testrun state
+=======================================
+
+.. versionadded:: 2.8
+
+.. warning::
+
+  The functionality of this core plugin was previosuly distributed
+  as a third party plugin named ``pytest-cache``.  The core plugin
+  is compatible regarding command line options and API usage except that you
+  can only store/receive data between test runs that is json-serializable.
+
+Usage
+---------
+
+The plugin provides two command line options to rerun failures from the
+last ``py.test`` invocation:
+
+* ``--lf`` (last failures) - to only re-run the failures.
+* ``--ff`` (failures first) - to run the failures first and then the rest of
+  the tests.
+
+For cleanup (usually not needed), a ``--cache-clear`` option allows to remove
+all cross-session cache contents ahead of a test run.
+
+Other plugins may access the `config.cache`_ object to set/get 
+**json encodable** values between ``py.test`` invocations.
+
+
+Rerunning only failures or failures first
+-----------------------------------------------
+
+First, let's create 50 test invocation of which only 2 fail::
+
+    # content of test_50.py
+    import pytest
+
+    @pytest.mark.parametrize("i", range(50))
+    def test_num(i):
+        if i in (17, 25):
+           pytest.fail("bad luck")
+
+If you run this for the first time you will see two failures::
+
+    $ py.test -q
+    .................F.......F........................
+    ======= FAILURES ========
+    _______ test_num[17] ________
+    
+    i = 17
+    
+        @pytest.mark.parametrize("i", range(50))
+        def test_num(i):
+            if i in (17, 25):
+    >          pytest.fail("bad luck")
+    E          Failed: bad luck
+    
+    test_50.py:6: Failed
+    _______ test_num[25] ________
+    
+    i = 25
+    
+        @pytest.mark.parametrize("i", range(50))
+        def test_num(i):
+            if i in (17, 25):
+    >          pytest.fail("bad luck")
+    E          Failed: bad luck
+    
+    test_50.py:6: Failed
+    2 failed, 48 passed in 0.12 seconds
+
+If you then run it with ``--lf``::
+
+    $ py.test --lf
+    ======= test session starts ========
+    platform linux -- Python 3.4.3, pytest-2.8.1, py-1.4.30, pluggy-0.3.1
+    run-last-failure: rerun last 2 failures
+    rootdir: $REGENDOC_TMPDIR, inifile: 
+    collected 50 items
+    
+    test_50.py FF
+    
+    ======= FAILURES ========
+    _______ test_num[17] ________
+    
+    i = 17
+    
+        @pytest.mark.parametrize("i", range(50))
+        def test_num(i):
+            if i in (17, 25):
+    >          pytest.fail("bad luck")
+    E          Failed: bad luck
+    
+    test_50.py:6: Failed
+    _______ test_num[25] ________
+    
+    i = 25
+    
+        @pytest.mark.parametrize("i", range(50))
+        def test_num(i):
+            if i in (17, 25):
+    >          pytest.fail("bad luck")
+    E          Failed: bad luck
+    
+    test_50.py:6: Failed
+    ======= 2 failed, 48 deselected in 0.12 seconds ========
+
+You have run only the two failing test from the last run, while 48 tests have
+not been run ("deselected").
+
+Now, if you run with the ``--ff`` option, all tests will be run but the first
+previous failures will be executed first (as can be seen from the series
+of ``FF`` and dots)::
+
+    $ py.test --ff
+    ======= test session starts ========
+    platform linux -- Python 3.4.3, pytest-2.8.1, py-1.4.30, pluggy-0.3.1
+    run-last-failure: rerun last 2 failures first
+    rootdir: $REGENDOC_TMPDIR, inifile: 
+    collected 50 items
+    
+    test_50.py FF................................................
+    
+    ======= FAILURES ========
+    _______ test_num[17] ________
+    
+    i = 17
+    
+        @pytest.mark.parametrize("i", range(50))
+        def test_num(i):
+            if i in (17, 25):
+    >          pytest.fail("bad luck")
+    E          Failed: bad luck
+    
+    test_50.py:6: Failed
+    _______ test_num[25] ________
+    
+    i = 25
+    
+        @pytest.mark.parametrize("i", range(50))
+        def test_num(i):
+            if i in (17, 25):
+    >          pytest.fail("bad luck")
+    E          Failed: bad luck
+    
+    test_50.py:6: Failed
+    ======= 2 failed, 48 passed in 0.12 seconds ========
+
+.. _`config.cache`:
+
+The new config.cache object
+--------------------------------
+
+.. regendoc:wipe
+
+Plugins or conftest.py support code can get a cached value using the
+pytest ``config`` object.  Here is a basic example plugin which
+implements a :ref:`fixture` which re-uses previously created state
+across py.test invocations::
+
+    # content of test_caching.py
+    import pytest
+    import time
+
+    @pytest.fixture
+    def mydata(request):
+        val = request.config.cache.get("example/value", None)
+        if val is None:
+            time.sleep(9*0.6) # expensive computation :)
+            val = 42
+            request.config.cache.set("example/value", val)
+        return val
+
+    def test_function(mydata):
+        assert mydata == 23
+
+If you run this command once, it will take a while because
+of the sleep::
+
+    $ py.test -q
+    F
+    ======= FAILURES ========
+    _______ test_function ________
+    
+    mydata = 42
+    
+        def test_function(mydata):
+    >       assert mydata == 23
+    E       assert 42 == 23
+    
+    test_caching.py:14: AssertionError
+    1 failed in 0.12 seconds
+
+If you run it a second time the value will be retrieved from
+the cache and this will be quick::
+
+    $ py.test -q
+    F
+    ======= FAILURES ========
+    _______ test_function ________
+    
+    mydata = 42
+    
+        def test_function(mydata):
+    >       assert mydata == 23
+    E       assert 42 == 23
+    
+    test_caching.py:14: AssertionError
+    1 failed in 0.12 seconds
+
+See the `cache-api`_ for more details.
+
+
+Inspecting Cache content
+-------------------------------
+
+You can always peek at the content of the cache using the
+``--cache-clear`` command line option::
+
+    $ py.test --cache-clear
+    ======= test session starts ========
+    platform linux -- Python 3.4.3, pytest-2.8.1, py-1.4.30, pluggy-0.3.1
+    rootdir: $REGENDOC_TMPDIR, inifile: 
+    collected 1 items
+    
+    test_caching.py F
+    
+    ======= FAILURES ========
+    _______ test_function ________
+    
+    mydata = 42
+    
+        def test_function(mydata):
+    >       assert mydata == 23
+    E       assert 42 == 23
+    
+    test_caching.py:14: AssertionError
+    ======= 1 failed in 0.12 seconds ========
+
+Clearing Cache content
+-------------------------------
+
+You can instruct pytest to clear all cache files and values
+by adding the ``--cache-clear`` option like this::
+
+    py.test --cache-clear
+
+This is recommended for invocations from Continous Integration
+servers where isolation and correctness is more important
+than speed.
+
+
+.. _`cache-api`:
+
+config.cache API
+------------------
+
+The `config.cache`` object allows other plugins,
+including ``conftest.py`` files,
+to safely and flexibly store and retrieve values across
+test runs because the ``config`` object is available
+in many places.
+
+Under the hood, the cache plugin uses the simple
+dumps/loads API of the json stdlib module
+
+.. currentmodule:: _pytest.cacheprovider
+
+.. automethod:: Cache.get
+.. automethod:: Cache.set
+.. automethod:: Cache.makedir

doc/en/capture.rst

@@ -63,15 +63,15 @@ and running this module will show you precisely the output
 of the failing function and hide the other one::
 
     $ py.test
-    =========================== test session starts ============================
-    platform linux -- Python 3.4.1 -- py-1.4.27 -- pytest-2.7.1
-    rootdir: /tmp/doc-exec-90, inifile: 
+    ======= test session starts ========
+    platform linux -- Python 3.4.3, pytest-2.8.1, py-1.4.30, pluggy-0.3.1
+    rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     
     test_module.py .F
     
-    ================================= FAILURES =================================
-    ________________________________ test_func2 ________________________________
+    ======= FAILURES ========
+    _______ test_func2 ________
     
         def test_func2():
     >       assert False
@@ -79,15 +79,17 @@ of the failing function and hide the other one::
     
     test_module.py:9: AssertionError
     -------------------------- Captured stdout setup ---------------------------
-    setting up <function test_func2 at 0x7fa678d6eb70>
-    ==================== 1 failed, 1 passed in 0.01 seconds ====================
+    setting up <function test_func2 at 0xdeadbeef>
+    ======= 1 failed, 1 passed in 0.12 seconds ========
 
 Accessing captured output from a test function
 ---------------------------------------------------
 
 The ``capsys`` and ``capfd`` fixtures allow to access stdout/stderr
 output created during test execution.  Here is an example test function
-that performs some output related checks::
+that performs some output related checks:
+
+.. code-block:: python
 
     def test_myoutput(capsys): # or use "capfd" for fd-level
         print ("hello")

doc/en/conf.py

@@ -47,7 +47,7 @@ extensions = ['sphinx.ext.autodoc', 'sphinx.ext.todo', 'sphinx.ext.autosummary',
 templates_path = ['_templates']
 
 # The suffix of source filenames.
-source_suffix = '.txt'
+source_suffix = '.rst'
 
 # The encoding of source files.
 #source_encoding = 'utf-8-sig'
@@ -73,13 +73,13 @@ copyright = u'2015, holger krekel and pytest-dev team'
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
-exclude_patterns = ['links.inc', '_build', 'naming20.txt', 'test/*',
+exclude_patterns = ['links.inc', '_build', 'naming20.rst', 'test/*',
     "old_*",
     '*attic*',
     '*/attic*',
-    'funcargs.txt',
-    'setup.txt',
-    'example/remoteinterp.txt',
+    'funcargs.rst',
+    'setup.rst',
+    'example/remoteinterp.rst',
     ]
 
 

doc/en/contact.rst

@@ -29,7 +29,7 @@ Contact channels
 - `merlinux.eu`_ offers pytest and tox-related professional teaching and
   consulting.
 
-.. _`pytest issue tracker`: http://bitbucket.org/pytest-dev/pytest/issues/
+.. _`pytest issue tracker`: https://github.com/pytest-dev/pytest/issues
 .. _`old issue tracker`: http://bitbucket.org/hpk42/py-trunk/issues/
 
 .. _`merlinux.eu`: http://merlinux.eu

doc/en/contents.rst

@@ -12,16 +12,22 @@ Full pytest documentation
 
    overview
    apiref
-   plugins
-   plugins_index/index
    example/index
-   talks
+   plugins
+   cache
    contributing
-   funcarg_compare.txt
-   announce/index
+   plugins_index/index
+   talks
 
-.. toctree::
-   :hidden:
+.. only:: html
+   .. toctree::
 
-   changelog.txt
+      funcarg_compare
+      announce/index
+
+.. only:: html
+   .. toctree::
+      :hidden:
+
+      changelog
 

doc/en/customize.rst

@@ -89,7 +89,9 @@ How to change command line options defaults
 It can be tedious to type the same series of command line options
 every time you use ``pytest``.  For example, if you always want to see
 detailed info on skipped and xfailed tests, as well as have terser "dot"
-progress output, you can write it into a configuration file::
+progress output, you can write it into a configuration file:
+
+.. code-block:: ini
 
     # content of pytest.ini
     # (or tox.ini or setup.cfg)
@@ -117,14 +119,16 @@ Builtin configuration file options
 .. confval:: addopts
 
    Add the specified ``OPTS`` to the set of command line arguments as if they
-   had been specified by the user. Example: if you have this ini file content::
+   had been specified by the user. Example: if you have this ini file content:
 
-       [pytest]
-       addopts = --maxfail=2 -rf  # exit after 2 failures, report fail info
+   .. code-block:: ini
+
+        [pytest]
+        addopts = --maxfail=2 -rf  # exit after 2 failures, report fail info
 
    issuing ``py.test test_hello.py`` actually means::
 
-       py.test --maxfail=2 -rf test_hello.py
+        py.test --maxfail=2 -rf test_hello.py
 
    Default is to add no options.
 
@@ -142,15 +146,36 @@ Builtin configuration file options
 
    Default patterns are ``'.*', 'CVS', '_darcs', '{arch}', '*.egg'``.
    Setting a ``norecursedirs`` replaces the default.  Here is an example of
-   how to avoid certain directories::
+   how to avoid certain directories:
 
-    # content of setup.cfg
-    [pytest]
-    norecursedirs = .svn _build tmp*
+   .. code-block:: ini
+
+        # content of setup.cfg
+        [pytest]
+        norecursedirs = .svn _build tmp*
 
    This would tell ``pytest`` to not look into typical subversion or
    sphinx-build directories or into any ``tmp`` prefixed directory.
 
+.. confval:: testpaths
+
+   .. versionadded:: 2.8
+
+   Sets list of directories that should be searched for tests when
+   no specific directories or files are given in the command line when
+   executing pytest from the :ref:`rootdir <rootdir>` directory.
+   Useful when all project tests are in a known location to speed up
+   test collection and to avoid picking up undesired tests by accident.
+
+   .. code-block:: ini
+
+        # content of pytest.ini
+        [pytest]
+        testpaths = testing doc
+
+   This tells pytest to only look for tests in ``testing`` and ``doc``
+   directories when executing from the root directory.
+
 .. confval:: python_files
 
    One or more Glob-style file patterns determining which python files
@@ -160,11 +185,13 @@ Builtin configuration file options
 
    One or more name prefixes or glob-style patterns determining which classes
    are considered for test collection. Here is an example of how to collect
-   tests from classes that end in ``Suite``::
+   tests from classes that end in ``Suite``:
 
-    # content of pytest.ini
-    [pytest]
-    python_classes = *Suite
+   .. code-block:: ini
+
+        # content of pytest.ini
+        [pytest]
+        python_classes = *Suite
 
    Note that ``unittest.TestCase`` derived classes are always collected
    regardless of this option, as ``unittest``'s own collection framework is used
@@ -174,11 +201,13 @@ Builtin configuration file options
 
    One or more name prefixes or glob-patterns determining which test functions
    and methods are considered tests. Here is an example of how
-   to collect test functions and methods that end in ``_test``::
+   to collect test functions and methods that end in ``_test``:
 
-    # content of pytest.ini
-    [pytest]
-    python_functions = *_test
+   .. code-block:: ini
+
+        # content of pytest.ini
+        [pytest]
+        python_functions = *_test
 
    Note that this has no effect on methods that live on a ``unittest
    .TestCase`` derived class, as ``unittest``'s own collection framework is used
@@ -190,3 +219,10 @@ Builtin configuration file options
 
    One or more doctest flag names from the standard ``doctest`` module.
    :doc:`See how py.test handles doctests <doctest>`.
+
+.. confval:: confcutdir
+
+   Sets a directory where search upwards for ``conftest.py`` files stops.
+   By default, pytest will stop searching for ``conftest.py`` files upwards
+   from ``pytest.ini``/``tox.ini``/``setup.cfg`` of the project if any,
+   or up to the file-system root.

doc/en/doctest.rst

@@ -15,7 +15,9 @@ python test modules)::
     py.test --doctest-modules
 
 You can make these changes permanent in your project by
-putting them into a pytest.ini file like this::
+putting them into a pytest.ini file like this:
+
+.. code-block:: ini
 
     # content of pytest.ini
     [pytest]
@@ -43,14 +45,14 @@ and another like this::
 then you can just invoke ``py.test`` without command line options::
 
     $ py.test
-    =========================== test session starts ============================
-    platform linux -- Python 3.4.1 -- py-1.4.27 -- pytest-2.7.1
-    rootdir: /tmp/doc-exec-96, inifile: pytest.ini
+    ======= test session starts ========
+    platform linux -- Python 3.4.3, pytest-2.8.1, py-1.4.30, pluggy-0.3.1
+    rootdir: $REGENDOC_TMPDIR, inifile: pytest.ini
     collected 1 items
     
     mymodule.py .
     
-    ========================= 1 passed in 0.06 seconds =========================
+    ======= 1 passed in 0.12 seconds ========
 
 It is possible to use fixtures using the ``getfixture`` helper::
 
@@ -70,3 +72,18 @@ ignore lengthy exception stack traces you can just write::
     # content of pytest.ini
     [pytest]
     doctest_optionflags= NORMALIZE_WHITESPACE IGNORE_EXCEPTION_DETAIL
+
+
+py.test also introduces a new ``ALLOW_UNICODE`` option flag: when enabled, the
+``u`` prefix is stripped from unicode strings in expected doctest output. This
+allows doctests which use unicode to run in Python 2 and 3 unchanged.
+
+As with any other option flag, this flag can be enabled in ``pytest.ini`` using
+the ``doctest_optionflags`` ini option or by an inline comment in the doc test
+itself::
+
+    # content of example.rst
+    >>> get_unicode_greeting()  # doctest: +ALLOW_UNICODE
+    'Hello'
+
+