Regendocs for 3.0.5

Use a simple ``+-`` ASCII string in the string representation of pytest.approx In Python 2

.github/ISSUE_TEMPLATE.md

@@ -4,5 +4,5 @@ Here's a quick checklist in what to include:
 
 - [ ] Include a detailed description of the bug or suggestion
 - [ ] `pip list` of the virtual environment you are using
-- [ ] py.test and operating system versions
+- [ ] pytest and operating system versions
 - [ ] Minimal example if possible

.github/PULL_REQUEST_TEMPLATE.md

@@ -2,7 +2,13 @@ Thanks for submitting a PR, your contribution is really appreciated!
 
 Here's a quick checklist that should be present in PRs:
 
-- [ ] Target: for bug or doc fixes, target `master`; for new features, target `features`
-- [ ] Make sure to include one or more tests for your change
-- [ ] Add yourself to `AUTHORS`
-- [ ] Add a new entry to the `CHANGELOG` (choose any open position to avoid merge conflicts with other PRs) 
+- [ ] Target: for bug or doc fixes, target `master`; for new features, target `features`;
+
+Unless your change is trivial documentation fix (e.g.,  a typo or reword of a small section) please:
+
+- [ ] Make sure to include one or more tests for your change;
+- [ ] Add yourself to `AUTHORS`;
+- [ ] Add a new entry to `CHANGELOG.rst`
+  * Choose any open position to avoid merge conflicts with other PRs.
+  * Add a link to the issue you are fixing (if any) using RST syntax.
+  * The pytest team likes to have people to acknowledged in the `CHANGELOG`, so please add a thank note to yourself ("Thanks @user for the PR") and a link to your GitHub profile. It may sound weird thanking yourself, but otherwise a maintainer would have to do it manually before or after merging instead of just using GitHub's merge button. This makes it easier on the maintainers to merge PRs. 

.gitignore

@@ -33,3 +33,4 @@ env/
 .coverage
 .ropeproject
 .idea
+.hypothesis

.travis.yml

@@ -25,7 +25,13 @@ env:
     - TESTENV=py35-trial
     - TESTENV=py27-nobyte
     - TESTENV=doctesting
-    - TESTENV=py27-cxfreeze
+    - TESTENV=freeze
+    - TESTENV=docs
+
+matrix:
+  allow_failures:
+    # py35-trial failing on Linux: #1989
+    - env: TESTENV=py35-trial
 
 script: tox --recreate -e $TESTENV
 

AUTHORS

@@ -3,45 +3,65 @@ merlinux GmbH, Germany, office at merlinux eu
 
 Contributors include::
 
+Abdeali JK
 Abhijeet Kasurde
+Ahn Ki-Wook
+Alexei Kozlenok
 Anatoly Bubenkoff
 Andreas Zeidler
+Andrzej Ostrowski
 Andy Freeland
 Anthon van der Neut
+Antony Lee
 Armin Rigo
 Aron Curzon
 Aviv Palivoda
+Ben Webb
 Benjamin Peterson
+Bernard Pratz
 Bob Ippolito
 Brian Dorsey
 Brian Okken
 Brianna Laugher
 Bruno Oliveira
+Cal Leeming
 Carl Friedrich Bolz
 Charles Cloud
+Charnjit SiNGH (CCSJ)
 Chris Lamb
+Christian Boelsen
 Christian Theunert
 Christian Tismer
 Christopher Gilling
 Daniel Grana
 Daniel Hahler
 Daniel Nuri
+Daniel Wandschneider
+Danielle Jenkins
 Dave Hunt
+David Díaz-Barquero
 David Mohr
 David Vierra
+Diego Russo
+Dmitry Dygalo
+Duncan Betts
 Edison Gustavo Muenz
+Edoardo Batini
 Eduardo Schettino
-Endre Galaczi
 Elizaveta Shashkova
+Endre Galaczi
 Eric Hunsberger
 Eric Siegerman
 Erik M. Bray
+Feng Ma
 Florian Bruhin
 Floris Bruynooghe
 Gabriel Reis
 Georgy Dyuldin
 Graham Horler
+Greg Price
 Grig Gheorghiu
+Grigorii Eremeev (budulianin)
 Guido Wesdorp
 Harald Armin Massa
 Ian Bicking
@@ -49,43 +69,73 @@ Jaap Broekhuizen
 Jan Balster
 Janne Vanhala
 Jason R. Coombs
+Javier Domingo Cansino
+Javier Romero
 John Towler
+Jon Sonesen
+Jordan Guymon
 Joshua Bronson
 Jurko Gospodnetić
+Justyna Janczyszyn
+Kale Kundert
 Katarzyna Jachim
 Kevin Cox
 Lee Kamentsky
+Lev Maximov
 Lukas Bednar
+Luke Murphy
 Maciek Fijalkowski
 Maho
 Marc Schlaich
+Marcin Bachry
 Mark Abramowitz
 Markus Unterwaditzer
 Martijn Faassen
+Martin K. Scherer
 Martin Prusse
+Mathieu Clabaut
 Matt Bachmann
+Matt Williams
+Matthias Hafner
+mbyt
 Michael Aquilina
 Michael Birtwell
 Michael Droettboom
+Michael Seifert
+Mike Lundy
+Ned Batchelder
+Neven Mundar
 Nicolas Delaby
+Oleg Pidsadnyi
+Oliver Bestwalter
+Omar Kohl
 Pieter Mulder
 Piotr Banaszkiewicz
 Punyashloka Biswal
 Quentin Pradet
 Ralf Schmitt
 Raphael Pierzina
+Raquel Alegre
+Roberto Polli
+Romain Dorgueil
+Roman Bolshakov
 Ronny Pfannschmidt
 Ross Lawley
+Russel Winder
 Ryan Wooden
 Samuele Pedroni
+Simon Gomizelj
+Stefan Farmbauer
+Stefan Zimmermann
+Stefano Taschini
+Steffen Allner
+Stephan Obermann
+Tareq Alayan
+Ted Xiao
+Thomas Grainger
 Tom Viner
 Trevor Bekolay
+Tyler Goodlet
+Vasily Kuznetsov
 Wouter van Ackooy
-David Díaz-Barquero
-Eric Hunsberger
-Simon Gomizelj
-Russel Winder
-Ben Webb
-Alexei Kozlenok
-Cal Leeming
-Feng Ma
+Xuecong Liao

CHANGELOG.rst

@@ -1,3 +1,656 @@
+3.0.5
+=====
+
+* Add warning when not passing ``option=value`` correctly to ``-o/--override-ini`` (`#2105`_).
+  Also improved the help documentation. Thanks to `@mbukatov`_ for the report and
+  `@lwm`_ for the PR.
+
+* Now ``--confcutdir`` and ``--junit-xml`` are properly validated if they are directories
+  and filenames, respectively (`#2089`_ and `#2078`_). Thanks to `@lwm`_ for the PR.
+
+* Add hint to error message hinting possible missing ``__init__.py`` (`#478`_). Thanks `@DuncanBetts`_.
+
+* More accurately describe when fixture finalization occurs in documentation (`#687`_). Thanks `@DuncanBetts`_.
+
+* Provide ``:ref:`` targets for ``recwarn.rst`` so we can use intersphinx referencing.
+  Thanks to `@dupuy`_ for the report and `@lwm`_ for the PR.
+
+* In Python 2, use a simple ``+-`` ASCII string in the string representation of ``pytest.approx`` (for example ``"4 +- 4.0e-06"``)
+  because it is brittle to handle that in different contexts and representations internally in pytest
+  which can result in bugs such as `#2111`_. In Python 3, the representation still uses ``±`` (for example ``4 ± 4.0e-06``).
+  Thanks `@kerrick-lyft`_ for the report and `@nicoddemus`_ for the PR.
+
+* Using ``item.Function``, ``item.Module``, etc., is now issuing deprecation warnings, prefer
+  ``pytest.Function``, ``pytest.Module``, etc., instead (`#2034`_).
+  Thanks `@nmundar`_ for the PR.
+
+* Fix error message using ``approx`` with complex numbers (`#2082`_).
+  Thanks `@adler-j`_ for the report and `@nicoddemus`_ for the PR.
+
+* Fixed false-positives warnings from assertion rewrite hook for modules imported more than
+  once by the ``pytest_plugins`` mechanism.
+  Thanks `@nicoddemus`_ for the PR.
+
+* Remove an internal cache which could cause hooks from ``conftest.py`` files in
+  sub-directories to be called in other directories incorrectly (`#2016`_).
+  Thanks `@d-b-w`_ for the report and `@nicoddemus`_ for the PR.
+
+* Remove internal code meant to support earlier Python 3 versions that produced the side effect
+  of leaving ``None`` in ``sys.modules`` when expressions were evaluated by pytest (for example passing a condition
+  as a string to ``pytest.mark.skipif``)(`#2103`_).
+  Thanks `@jaraco`_ for the report and `@nicoddemus`_ for the PR.
+
+* Cope gracefully with a .pyc file with no matching .py file (`#2038`_). Thanks
+  `@nedbat`_.
+
+.. _@adler-j: https://github.com/adler-j
+.. _@d-b-w: https://bitbucket.org/d-b-w/
+.. _@DuncanBetts: https://github.com/DuncanBetts
+.. _@dupuy: https://bitbucket.org/dupuy/
+.. _@kerrick-lyft: https://github.com/kerrick-lyft
+.. _@lwm: https://github.com/lwm
+.. _@mbukatov: https://github.com/mbukatov
+.. _@nedbat: https://github.com/nedbat
+.. _@nmundar: https://github.com/nmundar
+
+.. _#2016: https://github.com/pytest-dev/pytest/issues/2016
+.. _#2034: https://github.com/pytest-dev/pytest/issues/2034
+.. _#2038: https://github.com/pytest-dev/pytest/issues/2038
+.. _#2078: https://github.com/pytest-dev/pytest/issues/2078
+.. _#2082: https://github.com/pytest-dev/pytest/issues/2082
+.. _#2089: https://github.com/pytest-dev/pytest/issues/2089
+.. _#2103: https://github.com/pytest-dev/pytest/issues/2103
+.. _#2105: https://github.com/pytest-dev/pytest/issues/2105
+.. _#2111: https://github.com/pytest-dev/pytest/issues/2111
+.. _#478: https://github.com/pytest-dev/pytest/issues/478
+.. _#687: https://github.com/pytest-dev/pytest/issues/687
+
+
+3.0.4
+=====
+
+* Import errors when collecting test modules now display the full traceback (`#1976`_).
+  Thanks `@cwitty`_ for the report and `@nicoddemus`_ for the PR.
+
+* Fix confusing command-line help message for custom options with two or more ``metavar`` properties (`#2004`_).
+  Thanks `@okulynyak`_ and `@davehunt`_ for the report and `@nicoddemus`_ for the PR.
+
+* When loading plugins, import errors which contain non-ascii messages are now properly handled in Python 2 (`#1998`_).
+  Thanks `@nicoddemus`_ for the PR.
+
+* Fixed cyclic reference when ``pytest.raises`` is used in context-manager form (`#1965`_). Also as a
+  result of this fix, ``sys.exc_info()`` is left empty in both context-manager and function call usages.
+  Previously, ``sys.exc_info`` would contain the exception caught by the context manager,
+  even when the expected exception occurred.
+  Thanks `@MSeifert04`_ for the report and the PR.
+
+* Fixed false-positives warnings from assertion rewrite hook for modules that were rewritten but
+  were later marked explicitly by ``pytest.register_assert_rewrite``
+  or implicitly as a plugin (`#2005`_).
+  Thanks `@RonnyPfannschmidt`_ for the report and `@nicoddemus`_ for the PR.
+
+* Report teardown output on test failure (`#442`_).
+  Thanks `@matclab`_ for the PR.
+
+* Fix teardown error message in generated xUnit XML.
+  Thanks `@gdyuldin`_ for the PR.
+
+* Properly handle exceptions in ``multiprocessing`` tasks (`#1984`_).
+  Thanks `@adborden`_ for the report and `@nicoddemus`_ for the PR.
+
+* Clean up unittest TestCase objects after tests are complete (`#1649`_).
+  Thanks `@d_b_w`_ for the report and PR.
+
+
+.. _@adborden: https://github.com/adborden
+.. _@cwitty: https://github.com/cwitty
+.. _@d_b_w: https://github.com/d_b_w
+.. _@gdyuldin: https://github.com/gdyuldin
+.. _@matclab: https://github.com/matclab
+.. _@MSeifert04: https://github.com/MSeifert04
+.. _@okulynyak: https://github.com/okulynyak
+
+.. _#442: https://github.com/pytest-dev/pytest/issues/442
+.. _#1965: https://github.com/pytest-dev/pytest/issues/1965
+.. _#1976: https://github.com/pytest-dev/pytest/issues/1976
+.. _#1984: https://github.com/pytest-dev/pytest/issues/1984
+.. _#1998: https://github.com/pytest-dev/pytest/issues/1998
+.. _#2004: https://github.com/pytest-dev/pytest/issues/2004
+.. _#2005: https://github.com/pytest-dev/pytest/issues/2005
+.. _#1649: https://github.com/pytest-dev/pytest/issues/1649
+
+
+3.0.3
+=====
+
+* The ``ids`` argument to ``parametrize`` again accepts ``unicode`` strings
+  in Python 2 (`#1905`_).
+  Thanks `@philpep`_ for the report and `@nicoddemus`_ for the PR.
+
+* Assertions are now being rewritten for plugins in development mode
+  (``pip install -e``) (`#1934`_).
+  Thanks `@nicoddemus`_ for the PR.
+
+* Fix pkg_resources import error in Jython projects (`#1853`_).
+  Thanks `@raquel-ucl`_ for the PR.
+
+* Got rid of ``AttributeError: 'Module' object has no attribute '_obj'`` exception
+  in Python 3 (`#1944`_).
+  Thanks `@axil`_ for the PR.
+
+* Explain a bad scope value passed to ``@fixture`` declarations or
+  a ``MetaFunc.parametrize()`` call. Thanks `@tgoodlet`_ for the PR.
+
+* This version includes ``pluggy-0.4.0``, which correctly handles
+  ``VersionConflict`` errors in plugins (`#704`_).
+  Thanks `@nicoddemus`_ for the PR.
+
+
+.. _@philpep: https://github.com/philpep
+.. _@raquel-ucl: https://github.com/raquel-ucl
+.. _@axil: https://github.com/axil
+.. _@tgoodlet: https://github.com/tgoodlet
+
+.. _#1853: https://github.com/pytest-dev/pytest/issues/1853
+.. _#1905: https://github.com/pytest-dev/pytest/issues/1905
+.. _#1934: https://github.com/pytest-dev/pytest/issues/1934
+.. _#1944: https://github.com/pytest-dev/pytest/issues/1944
+.. _#704: https://github.com/pytest-dev/pytest/issues/704
+
+
+
+3.0.2
+=====
+
+* Improve error message when passing non-string ids to ``pytest.mark.parametrize`` (`#1857`_).
+  Thanks `@okken`_ for the report and `@nicoddemus`_ for the PR.
+
+* Add ``buffer`` attribute to stdin stub class ``pytest.capture.DontReadFromInput``
+  Thanks `@joguSD`_ for the PR.
+
+* Fix ``UnicodeEncodeError`` when string comparison with unicode has failed. (`#1864`_)
+  Thanks `@AiOO`_ for the PR.
+
+* ``pytest_plugins`` is now handled correctly if defined as a string (as opposed as
+  a sequence of strings) when modules are considered for assertion rewriting.
+  Due to this bug, much more modules were being rewritten than necessary
+  if a test suite uses ``pytest_plugins`` to load internal plugins (`#1888`_).
+  Thanks `@jaraco`_ for the report and `@nicoddemus`_ for the PR (`#1891`_).
+
+* Do not call tearDown and cleanups when running tests from
+  ``unittest.TestCase`` subclasses with ``--pdb``
+  enabled. This allows proper post mortem debugging for all applications
+  which have significant logic in their tearDown machinery (`#1890`_). Thanks
+  `@mbyt`_ for the PR.
+
+* Fix use of deprecated ``getfuncargvalue`` method in the internal doctest plugin.
+  Thanks `@ViviCoder`_ for the report (`#1898`_).
+
+.. _@joguSD: https://github.com/joguSD
+.. _@AiOO: https://github.com/AiOO
+.. _@mbyt: https://github.com/mbyt
+.. _@ViviCoder: https://github.com/ViviCoder
+
+.. _#1857: https://github.com/pytest-dev/pytest/issues/1857
+.. _#1864: https://github.com/pytest-dev/pytest/issues/1864
+.. _#1888: https://github.com/pytest-dev/pytest/issues/1888
+.. _#1891: https://github.com/pytest-dev/pytest/pull/1891
+.. _#1890: https://github.com/pytest-dev/pytest/issues/1890
+.. _#1898: https://github.com/pytest-dev/pytest/issues/1898
+
+
+3.0.1
+=====
+
+* Fix regression when ``importorskip`` is used at module level (`#1822`_).
+  Thanks `@jaraco`_ and `@The-Compiler`_ for the report and `@nicoddemus`_ for the PR.
+
+* Fix parametrization scope when session fixtures are used in conjunction
+  with normal parameters in the same call (`#1832`_).
+  Thanks `@The-Compiler`_ for the report, `@Kingdread`_ and `@nicoddemus`_ for the PR.
+
+* Fix internal error when parametrizing tests or fixtures using an empty ``ids`` argument (`#1849`_).
+  Thanks `@OPpuolitaival`_ for the report and `@nicoddemus`_ for the PR.
+
+* Fix loader error when running ``pytest`` embedded in a zipfile.
+  Thanks `@mbachry`_ for the PR.
+
+
+.. _@Kingdread: https://github.com/Kingdread
+.. _@mbachry: https://github.com/mbachry
+.. _@OPpuolitaival: https://github.com/OPpuolitaival
+
+.. _#1822: https://github.com/pytest-dev/pytest/issues/1822
+.. _#1832: https://github.com/pytest-dev/pytest/issues/1832
+.. _#1849: https://github.com/pytest-dev/pytest/issues/1849
+
+
+3.0.0
+=====
+
+**Incompatible changes**
+
+
+A number of incompatible changes were made in this release, with the intent of removing features deprecated for a long
+time or change existing behaviors in order to make them less surprising/more useful.
+
+* Reinterpretation mode has now been removed.  Only plain and rewrite
+  mode are available, consequently the ``--assert=reinterp`` option is
+  no longer available.  This also means files imported from plugins or
+  ``conftest.py`` will not benefit from improved assertions by
+  default, you should use ``pytest.register_assert_rewrite()`` to
+  explicitly turn on assertion rewriting for those files.  Thanks
+  `@flub`_ for the PR.
+
+* The following deprecated commandline options were removed:
+
+  * ``--genscript``: no longer supported;
+  * ``--no-assert``: use ``--assert=plain`` instead;
+  * ``--nomagic``: use ``--assert=plain`` instead;
+  * ``--report``: use ``-r`` instead;
+
+  Thanks to `@RedBeardCode`_ for the PR (`#1664`_).
+
+* ImportErrors in plugins now are a fatal error instead of issuing a
+  pytest warning (`#1479`_). Thanks to `@The-Compiler`_ for the PR.
+
+* Removed support code for Python 3 versions < 3.3 (`#1627`_).
+
+* Removed all ``py.test-X*`` entry points. The versioned, suffixed entry points
+  were never documented and a leftover from a pre-virtualenv era. These entry
+  points also created broken entry points in wheels, so removing them also
+  removes a source of confusion for users (`#1632`_).
+  Thanks `@obestwalter`_ for the PR.
+
+* ``pytest.skip()`` now raises an error when used to decorate a test function,
+  as opposed to its original intent (to imperatively skip a test inside a test function). Previously
+  this usage would cause the entire module to be skipped (`#607`_).
+  Thanks `@omarkohl`_ for the complete PR (`#1519`_).
+
+* Exit tests if a collection error occurs. A poll indicated most users will hit CTRL-C
+  anyway as soon as they see collection errors, so pytest might as well make that the default behavior (`#1421`_).
+  A ``--continue-on-collection-errors`` option has been added to restore the previous behaviour.
+  Thanks `@olegpidsadnyi`_ and `@omarkohl`_ for the complete PR (`#1628`_).
+
+* Renamed the pytest ``pdb`` module (plugin) into ``debugging`` to avoid clashes with the builtin ``pdb`` module.
+
+* Raise a helpful failure message when requesting a parametrized fixture at runtime,
+  e.g. with ``request.getfixturevalue``. Previously these parameters were simply
+  never defined, so a fixture decorated like ``@pytest.fixture(params=[0, 1, 2])``
+  only ran once (`#460`_).
+  Thanks to `@nikratio`_ for the bug report, `@RedBeardCode`_ and `@tomviner`_ for the PR.
+
+* ``_pytest.monkeypatch.monkeypatch`` class has been renamed to ``_pytest.monkeypatch.MonkeyPatch``
+  so it doesn't conflict with the ``monkeypatch`` fixture.
+
+* ``--exitfirst / -x`` can now be overridden by a following ``--maxfail=N``
+  and is just a synonym for ``--maxfail=1``.
+
+
+**New Features**
+
+* Support nose-style ``__test__`` attribute on methods of classes,
+  including unittest-style Classes. If set to ``False``, the test will not be
+  collected.
+
+* New ``doctest_namespace`` fixture for injecting names into the
+  namespace in which doctests run.
+  Thanks `@milliams`_ for the complete PR (`#1428`_).
+
+* New ``--doctest-report`` option available to change the output format of diffs
+  when running (failing) doctests (implements `#1749`_).
+  Thanks `@hartym`_ for the PR.
+
+* New ``name`` argument to ``pytest.fixture`` decorator which allows a custom name
+  for a fixture (to solve the funcarg-shadowing-fixture problem).
+  Thanks `@novas0x2a`_ for the complete PR (`#1444`_).
+
+* New ``approx()`` function for easily comparing floating-point numbers in
+  tests.
+  Thanks `@kalekundert`_ for the complete PR (`#1441`_).
+
+* Ability to add global properties in the final xunit output file by accessing
+  the internal ``junitxml`` plugin (experimental).
+  Thanks `@tareqalayan`_ for the complete PR `#1454`_).
+
+* New ``ExceptionInfo.match()`` method to match a regular expression on the
+  string representation of an exception (`#372`_).
+  Thanks `@omarkohl`_ for the complete PR (`#1502`_).
+
+* ``__tracebackhide__`` can now also be set to a callable which then can decide
+  whether to filter the traceback based on the ``ExceptionInfo`` object passed
+  to it. Thanks `@The-Compiler`_ for the complete PR (`#1526`_).
+
+* New ``pytest_make_parametrize_id(config, val)`` hook which can be used by plugins to provide
+  friendly strings for custom types.
+  Thanks `@palaviv`_ for the PR.
+
+* ``capsys`` and ``capfd`` now have a ``disabled()`` context-manager method, which
+  can be used to temporarily disable capture within a test.
+  Thanks `@nicoddemus`_ for the PR.
+
+* New cli flag ``--fixtures-per-test``: shows which fixtures are being used
+  for each selected test item. Features doc strings of fixtures by default.
+  Can also show where fixtures are defined if combined with ``-v``.
+  Thanks `@hackebrot`_ for the PR.
+
+* Introduce ``pytest`` command as recommended entry point. Note that ``py.test``
+  still works and is not scheduled for removal. Closes proposal
+  `#1629`_. Thanks `@obestwalter`_ and `@davehunt`_ for the complete PR
+  (`#1633`_).
+
+* New cli flags:
+
+  + ``--setup-plan``: performs normal collection and reports
+    the potential setup and teardown and does not execute any fixtures and tests;
+  + ``--setup-only``: performs normal collection, executes setup and teardown of
+    fixtures and reports them;
+  + ``--setup-show``: performs normal test execution and additionally shows
+    setup and teardown of fixtures;
+  + ``--keep-duplicates``: py.test now ignores duplicated paths given in the command
+    line. To retain the previous behavior where the same test could be run multiple
+    times by specifying it in the command-line multiple times, pass the ``--keep-duplicates``
+    argument (`#1609`_);
+
+  Thanks `@d6e`_, `@kvas-it`_, `@sallner`_, `@ioggstream`_ and `@omarkohl`_ for the PRs.
+
+* New CLI flag ``--override-ini``/``-o``: overrides values from the ini file.
+  For example: ``"-o xfail_strict=True"``'.
+  Thanks `@blueyed`_ and `@fengxx`_ for the PR.
+
+* New hooks:
+
+  + ``pytest_fixture_setup(fixturedef, request)``: executes fixture setup;
+  + ``pytest_fixture_post_finalizer(fixturedef)``: called after the fixture's
+    finalizer and has access to the fixture's result cache.
+
+  Thanks `@d6e`_, `@sallner`_.
+
+* Issue warnings for asserts whose test is a tuple literal. Such asserts will
+  never fail because tuples are always truthy and are usually a mistake
+  (see `#1562`_). Thanks `@kvas-it`_, for the PR.
+
+* Allow passing a custom debugger class (e.g. ``--pdbcls=IPython.core.debugger:Pdb``).
+  Thanks to `@anntzer`_ for the PR.
+
+
+**Changes**
+
+* Plugins now benefit from assertion rewriting.  Thanks
+  `@sober7`_, `@nicoddemus`_ and `@flub`_ for the PR.
+
+* Change ``report.outcome`` for ``xpassed`` tests to ``"passed"`` in non-strict
+  mode and ``"failed"`` in strict mode. Thanks to `@hackebrot`_ for the PR
+  (`#1795`_) and `@gprasad84`_ for report (`#1546`_).
+
+* Tests marked with ``xfail(strict=False)`` (the default) now appear in
+  JUnitXML reports as passing tests instead of skipped.
+  Thanks to `@hackebrot`_ for the PR (`#1795`_).
+
+* Highlight path of the file location in the error report to make it easier to copy/paste.
+  Thanks `@suzaku`_ for the PR (`#1778`_).
+
+* Fixtures marked with ``@pytest.fixture`` can now use ``yield`` statements exactly like
+  those marked with the ``@pytest.yield_fixture`` decorator. This change renders
+  ``@pytest.yield_fixture`` deprecated and makes ``@pytest.fixture`` with ``yield`` statements
+  the preferred way to write teardown code (`#1461`_).
+  Thanks `@csaftoiu`_ for bringing this to attention and `@nicoddemus`_ for the PR.
+
+* Explicitly passed parametrize ids do not get escaped to ascii (`#1351`_).
+  Thanks `@ceridwen`_ for the PR.
+
+* Fixtures are now sorted in the error message displayed when an unknown
+  fixture is declared in a test function.
+  Thanks `@nicoddemus`_ for the PR.
+
+* ``pytest_terminal_summary`` hook now receives the ``exitstatus``
+  of the test session as argument. Thanks `@blueyed`_ for the PR (`#1809`_).
+
+* Parametrize ids can accept ``None`` as specific test id, in which case the
+  automatically generated id for that argument will be used.
+  Thanks `@palaviv`_ for the complete PR (`#1468`_).
+
+* The parameter to xunit-style setup/teardown methods (``setup_method``,
+  ``setup_module``, etc.) is now optional and may be omitted.
+  Thanks `@okken`_ for bringing this to attention and `@nicoddemus`_ for the PR.
+
+* Improved automatic id generation selection in case of duplicate ids in
+  parametrize.
+  Thanks `@palaviv`_ for the complete PR (`#1474`_).
+
+* Now pytest warnings summary is shown up by default. Added a new flag
+  ``--disable-pytest-warnings`` to explicitly disable the warnings summary (`#1668`_).
+
+* Make ImportError during collection more explicit by reminding
+  the user to check the name of the test module/package(s) (`#1426`_).
+  Thanks `@omarkohl`_ for the complete PR (`#1520`_).
+
+* Add ``build/`` and ``dist/`` to the default ``--norecursedirs`` list. Thanks
+  `@mikofski`_ for the report and `@tomviner`_ for the PR (`#1544`_).
+
+* ``pytest.raises`` in the context manager form accepts a custom
+  ``message`` to raise when no exception occurred.
+  Thanks `@palaviv`_ for the complete PR (`#1616`_).
+
+* ``conftest.py`` files now benefit from assertion rewriting; previously it
+  was only available for test modules. Thanks `@flub`_, `@sober7`_ and
+  `@nicoddemus`_ for the PR (`#1619`_).
+
+* Text documents without any doctests no longer appear as "skipped".
+  Thanks `@graingert`_ for reporting and providing a full PR (`#1580`_).
+
+* Ensure that a module within a namespace package can be found when it
+  is specified on the command line together with the ``--pyargs``
+  option.  Thanks to `@taschini`_ for the PR (`#1597`_).
+
+* Always include full assertion explanation during assertion rewriting. The previous behaviour was hiding
+  sub-expressions that happened to be ``False``, assuming this was redundant information.
+  Thanks `@bagerard`_ for reporting (`#1503`_). Thanks to `@davehunt`_ and
+  `@tomviner`_ for the PR.
+
+* ``OptionGroup.addoption()`` now checks if option names were already
+  added before, to make it easier to track down issues like `#1618`_.
+  Before, you only got exceptions later from ``argparse`` library,
+  giving no clue about the actual reason for double-added options.
+
+* ``yield``-based tests are considered deprecated and will be removed in pytest-4.0.
+  Thanks `@nicoddemus`_ for the PR.
+
+* ``[pytest]`` sections in ``setup.cfg`` files should now be named ``[tool:pytest]``
+  to avoid conflicts with other distutils commands (see `#567`_). ``[pytest]`` sections in
+  ``pytest.ini`` or ``tox.ini`` files are supported and unchanged.
+  Thanks `@nicoddemus`_ for the PR.
+
+* Using ``pytest_funcarg__`` prefix to declare fixtures is considered deprecated and will be
+  removed in pytest-4.0 (`#1684`_).
+  Thanks `@nicoddemus`_ for the PR.
+
+* Passing a command-line string to ``pytest.main()`` is considered deprecated and scheduled
+  for removal in pytest-4.0. It is recommended to pass a list of arguments instead (`#1723`_).
+
+* Rename ``getfuncargvalue`` to ``getfixturevalue``. ``getfuncargvalue`` is
+  still present but is now considered deprecated. Thanks to `@RedBeardCode`_ and `@tomviner`_
+  for the PR (`#1626`_).
+
+* ``optparse`` type usage now triggers DeprecationWarnings (`#1740`_).
+
+
+* ``optparse`` backward compatibility supports float/complex types (`#457`_).
+
+* Refined logic for determining the ``rootdir``, considering only valid
+  paths which fixes a number of issues: `#1594`_, `#1435`_ and `#1471`_.
+  Updated the documentation according to current behavior. Thanks to
+  `@blueyed`_, `@davehunt`_ and `@matthiasha`_ for the PR.
+
+* Always include full assertion explanation. The previous behaviour was hiding
+  sub-expressions that happened to be False, assuming this was redundant information.
+  Thanks `@bagerard`_ for reporting (`#1503`_). Thanks to `@davehunt`_ and
+  `@tomviner`_ for PR.
+
+* Better message in case of not using parametrized variable (see `#1539`_).
+  Thanks to `@tramwaj29`_ for the PR.
+
+* Updated docstrings with a more uniform style.
+
+* Add stderr write for ``pytest.exit(msg)`` during startup. Previously the message was never shown.
+  Thanks `@BeyondEvil`_ for reporting `#1210`_. Thanks to `@JonathonSonesen`_ and
+  `@tomviner`_ for the PR.
+
+* No longer display the incorrect test deselection reason (`#1372`_).
+  Thanks `@ronnypfannschmidt`_ for the PR.
+
+* The ``--resultlog`` command line option has been deprecated: it is little used
+  and there are more modern and better alternatives (see `#830`_).
+  Thanks `@nicoddemus`_ for the PR.
+
+* Improve error message with fixture lookup errors: add an 'E' to the first
+  line and '>' to the rest. Fixes `#717`_. Thanks `@blueyed`_ for reporting and
+  a PR, `@eolo999`_ for the initial PR and `@tomviner`_ for his guidance during
+  EuroPython2016 sprint.
+
+
+**Bug Fixes**
+
+* Parametrize now correctly handles duplicated test ids.
+
+* Fix internal error issue when the ``method`` argument is missing for
+  ``teardown_method()`` (`#1605`_).
+
+* Fix exception visualization in case the current working directory (CWD) gets
+  deleted during testing (`#1235`_). Thanks `@bukzor`_ for reporting. PR by
+  `@marscher`_.
+
+* Improve test output for logical expression with brackets (`#925`_).
+  Thanks `@DRMacIver`_ for reporting and `@RedBeardCode`_ for the PR.
+
+* Create correct diff for strings ending with newlines (`#1553`_).
+  Thanks `@Vogtinator`_ for reporting and `@RedBeardCode`_ and
+  `@tomviner`_ for the PR.
+
+* ``ConftestImportFailure`` now shows the traceback making it easier to
+  identify bugs in ``conftest.py`` files (`#1516`_). Thanks `@txomon`_ for
+  the PR.
+
+* Text documents without any doctests no longer appear as "skipped".
+  Thanks `@graingert`_ for reporting and providing a full PR (`#1580`_).
+
+* Fixed collection of classes with custom ``__new__`` method.
+  Fixes `#1579`_. Thanks to `@Stranger6667`_ for the PR.
+
+* Fixed scope overriding inside metafunc.parametrize (`#634`_).
+  Thanks to `@Stranger6667`_ for the PR.
+
+* Fixed the total tests tally in junit xml output (`#1798`_).
+  Thanks to `@cryporchild`_ for the PR.
+
+* Fixed off-by-one error with lines from ``request.node.warn``.
+  Thanks to `@blueyed`_ for the PR.
+
+
+.. _#1210: https://github.com/pytest-dev/pytest/issues/1210
+.. _#1235: https://github.com/pytest-dev/pytest/issues/1235
+.. _#1351: https://github.com/pytest-dev/pytest/issues/1351
+.. _#1372: https://github.com/pytest-dev/pytest/issues/1372
+.. _#1421: https://github.com/pytest-dev/pytest/issues/1421
+.. _#1426: https://github.com/pytest-dev/pytest/issues/1426
+.. _#1428: https://github.com/pytest-dev/pytest/pull/1428
+.. _#1435: https://github.com/pytest-dev/pytest/issues/1435
+.. _#1441: https://github.com/pytest-dev/pytest/pull/1441
+.. _#1444: https://github.com/pytest-dev/pytest/pull/1444
+.. _#1454: https://github.com/pytest-dev/pytest/pull/1454
+.. _#1461: https://github.com/pytest-dev/pytest/pull/1461
+.. _#1468: https://github.com/pytest-dev/pytest/pull/1468
+.. _#1471: https://github.com/pytest-dev/pytest/issues/1471
+.. _#1474: https://github.com/pytest-dev/pytest/pull/1474
+.. _#1479: https://github.com/pytest-dev/pytest/issues/1479
+.. _#1502: https://github.com/pytest-dev/pytest/pull/1502
+.. _#1503: https://github.com/pytest-dev/pytest/issues/1503
+.. _#1516: https://github.com/pytest-dev/pytest/pull/1516
+.. _#1519: https://github.com/pytest-dev/pytest/pull/1519
+.. _#1520: https://github.com/pytest-dev/pytest/pull/1520
+.. _#1526: https://github.com/pytest-dev/pytest/pull/1526
+.. _#1539: https://github.com/pytest-dev/pytest/issues/1539
+.. _#1544: https://github.com/pytest-dev/pytest/issues/1544
+.. _#1546: https://github.com/pytest-dev/pytest/issues/1546
+.. _#1553: https://github.com/pytest-dev/pytest/issues/1553
+.. _#1562: https://github.com/pytest-dev/pytest/issues/1562
+.. _#1579: https://github.com/pytest-dev/pytest/issues/1579
+.. _#1580: https://github.com/pytest-dev/pytest/pull/1580
+.. _#1594: https://github.com/pytest-dev/pytest/issues/1594
+.. _#1597: https://github.com/pytest-dev/pytest/pull/1597
+.. _#1605: https://github.com/pytest-dev/pytest/issues/1605
+.. _#1616: https://github.com/pytest-dev/pytest/pull/1616
+.. _#1618: https://github.com/pytest-dev/pytest/issues/1618
+.. _#1619: https://github.com/pytest-dev/pytest/issues/1619
+.. _#1626: https://github.com/pytest-dev/pytest/pull/1626
+.. _#1627: https://github.com/pytest-dev/pytest/pull/1627
+.. _#1628: https://github.com/pytest-dev/pytest/pull/1628
+.. _#1629: https://github.com/pytest-dev/pytest/issues/1629
+.. _#1632: https://github.com/pytest-dev/pytest/issues/1632
+.. _#1633: https://github.com/pytest-dev/pytest/pull/1633
+.. _#1664: https://github.com/pytest-dev/pytest/pull/1664
+.. _#1668: https://github.com/pytest-dev/pytest/issues/1668
+.. _#1684: https://github.com/pytest-dev/pytest/pull/1684
+.. _#1723: https://github.com/pytest-dev/pytest/pull/1723
+.. _#1740: https://github.com/pytest-dev/pytest/issues/1740
+.. _#1749: https://github.com/pytest-dev/pytest/issues/1749
+.. _#1778: https://github.com/pytest-dev/pytest/pull/1778
+.. _#1795: https://github.com/pytest-dev/pytest/pull/1795
+.. _#1798: https://github.com/pytest-dev/pytest/pull/1798
+.. _#1809: https://github.com/pytest-dev/pytest/pull/1809
+.. _#372: https://github.com/pytest-dev/pytest/issues/372
+.. _#457: https://github.com/pytest-dev/pytest/issues/457
+.. _#460: https://github.com/pytest-dev/pytest/pull/460
+.. _#567: https://github.com/pytest-dev/pytest/pull/567
+.. _#607: https://github.com/pytest-dev/pytest/issues/607
+.. _#634: https://github.com/pytest-dev/pytest/issues/634
+.. _#717: https://github.com/pytest-dev/pytest/issues/717
+.. _#830: https://github.com/pytest-dev/pytest/issues/830
+.. _#925: https://github.com/pytest-dev/pytest/issues/925
+
+
+.. _@anntzer: https://github.com/anntzer
+.. _@bagerard: https://github.com/bagerard
+.. _@BeyondEvil: https://github.com/BeyondEvil
+.. _@blueyed: https://github.com/blueyed
+.. _@ceridwen: https://github.com/ceridwen
+.. _@cryporchild: https://github.com/cryporchild
+.. _@csaftoiu: https://github.com/csaftoiu
+.. _@d6e: https://github.com/d6e
+.. _@davehunt: https://github.com/davehunt
+.. _@DRMacIver: https://github.com/DRMacIver
+.. _@eolo999: https://github.com/eolo999
+.. _@fengxx: https://github.com/fengxx
+.. _@flub: https://github.com/flub
+.. _@gprasad84: https://github.com/gprasad84
+.. _@graingert: https://github.com/graingert
+.. _@hartym: https://github.com/hartym
+.. _@JonathonSonesen: https://github.com/JonathonSonesen
+.. _@kalekundert: https://github.com/kalekundert
+.. _@kvas-it: https://github.com/kvas-it
+.. _@marscher: https://github.com/marscher
+.. _@mikofski: https://github.com/mikofski
+.. _@milliams: https://github.com/milliams
+.. _@nikratio: https://github.com/nikratio
+.. _@novas0x2a: https://github.com/novas0x2a
+.. _@obestwalter: https://github.com/obestwalter
+.. _@okken: https://github.com/okken
+.. _@olegpidsadnyi: https://github.com/olegpidsadnyi
+.. _@omarkohl: https://github.com/omarkohl
+.. _@palaviv: https://github.com/palaviv
+.. _@RedBeardCode: https://github.com/RedBeardCode
+.. _@sallner: https://github.com/sallner
+.. _@sober7: https://github.com/sober7
+.. _@Stranger6667: https://github.com/Stranger6667
+.. _@suzaku: https://github.com/suzaku
+.. _@tareqalayan: https://github.com/tareqalayan
+.. _@taschini: https://github.com/taschini
+.. _@tramwaj29: https://github.com/tramwaj29
+.. _@txomon: https://github.com/txomon
+.. _@Vogtinator: https://github.com/Vogtinator
+.. _@matthiasha: https://github.com/matthiasha
+
+
 2.9.2
 =====
 
@@ -30,8 +683,8 @@
 
 .. _#510: https://github.com/pytest-dev/pytest/issues/510
 .. _#1506: https://github.com/pytest-dev/pytest/pull/1506
-.. _#1496: https://github.com/pytest-dev/pytest/issue/1496
-.. _#1524: https://github.com/pytest-dev/pytest/issue/1524
+.. _#1496: https://github.com/pytest-dev/pytest/issues/1496
+.. _#1524: https://github.com/pytest-dev/pytest/pull/1524
 
 .. _@prusse-martin: https://github.com/prusse-martin
 .. _@astraw38: https://github.com/astraw38
@@ -62,11 +715,13 @@
 
 * Fix (`#649`_): parametrized test nodes cannot be specified to run on the command line.
 
+* Fix (`#138`_): better reporting for python 3.3+ chained exceptions
 
 .. _#1437: https://github.com/pytest-dev/pytest/issues/1437
 .. _#469: https://github.com/pytest-dev/pytest/issues/469
 .. _#1431: https://github.com/pytest-dev/pytest/pull/1431
 .. _#649: https://github.com/pytest-dev/pytest/issues/649
+.. _#138: https://github.com/pytest-dev/pytest/issues/138
 
 .. _@asottile: https://github.com/asottile
 
@@ -156,7 +811,7 @@
   Thanks `@biern`_ for the PR.
 
 * Fix `traceback style docs`_ to describe all of the available options
-  (auto/long/short/line/native/no), with `auto` being the default since v2.6.
+  (auto/long/short/line/native/no), with ``auto`` being the default since v2.6.
   Thanks `@hackebrot`_ for the PR.
 
 * Fix (`#1422`_): junit record_xml_property doesn't allow multiple records
@@ -164,6 +819,7 @@
 
 .. _`traceback style docs`: https://pytest.org/latest/usage.html#modifying-python-traceback-printing
 
+.. _#1609: https://github.com/pytest-dev/pytest/issues/1609
 .. _#1422: https://github.com/pytest-dev/pytest/issues/1422
 .. _#1379: https://github.com/pytest-dev/pytest/issues/1379
 .. _#1366: https://github.com/pytest-dev/pytest/issues/1366
@@ -188,8 +844,8 @@
 .. _@RonnyPfannschmidt: https://github.com/RonnyPfannschmidt
 .. _@rabbbit: https://github.com/rabbbit
 .. _@hackebrot: https://github.com/hackebrot
-.. _@omarkohl: https://github.com/omarkohl
 .. _@pquentin: https://github.com/pquentin
+.. _@ioggstream: https://github.com/ioggstream
 
 2.8.7
 =====
@@ -773,7 +1429,7 @@
   dep).  Thanks Charles Cloud for analysing the issue.
 
 - fix conftest related fixture visibility issue: when running with a
-  CWD outside a test package pytest would get fixture discovery wrong.
+  CWD outside of a test package pytest would get fixture discovery wrong.
   Thanks to Wolfgang Schnerring for figuring out a reproducable example.
 
 - Introduce pytest_enter_pdb hook (needed e.g. by pytest_timeout to cancel the

CONTRIBUTING.rst

@@ -48,7 +48,7 @@ to fix the bug yet.
 Fix bugs
 --------
 
-Look through the GitHub issues for bugs.  Here is sample filter you can use:
+Look through the GitHub issues for bugs.  Here is a filter you can use:
 https://github.com/pytest-dev/pytest/labels/bug
 
 :ref:`Talk <contact>` to developers to find out how you can fix specific bugs.
@@ -60,8 +60,7 @@ Don't forget to check the issue trackers of your favourite plugins, too!
 Implement features
 ------------------
 
-Look through the GitHub issues for enhancements.  Here is sample filter you
-can use:
+Look through the GitHub issues for enhancements.  Here is a filter you can use:
 https://github.com/pytest-dev/pytest/labels/enhancement
 
 :ref:`Talk <contact>` to developers to find out how you can implement specific
@@ -70,17 +69,26 @@ features.
 Write documentation
 -------------------
 
-pytest could always use more documentation.  What exactly is needed?
+Pytest could always use more documentation.  What exactly is needed?
 
 * More complementary documentation.  Have you perhaps found something unclear?
 * Documentation translations.  We currently have only English.
 * Docstrings.  There can never be too many 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.
+You can also edit documentation files directly in the GitHub web interface,
+without using a local copy.  This can be convenient for small fixes.
 
+.. note::
+    Build the documentation locally with the following command:
+
+    .. code:: bash
+
+        $ tox -e docs
+
+    The built documentation should be available in the ``doc/en/_build/``.
+
+    Where 'en' refers to the documentation language.
 
 .. _submitplugin:
 
@@ -95,13 +103,14 @@ in repositories living under the ``pytest-dev`` organisations:
 - `pytest-dev on Bitbucket <https://bitbucket.org/pytest-dev>`_
 
 All pytest-dev Contributors team members have write access to all contained
-repositories.  pytest core and plugins are generally developed
+repositories.  Pytest core and plugins are generally developed
 using `pull requests`_ to respective repositories.
 
 The objectives of the ``pytest-dev`` organisation are:
 
 * Having a central location for popular pytest plugins
-* Sharing some of the maintenance responsibility (in case a maintainer no longer whishes to maintain a plugin)
+* Sharing some of the maintenance responsibility (in case a maintainer no
+  longer wishes to maintain a plugin)
 
 You can submit your plugin by subscribing to the `pytest-dev mail list
 <https://mail.python.org/mailman/listinfo/pytest-dev>`_ and writing a
@@ -121,33 +130,26 @@ the following:
 
 - an issue tracker for bug reports and enhancement requests.
 
+- a `changelog <http://keepachangelog.com/>`_
+
 If no contributor strongly objects and two agree, the repository can then be
 transferred to the ``pytest-dev`` organisation.
 
 Here's a rundown of how a repository transfer usually proceeds
 (using a repository named ``joedoe/pytest-xyz`` as example):
 
-* One of the ``pytest-dev`` administrators creates:
-
-  - ``pytest-xyz-admin`` team, with full administration rights to
-    ``pytest-dev/pytest-xyz``.
-  - ``pytest-xyz-developers`` team, with write access to
-    ``pytest-dev/pytest-xyz``.
-
-* ``joedoe`` is invited to the ``pytest-xyz-admin`` team;
-
-* After accepting the invitation, ``joedoe`` transfers the repository from its
-  original location to ``pytest-dev/pytest-xyz`` (A nice feature is that GitHub handles URL redirection from
-  the old to the new location automatically).
-
-* ``joedoe`` is free to add any other collaborators to the
-  ``pytest-xyz-admin`` or ``pytest-xyz-developers`` team as desired.
+* ``joedoe`` transfers repository ownership to ``pytest-dev`` administrator ``calvin``.
+* ``calvin`` creates ``pytest-xyz-admin`` and ``pytest-xyz-developers`` teams, inviting ``joedoe`` to both as **maintainer**.
+* ``calvin`` transfers repository to ``pytest-dev`` and configures team access:
+  
+  - ``pytest-xyz-admin`` **admin** access;
+  - ``pytest-xyz-developers`` **write** access;
 
 The ``pytest-dev/Contributors`` team has write access to all projects, and
 every project administrator is in it. We recommend that each plugin has at least three
 people who have the right to release to PyPI.
 
-Repository owners can be assured that no ``pytest-dev`` administrator will ever make
+Repository owners can rest assured that no ``pytest-dev`` administrator will ever make
 releases of your repository or take ownership in any way, except in rare cases
 where someone becomes unresponsive after months of contact attempts.
 As stated, the objective is to share maintenance and avoid "plugin-abandon".
@@ -159,15 +161,11 @@ As stated, the objective is to share maintenance and avoid "plugin-abandon".
 Preparing Pull Requests on GitHub
 ---------------------------------
 
-There's an excellent tutorial on how Pull Requests work in the
-`GitHub Help Center <https://help.github.com/articles/using-pull-requests/>`_
-
-
 .. note::
   What is a "pull request"?  It informs project's core developers about the
   changes you want to review and merge.  Pull requests are stored on
   `GitHub servers <https://github.com/pytest-dev/pytest/pulls>`_.
-  Once you send pull request, we can discuss it's potential modifications and
+  Once you send a pull request, we can discuss its potential modifications and
   even add more commits to it later on.
 
 There's an excellent tutorial on how Pull Requests work in the
@@ -211,35 +209,32 @@ but here is a simple overview:
    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 linting,py27,py35
+    $ tox -e linting,py27,py35
 
    This command will run tests via the "tox" tool against Python 2.7 and 3.5
-   and also perform "lint" 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.
+   and also perform "lint" coding-style checks.
 
 #. 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::
+   To run tests on Python 2.7 and pass options to pytest (e.g. enter pdb on
+   failure) to pytest you can do::
 
-    $ python runtox.py -e py27 -- --pdb
+    $ tox -e py27 -- --pdb
 
-   or to only run tests in a particular test module on py35::
+   Or to only run tests in a particular test module on Python 3.5::
 
-    $ python runtox.py -e py35 -- testing/test_config.py
+    $ tox -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
 
-   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.
+   Make sure you add a message to ``CHANGELOG.rst`` 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.
 
 #. Finally, submit a pull request through the GitHub website using this data::
 
@@ -248,6 +243,6 @@ but here is a simple overview:
 
     base-fork: pytest-dev/pytest
     base: master          # if it's a bugfix
-    base: feature         # if it's a feature
+    base: features        # if it's a feature
 
 

HOWTORELEASE.rst

@@ -3,90 +3,83 @@ How to release pytest
 
 Note: this assumes you have already registered on pypi.
 
-0. create the branch release-VERSION
-   use features as base for minor/major releases
-   and master as base for bugfix releases
+1. Bump version numbers in ``_pytest/__init__.py`` (``setup.py`` reads it).
 
-1. Bump version numbers in _pytest/__init__.py (setup.py reads it)
+2. Check and finalize ``CHANGELOG.rst``.
 
-2. Check and finalize CHANGELOG
+3. Write ``doc/en/announce/release-VERSION.txt`` and include
+   it in ``doc/en/announce/index.txt``. Run this command to list names of authors involved::
 
-3. Write doc/en/announce/release-VERSION.txt and include
-   it in doc/en/announce/index.txt::
+        git log $(git describe --abbrev=0 --tags)..HEAD --format='%aN' | sort -u
 
-        git log 2.8.2..HEAD --format='%aN' | sort -u # lists the names of authors involved
+4. Regenerate the docs examples using tox::
 
-4. Use devpi for uploading a release tarball to a staging area::
+      tox -e regen
+
+5. At this point, open a PR named ``release-X`` so others can help find regressions or provide suggestions.
+
+6. Use devpi for uploading a release tarball to a staging area::
 
      devpi use https://devpi.net/USER/dev
      devpi upload --formats sdist,bdist_wheel
 
-5. Run from multiple machines::
+7. Run from multiple machines::
 
      devpi use https://devpi.net/USER/dev
      devpi test pytest==VERSION
 
-6. Check that tests pass for relevant combinations with::
+   Alternatively, you can use `devpi-cloud-tester <https://github.com/nicoddemus/devpi-cloud-tester>`_ to test
+   the package on AppVeyor and Travis (follow instructions on the ``README``).
+
+8. Check that tests pass for relevant combinations with::
 
        devpi list pytest
 
    or look at failures with "devpi list -f pytest".
 
-7. Regenerate the docs examples using tox, and check for regressions::
+9. Feeling confident? Publish to pypi::
 
-      tox -e regen
-      git diff
+      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>`_.
 
-8. Build the docs, you need a virtualenv with py and sphinx
-   installed::
+10. Tag the release::
 
-      cd doc/en      
-      make html
+      git tag VERSION <hash>
+      git push origin VERSION
 
-   Commit any changes before tagging the release.
+    Make sure ``<hash>`` is **exactly** the git hash at the time the package was created.
 
-9. Tag the release::
+11. Send release announcement to mailing lists:
 
-      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
-
-    This requires ssh-login permission on pytest.org because it uses
-    rsync.
-    Note that the ``install`` target of ``doc/en/Makefile`` defines where the
-    rsync goes to, typically to the "latest" section of pytest.org.
-
-    If you are making a minor release (e.g. 5.4), you also need to manually
-    create a symlink for "latest"::
-
-       ssh pytest-dev@pytest.org
-       ln -s 5.4 latest
-
-    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
+    - pytest-dev@python.org
     - python-announce-list@python.org
+    - testing-in-python@lists.idyll.org (only for minor/major releases)
+
+    And announce the release on Twitter, making sure to add the hashtag ``#pytest``.
+
+12. **After the release**
+
+  a. **patch release (2.8.3)**:
+
+        1. Checkout ``master``.
+        2. Update version number in ``_pytest/__init__.py`` to ``"2.8.4.dev0"``.
+        3. Create a new section in ``CHANGELOG.rst`` titled ``2.8.4.dev0`` and add a few bullet points as placeholders for new entries.
+        4. Commit and push.
+
+  b. **minor release (2.9.0)**:
+
+        1. Merge ``features`` into ``master``.
+        2. Checkout ``master``.
+        3. Follow the same steps for a **patch release** above, using the next patch release: ``2.9.1.dev0``.
+        4. Commit ``master``.
+        5. Checkout ``features`` and merge with ``master`` (should be a fast-forward at this point).
+        6. Update version number in ``_pytest/__init__.py`` to the next minor release: ``"2.10.0.dev0"``.
+        7. Create a new section in ``CHANGELOG.rst`` titled ``2.10.0.dev0``, above ``2.9.1.dev0``, and add a few bullet points as placeholders for new entries.
+        8. Commit ``features``.
+        9. Push ``master`` and ``features``.
+
+  c. **major release (3.0.0)**: same steps as that of a **minor release**
 
 
-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``).
-
-14. merge the actual release into the master branch and do a pull request against it
-15. merge from master to features

ISSUES.txt

@@ -1,365 +0,0 @@
-
-
-recorder = monkeypatch.function(".......")
--------------------------------------------------------------
-tags: nice feature 
-
-Like monkeypatch.replace but sets a mock-like call recorder:
-
-    recorder = monkeypatch.function("os.path.abspath")
-    recorder.set_return("/hello")
-    os.path.abspath("hello")
-    call, = recorder.calls
-    assert call.args.path == "hello"
-    assert call.returned == "/hello"
-    ...
-
-Unlike mock, "args.path" acts on the parsed auto-spec'ed ``os.path.abspath``
-so it's independent from if the client side called "os.path.abspath(path=...)"
-or "os.path.abspath('positional')".
-
-
-refine parametrize API
--------------------------------------------------------------
-tags: critical feature 
-
-extend metafunc.parametrize to directly support indirection, example:
-
-    def setupdb(request, config):
-        # setup "resource" based on test request and the values passed 
-        # in to parametrize.  setupfunc is called for each such value.
-        # you may use request.addfinalizer() or request.cached_setup ...
-        return dynamic_setup_database(val)
-
-    @pytest.mark.parametrize("db", ["pg", "mysql"], setupfunc=setupdb)
-    def test_heavy_functional_test(db):
-        ...
-
-There would be no need to write or explain funcarg factories and
-their special __ syntax.
-
-The examples and improvements should also show how to put the parametrize
-decorator to a class, to a module or even to a directory.  For the directory
-part a conftest.py content like this::
-
-    pytestmark = [
-        @pytest.mark.parametrize_setup("db", ...),
-    ]
-
-probably makes sense in order to keep the declarative nature.   This mirrors
-the marker-mechanism with respect to a test module but puts it to a directory
-scale.
-
-When doing larger scoped parametrization it probably becomes necessary
-to allow parametrization to be ignored if the according parameter is not
-used (currently any parametrized argument that is not present in a function will cause a ValueError). Example:
-
-        @pytest.mark.parametrize("db", ..., mustmatch=False)
-
-means to not raise an error but simply ignore the parametrization
-if the signature of a decorated function does not match. XXX is it
-not sufficient to always allow non-matches?
-
-
-allow parametrized attributes on classes
--------------------------------------------------- 
-
-tags: wish 2.4
-
-example:
-
-    @pytest.mark.parametrize_attr("db", setupfunc, [1,2,3], scope="class")
-    @pytest.mark.parametrize_attr("tmp", setupfunc, scope="...")
-    class TestMe:
-        def test_hello(self):
-            access self.db ...
-
-this would run the test_hello() function three times with three
-different values for self.db. This could also work with unittest/nose
-style tests, i.e. it leverages existing test suites without needing
-to rewrite them. Together with the previously mentioned setup_test()
-maybe the setupfunc could be omitted?
-
-optimizations 
----------------------------------------------------------------
-tags: 2.4 core
-
-- look at ihook optimization such that all lookups for
-  hooks relating to the same fspath are cached.
-
-fix start/finish partial finailization problem
----------------------------------------------------------------
-tags: bug core
-
-if a configure/runtest_setup/sessionstart/... hook invocation partially
-fails the sessionfinishes is not called.  Each hook implementation
-should better be repsonsible for registering a cleanup/finalizer
-appropriately to avoid this issue.  Moreover/Alternatively, we could 
-record which implementations of a hook succeeded and only call their
-teardown.
-
-
-relax requirement to have tests/testing contain an __init__
-----------------------------------------------------------------
-tags: feature 
-bb: http://bitbucket.org/hpk42/py-trunk/issue/64
-
-A local test run of a "tests" directory may work
-but a remote one fail because the tests directory
-does not contain an "__init__.py". Either give
-an error or make it work without the __init__.py
-i.e. port the nose-logic of unloading a test module.
-
-customize test function collection
--------------------------------------------------------
-tags: feature 
-
-- introduce pytest.mark.nocollect for not considering a function for
-  test collection at all.  maybe also introduce a pytest.mark.test to
-  explicitly mark a function to become a tested one.  Lookup JUnit ways
-  of tagging tests.
-
-introduce pytest.mark.importorskip
--------------------------------------------------------
-tags: feature 
-
-in addition to the imperative pytest.importorskip also introduce
-a pytest.mark.importorskip so that the test count is more correct.
-
-
-introduce pytest.mark.platform
--------------------------------------------------------
-tags: feature 
-
-Introduce nice-to-spell platform-skipping, examples:
-
-    @pytest.mark.platform("python3")
-    @pytest.mark.platform("not python3")
-    @pytest.mark.platform("win32 and not python3")
-    @pytest.mark.platform("darwin")
-    @pytest.mark.platform("not (jython and win32)")
-    @pytest.mark.platform("not (jython and win32)", xfail=True)
-
-etc. Idea is to allow Python expressions which can operate
-on common spellings for operating systems and python
-interpreter versions.
-
-pytest.mark.xfail signature change
--------------------------------------------------------
-tags: feature 
-
-change to pytest.mark.xfail(reason, (optional)condition)
-to better implement the word meaning.  It also signals
-better that we always have some kind of an implementation
-reason that can be formualated.
-Compatibility? how to introduce a new name/keep compat?
-
-allow to non-intrusively apply skipfs/xfail/marks
----------------------------------------------------
-tags: feature 
-
-use case: mark a module or directory structures
-to be skipped on certain platforms (i.e. no import
-attempt will be made).
-
-consider introducing a hook/mechanism that allows to apply marks
-from conftests or plugins. (See extended parametrization)
-
-
-explicit referencing of conftest.py files
------------------------------------------
-tags: feature 
-
-allow to name conftest.py files (in sub directories) that should
-be imported early, as to include command line options.
-
-improve central pytest ini file
--------------------------------
-tags: feature 
-
-introduce more declarative configuration options:
-- (to-be-collected test directories)
-- required plugins
-- test func/class/file matching patterns
-- skip/xfail (non-intrusive)
-- pytest.ini and tox.ini and setup.cfg configuration in the same file
-
-new documentation
-----------------------------------
-tags: feature 
-
-- logo pytest
-- examples for unittest or functional testing
-- resource management for functional testing
-- patterns: page object
-
-have imported module mismatch honour relative paths
---------------------------------------------------------
-tags: bug 
-
-With 1.1.1 pytest fails at least on windows if an import
-is relative and compared against an absolute conftest.py
-path. Normalize.
-
-consider globals: pytest.ensuretemp and config
---------------------------------------------------------------
-tags: experimental-wish 
-
-consider deprecating pytest.ensuretemp and pytest.config
-to further reduce pytest globality.  Also consider
-having pytest.config and ensuretemp coming from
-a plugin rather than being there from the start.
-
-
-consider pytest_addsyspath hook
------------------------------------------
-tags: wish
-
-pytest could call a new pytest_addsyspath() in order to systematically
-allow manipulation of sys.path and to inhibit it via --no-addsyspath
-in order to more easily run against installed packages.
-
-Alternatively it could also be done via the config object
-and pytest_configure.
-
-
-
-deprecate global pytest.config usage
-----------------------------------------------------------------
-tags: feature 
-
-pytest.ensuretemp and pytest.config are probably the last
-objects containing global state.  Often using them is not
-necessary.  This is about trying to get rid of them, i.e.
-deprecating them and checking with PyPy's usages as well
-as others.
-
-remove deprecated bits in collect.py
--------------------------------------------------------------------
-tags: feature 
-
-In an effort to further simplify code, review and remove deprecated bits
-in collect.py.  Probably good:
-- inline consider_file/dir methods, no need to have them
-  subclass-overridable because of hooks
-
-implement fslayout decorator
----------------------------------
-tags: feature 
-
-Improve the way how tests can work with pre-made examples,
-keeping the layout close to the test function:
-
-@pytest.mark.fslayout("""
-    conftest.py:
-        #  empty
-    tests/
-        test_%(NAME)s:  # becomes test_run1.py
-            def test_function(self):
-                pass
-""")
-def test_run(pytester, fslayout):
-    p = fslayout.findone("test_*.py")
-    result = pytester.runpytest(p)
-    assert result.ret == 0
-    assert result.passed == 1
-
-Another idea is to allow to define a full scenario including the run
-in one content string::
-
-    runscenario("""
-        test_{TESTNAME}.py:
-            import pytest
-            @pytest.mark.xfail
-            def test_that_fails():
-                assert 0
-
-            @pytest.mark.skipif("True")
-            def test_hello():
-                pass
-
-        conftest.py:
-            import pytest
-            def pytest_runsetup_setup(item):
-                pytest.skip("abc")
-
-        runpytest -rsxX
-        *SKIP*{TESTNAME}*
-        *1 skipped* 
-    """)
-
-This could be run with at least three different ways to invoke pytest:
-through the shell, through "python -m pytest" and inlined. As inlined
-would be the fastest it could be run first (or "--fast" mode).
-
-
-Create isolate plugin
----------------------
-tags: feature
-
-The idea is that you can e.g. import modules in a test and afterwards
-sys.modules, sys.meta_path etc would be reverted.  It can go further
-then just importing however, e.g. current working directory, file
-descriptors, ...
-
-This would probably be done by marking::
-
-    @pytest.mark.isolate(importing=True, cwd=True, fds=False)
-    def test_foo():
-        ...
-
-With the possibility of doing this globally in an ini-file.
-
-
-fnmatch for test names
-----------------------
-tags: feature-wish
-
-various testsuites use suffixes instead of prefixes for test classes
-also it lends itself to bdd style test names::
-
-    class UserBehaviour:
-        def anonymous_should_not_have_inbox(user):
-            ...
-        def registred_should_have_inbox(user):
-            ..
-
-using the following in pytest.ini::
-
-    [pytest]
-    python_classes = Test *Behaviour *Test
-    python_functions = test *_should_*
-
-
-mechanism for running named parts of tests with different reporting behaviour
-------------------------------------------------------------------------------
-tags: feature-wish-incomplete
-
-a few use-cases come to mind:
-
-* fail assertions and record that without stopping a complete test
-
-  * this is in particular hepfull if a small bit of a test is known to fail/xfail::
-
-    def test_fun():
-        with pytest.section('fdcheck, marks=pytest.mark.xfail_if(...)):
-            breaks_on_windows()
-
-* divide functional/acceptance tests into sections
-* provide a different mechanism for generators, maybe something like::
-
-    def pytest_runtest_call(item)
-        if not generator:
-            ...
-        prepare_check = GeneratorCheckprepare()
-
-        gen = item.obj(**fixtures)
-        for check in gen
-            id, call = prepare_check(check)
-            # bubble should only prevent exception propagation after a failure
-            # the whole test should still fail
-            # there might be need for a lower level api and taking custom markers into account
-            with pytest.section(id, bubble=False):
-                call()
-
-

MANIFEST.in

@@ -4,31 +4,33 @@ include AUTHORS
 
 include README.rst
 include CONTRIBUTING.rst
+include HOWTORELEASE.rst
 
 include tox.ini
 include setup.py
 
-include .coveragerc
+recursive-include scripts *.py
+recursive-include scripts *.bat
 
-include plugin-test.sh
-include requirements-docs.txt
-include runtox.py
+include .coveragerc
 
 recursive-include bench *.py
 recursive-include extra *.py
 
 graft testing
 graft doc
+prune doc/en/_build
 
 exclude _pytest/impl
 
 graft _pytest/vendored_packages
 
 recursive-exclude * *.pyc *.pyo
+recursive-exclude testing/.hypothesis *
+recursive-exclude testing/freeze/~ *
+recursive-exclude testing/freeze/build *
+recursive-exclude testing/freeze/dist *
 
-exclude appveyor/install.ps1
 exclude appveyor.yml
-exclude appveyor
-
-exclude ISSUES.txt
-exclude HOWTORELEASE.rst
+exclude .travis.yml
+prune .github

README.rst

@@ -1,5 +1,5 @@
-.. image:: http://pytest.org/latest/_static/pytest1.png
-   :target: http://pytest.org
+.. image:: http://docs.pytest.org/en/latest/_static/pytest1.png
+   :target: http://docs.pytest.org
    :align: center
    :alt: pytest
 
@@ -17,67 +17,67 @@
     :target: https://ci.appveyor.com/project/pytestbot/pytest
 
 The ``pytest`` framework makes it easy to write small tests, yet
-scales to support complex functional testing for applications and libraries.    
+scales to support complex functional testing for applications and libraries.
 
 An example of a simple test:
 
 .. code-block:: python
 
     # content of test_sample.py
-    def func(x):
+    def inc(x):
         return x + 1
 
     def test_answer():
-        assert func(3) == 5
+        assert inc(3) == 5
 
 
 To execute it::
 
-    $ py.test
-    ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.5, py-1.4.31, pluggy-0.3.1    
+    $ pytest
+    ============================= test session starts =============================    
     collected 1 items
 
     test_sample.py F
 
-    ======= FAILURES ========
-    _______ test_answer ________
+    ================================== FAILURES ===================================
+    _________________________________ test_answer _________________________________
 
         def test_answer():
-    >       assert func(3) == 5
+    >       assert inc(3) == 5
     E       assert 4 == 5
-    E        +  where 4 = func(3)
+    E        +  where 4 = inc(3)
 
     test_sample.py:5: AssertionError
-    ======= 1 failed in 0.12 seconds ========
+    ========================== 1 failed in 0.04 seconds ===========================
+
+
+Due to ``pytest``'s detailed assertion introspection, only plain ``assert`` statements are used. See `getting-started <http://docs.pytest.org/en/latest/getting-started.html#our-first-test-run>`_ for more examples.
 
-Due to ``py.test``'s detailed assertion introspection, only plain ``assert`` statements are used. See `getting-started <http://pytest.org/latest/getting-started.html#our-first-test-run>`_ for more examples.
-        
 
 Features
 --------
 
-- Detailed info on failing `assert statements <http://pytest.org/latest/assert.html>`_ (no need to remember ``self.assert*`` names);
+- Detailed info on failing `assert statements <http://docs.pytest.org/en/latest/assert.html>`_ (no need to remember ``self.assert*`` names);
 
 - `Auto-discovery
-  <http://pytest.org/latest/goodpractices.html#python-test-discovery>`_
+  <http://docs.pytest.org/en/latest/goodpractices.html#python-test-discovery>`_
   of test modules and functions;
 
-- `Modular fixtures <http://pytest.org/latest/fixture.html>`_  for
+- `Modular fixtures <http://docs.pytest.org/en/latest/fixture.html>`_ for
   managing small or parametrized long-lived test resources;
 
-- Can run `unittest <http://pytest.org/latest/unittest.html>`_ (or trial),
-  `nose <http://pytest.org/latest/nose.html>`_ test suites out of the box;
+- Can run `unittest <http://docs.pytest.org/en/latest/unittest.html>`_ (or trial),
+  `nose <http://docs.pytest.org/en/latest/nose.html>`_ test suites out of the box;
 
-- Python2.6+, Python3.2+, PyPy-2.3, Jython-2.5 (untested);
+- Python2.6+, Python3.3+, PyPy-2.3, Jython-2.5 (untested);
 
-- Rich plugin architecture, with over 150+ `external plugins <http://pytest.org/latest/plugins.html#installing-external-plugins-searching>`_ and thriving community;
+- Rich plugin architecture, with over 150+ `external plugins <http://docs.pytest.org/en/latest/plugins.html#installing-external-plugins-searching>`_ and thriving community;
 
 
 Documentation
 -------------
 
-For full documentation, including installation, tutorials and PDF documents, please see http://pytest.org.
+For full documentation, including installation, tutorials and PDF documents, please see http://docs.pytest.org.
 
 
 Bugs/Requests
@@ -89,7 +89,7 @@ Please use the `GitHub issue tracker <https://github.com/pytest-dev/pytest/issue
 Changelog
 ---------
 
-Consult the `Changelog <http://pytest.org/latest/changelog.html>`_ page for fixes and enhancements of each version.
+Consult the `Changelog <http://docs.pytest.org/en/latest/changelog.html>`__ page for fixes and enhancements of each version.
 
 
 License

_pytest/__init__.py

@@ -1,2 +1,2 @@
 #
-__version__ = '2.9.2'
+__version__ = '3.0.5'

_pytest/_argcomplete.py

@@ -87,6 +87,7 @@ class FastFilesCompleter:
             completion.append(x[prefix_dir:])
         return completion
 
+
 if os.environ.get('_ARGCOMPLETE'):
     try:
         import argcomplete.completers

_pytest/_code/__init__.py

@@ -4,9 +4,6 @@ from .code import ExceptionInfo  # noqa
 from .code import Frame  # noqa
 from .code import Traceback  # noqa
 from .code import getrawcode  # noqa
-from .code import patch_builtins  # noqa
-from .code import unpatch_builtins  # noqa
 from .source import Source  # noqa
 from .source import compile_ as compile  # noqa
 from .source import getfslineno  # noqa
-

_pytest/_code/code.py

@@ -1,8 +1,9 @@
 import sys
 from inspect import CO_VARARGS, CO_VARKEYWORDS
+import re
+from weakref import ref
 
 import py
-
 builtin_repr = repr
 
 reprlib = py.builtin._tryimport('repr', 'reprlib')
@@ -12,6 +13,7 @@ if sys.version_info[0] >= 3:
 else:
     from ._py2traceback import format_exception_only
 
+
 class Code(object):
     """ wrapper around Python code objects """
     def __init__(self, rawcode):
@@ -28,6 +30,8 @@ class Code(object):
     def __eq__(self, other):
         return self.raw == other.raw
 
+    __hash__ = None
+
     def __ne__(self, other):
         return not self == other
 
@@ -35,12 +39,16 @@ class Code(object):
     def path(self):
         """ return a path object pointing to source code (note that it
         might not point to an actually existing file). """
-        p = py.path.local(self.raw.co_filename)
-        # maybe don't try this checking
-        if not p.check():
+        try:
+            p = py.path.local(self.raw.co_filename)
+            # maybe don't try this checking
+            if not p.check():
+                raise OSError("py.path check failed.")
+        except OSError:
             # XXX maybe try harder like the weird logic
             # in the standard lib [linecache.updatecache] does?
             p = self.raw.co_filename
+
         return p
 
     @property
@@ -139,7 +147,8 @@ class TracebackEntry(object):
     _repr_style = None
     exprinfo = None
 
-    def __init__(self, rawentry):
+    def __init__(self, rawentry, excinfo=None):
+        self._excinfo = excinfo
         self._rawentry = rawentry
         self.lineno = rawentry.tb_lineno - 1
 
@@ -174,18 +183,6 @@ class TracebackEntry(object):
         return self.frame.f_locals
     locals = property(getlocals, None, None, "locals of underlaying frame")
 
-    def reinterpret(self):
-        """Reinterpret the failing statement and returns a detailed information
-           about what operations are performed."""
-        from _pytest.assertion.reinterpret import reinterpret
-        if self.exprinfo is None:
-            source = py.builtin._totext(self.statement).strip()
-            x = reinterpret(source, self.frame, should_fail=True)
-            if not py.builtin._istext(x):
-                raise TypeError("interpret returned non-string %r" % (x,))
-            self.exprinfo = x
-        return self.exprinfo
-
     def getfirstlinesource(self):
         # on Jython this firstlineno can be -1 apparently
         return max(self.frame.code.firstlineno, 0)
@@ -220,16 +217,24 @@ class TracebackEntry(object):
         """ return True if the current frame has a var __tracebackhide__
             resolving to True
 
+            If __tracebackhide__ is a callable, it gets called with the
+            ExceptionInfo instance and can decide whether to hide the traceback.
+
             mostly for internal use
         """
         try:
-            return self.frame.f_locals['__tracebackhide__']
+            tbh = self.frame.f_locals['__tracebackhide__']
         except KeyError:
             try:
-                return self.frame.f_globals['__tracebackhide__']
+                tbh = self.frame.f_globals['__tracebackhide__']
             except KeyError:
                 return False
 
+        if py.builtin.callable(tbh):
+            return tbh(None if self._excinfo is None else self._excinfo())
+        else:
+            return tbh
+
     def __str__(self):
         try:
             fn = str(self.path)
@@ -253,12 +258,13 @@ class Traceback(list):
         access to Traceback entries.
     """
     Entry = TracebackEntry
-    def __init__(self, tb):
-        """ initialize from given python traceback object. """
+    def __init__(self, tb, excinfo=None):
+        """ initialize from given python traceback object and ExceptionInfo """
+        self._excinfo = excinfo
         if hasattr(tb, 'tb_next'):
             def f(cur):
                 while cur is not None:
-                    yield self.Entry(cur)
+                    yield self.Entry(cur, excinfo=excinfo)
                     cur = cur.tb_next
             list.__init__(self, f(tb))
         else:
@@ -282,7 +288,7 @@ class Traceback(list):
                  not codepath.relto(excludepath)) and
                 (lineno is None or x.lineno == lineno) and
                 (firstlineno is None or x.frame.code.firstlineno == firstlineno)):
-                return Traceback(x._rawentry)
+                return Traceback(x._rawentry, self._excinfo)
         return self
 
     def __getitem__(self, key):
@@ -301,7 +307,7 @@ class Traceback(list):
             by default this removes all the TracebackEntries which are hidden
             (see ishidden() above)
         """
-        return Traceback(filter(fn, self))
+        return Traceback(filter(fn, self), self._excinfo)
 
     def getcrashentry(self):
         """ return last non-hidden traceback entry that lead
@@ -337,6 +343,7 @@ class Traceback(list):
             l.append(entry.frame.f_locals)
         return None
 
+
 co_equal = compile('__recursioncache_locals_1 == __recursioncache_locals_2',
                    '?', 'eval')
 
@@ -352,7 +359,7 @@ class ExceptionInfo(object):
             if exprinfo is None and isinstance(tup[1], AssertionError):
                 exprinfo = getattr(tup[1], 'msg', None)
                 if exprinfo is None:
-                    exprinfo = str(tup[1])
+                    exprinfo = py._builtin._totext(tup[1])
                 if exprinfo and exprinfo.startswith('assert '):
                     self._striptext = 'AssertionError: '
         self._excinfo = tup
@@ -365,7 +372,7 @@ class ExceptionInfo(object):
         #: the exception type name
         self.typename = self.type.__name__
         #: the exception traceback (_pytest._code.Traceback instance)
-        self.traceback = _pytest._code.Traceback(self.tb)
+        self.traceback = _pytest._code.Traceback(self.tb, excinfo=ref(self))
 
     def __repr__(self):
         return "<ExceptionInfo %s tblen=%d>" % (self.typename, len(self.traceback))
@@ -427,6 +434,19 @@ class ExceptionInfo(object):
         loc = ReprFileLocation(entry.path, entry.lineno + 1, self.exconly())
         return unicode(loc)
 
+    def match(self, regexp):
+        """
+        Match the regular expression 'regexp' on the string representation of
+        the exception. If it matches then True is returned (so that it is
+        possible to write 'assert excinfo.match()'). If it doesn't match an
+        AssertionError is raised.
+        """
+        __tracebackhide__ = True
+        if not re.search(regexp, str(self.value)):
+            assert 0, "Pattern '{0!s}' not found in '{1!s}'".format(
+                regexp, self.value)
+        return True
+
 
 class FormattedExcinfo(object):
     """ presenting information about failing Functions and Generators. """
@@ -593,12 +613,43 @@ class FormattedExcinfo(object):
                 break
         return ReprTraceback(entries, extraline, style=self.style)
 
-    def repr_excinfo(self, excinfo):
-        reprtraceback = self.repr_traceback(excinfo)
-        reprcrash = excinfo._getreprcrash()
-        return ReprExceptionInfo(reprtraceback, reprcrash)
 
-class TerminalRepr:
+    def repr_excinfo(self, excinfo):
+        if sys.version_info[0] < 3:
+            reprtraceback = self.repr_traceback(excinfo)
+            reprcrash = excinfo._getreprcrash()
+
+            return ReprExceptionInfo(reprtraceback, reprcrash)
+        else:
+            repr_chain = []
+            e = excinfo.value
+            descr = None
+            while e is not None:
+                if excinfo:
+                    reprtraceback = self.repr_traceback(excinfo)
+                    reprcrash = excinfo._getreprcrash()
+                else:
+                    # fallback to native repr if the exception doesn't have a traceback:
+                    # ExceptionInfo objects require a full traceback to work
+                    reprtraceback = ReprTracebackNative(py.std.traceback.format_exception(type(e), e, None))
+                    reprcrash = None
+
+                repr_chain += [(reprtraceback, reprcrash, descr)]
+                if e.__cause__ is not None:
+                    e = e.__cause__
+                    excinfo = ExceptionInfo((type(e), e, e.__traceback__)) if e.__traceback__ else None
+                    descr = 'The above exception was the direct cause of the following exception:'
+                elif e.__context__ is not None:
+                    e = e.__context__
+                    excinfo = ExceptionInfo((type(e), e, e.__traceback__)) if e.__traceback__ else None
+                    descr = 'During handling of the above exception, another exception occurred:'
+                else:
+                    e = None
+            repr_chain.reverse()
+            return ExceptionChainRepr(repr_chain)
+
+
+class TerminalRepr(object):
     def __str__(self):
         s = self.__unicode__()
         if sys.version_info[0] < 3:
@@ -617,21 +668,47 @@ class TerminalRepr:
         return "<%s instance at %0x>" %(self.__class__, id(self))
 
 
-class ReprExceptionInfo(TerminalRepr):
-    def __init__(self, reprtraceback, reprcrash):
-        self.reprtraceback = reprtraceback
-        self.reprcrash = reprcrash
+class ExceptionRepr(TerminalRepr):
+    def __init__(self):
         self.sections = []
 
     def addsection(self, name, content, sep="-"):
         self.sections.append((name, content, sep))
 
     def toterminal(self, tw):
-        self.reprtraceback.toterminal(tw)
         for name, content, sep in self.sections:
             tw.sep(sep, name)
             tw.line(content)
 
+
+class ExceptionChainRepr(ExceptionRepr):
+    def __init__(self, chain):
+        super(ExceptionChainRepr, self).__init__()
+        self.chain = chain
+        # reprcrash and reprtraceback of the outermost (the newest) exception
+        # in the chain
+        self.reprtraceback = chain[-1][0]
+        self.reprcrash = chain[-1][1]
+
+    def toterminal(self, tw):
+        for element in self.chain:
+            element[0].toterminal(tw)
+            if element[2] is not None:
+                tw.line("")
+                tw.line(element[2], yellow=True)
+        super(ExceptionChainRepr, self).toterminal(tw)
+
+
+class ReprExceptionInfo(ExceptionRepr):
+    def __init__(self, reprtraceback, reprcrash):
+        super(ReprExceptionInfo, self).__init__()
+        self.reprtraceback = reprtraceback
+        self.reprcrash = reprcrash
+
+    def toterminal(self, tw):
+        self.reprtraceback.toterminal(tw)
+        super(ReprExceptionInfo, self).toterminal(tw)
+
 class ReprTraceback(TerminalRepr):
     entrysep = "_ "
 
@@ -720,7 +797,8 @@ class ReprFileLocation(TerminalRepr):
         i = msg.find("\n")
         if i != -1:
             msg = msg[:i]
-        tw.line("%s:%s: %s" %(self.path, self.lineno, msg))
+        tw.write(self.path, bold=True, red=True)
+        tw.line(":%s: %s" % (self.lineno, msg))
 
 class ReprLocals(TerminalRepr):
     def __init__(self, lines):
@@ -753,29 +831,6 @@ class ReprFuncArgs(TerminalRepr):
             tw.line("")
 
 
-
-oldbuiltins = {}
-
-def patch_builtins(assertion=True, compile=True):
-    """ put compile and AssertionError builtins to Python's builtins. """
-    if assertion:
-        from _pytest.assertion import reinterpret
-        l = oldbuiltins.setdefault('AssertionError', [])
-        l.append(py.builtin.builtins.AssertionError)
-        py.builtin.builtins.AssertionError = reinterpret.AssertionError
-    if compile:
-        import _pytest._code
-        l = oldbuiltins.setdefault('compile', [])
-        l.append(py.builtin.builtins.compile)
-        py.builtin.builtins.compile = _pytest._code.compile
-
-def unpatch_builtins(assertion=True, compile=True):
-    """ remove compile and AssertionError builtins from Python builtins. """
-    if assertion:
-        py.builtin.builtins.AssertionError = oldbuiltins['AssertionError'].pop()
-    if compile:
-        py.builtin.builtins.compile = oldbuiltins['compile'].pop()
-
 def getrawcode(obj, trycall=True):
     """ return code object for given function. """
     try:
@@ -792,6 +847,7 @@ def getrawcode(obj, trycall=True):
                     return x
         return obj
 
+
 if sys.version_info[:2] >= (3, 5):  # RecursionError introduced in 3.5
     def is_recursion_error(excinfo):
         return excinfo.errisinstance(RecursionError)  # noqa

_pytest/_code/source.py

@@ -4,7 +4,6 @@ from bisect import bisect_right
 import sys
 import inspect, tokenize
 import py
-from types import ModuleType
 cpy_compile = compile
 
 try:
@@ -52,22 +51,21 @@ class Source(object):
                 return str(self) == other
             return False
 
+    __hash__ = None
+
     def __getitem__(self, key):
         if isinstance(key, int):
             return self.lines[key]
         else:
             if key.step not in (None, 1):
                 raise IndexError("cannot slice a Source with a step")
-            return self.__getslice__(key.start, key.stop)
+            newsource = Source()
+            newsource.lines = self.lines[key.start:key.stop]
+            return newsource
 
     def __len__(self):
         return len(self.lines)
 
-    def __getslice__(self, start, end):
-        newsource = Source()
-        newsource.lines = self.lines[start:end]
-        return newsource
-
     def strip(self):
         """ return new source object with trailing
             and leading blank lines removed.
@@ -193,14 +191,6 @@ class Source(object):
             if flag & _AST_FLAG:
                 return co
             lines = [(x + "\n") for x in self.lines]
-            if sys.version_info[0] >= 3:
-                # XXX py3's inspect.getsourcefile() checks for a module
-                # and a pep302 __loader__ ... we don't have a module
-                # at code compile-time so we need to fake it here
-                m = ModuleType("_pycodecompile_pseudo_module")
-                py.std.inspect.modulesbyfile[filename] = None
-                py.std.sys.modules[None] = m
-                m.__loader__ = 1
             py.std.linecache.cache[filename] = (1, None, lines, filename)
             return co
 
@@ -266,6 +256,7 @@ def findsource(obj):
     source.lines = [line.rstrip() for line in sourcelines]
     return source, lineno
 
+
 def getsource(obj, **kwargs):
     import _pytest._code
     obj = _pytest._code.getrawcode(obj)
@@ -276,6 +267,7 @@ def getsource(obj, **kwargs):
     assert isinstance(strsrc, str)
     return Source(strsrc, **kwargs)
 
+
 def deindent(lines, offset=None):
     if offset is None:
         for line in lines:
@@ -289,6 +281,7 @@ def deindent(lines, offset=None):
     if offset == 0:
         return list(lines)
     newlines = []
+
     def readline_generator(lines):
         for line in lines:
             yield line + '\n'

_pytest/assertion/__init__.py

@@ -4,8 +4,9 @@ support for presenting detailed information in failing assertions.
 import py
 import os
 import sys
-from _pytest.monkeypatch import monkeypatch
+
 from _pytest.assertion import util
+from _pytest.assertion import rewrite
 
 
 def pytest_addoption(parser):
@@ -13,25 +14,49 @@ def pytest_addoption(parser):
     group.addoption('--assert',
                     action="store",
                     dest="assertmode",
-                    choices=("rewrite", "reinterp", "plain",),
+                    choices=("rewrite", "plain",),
                     default="rewrite",
                     metavar="MODE",
-                    help="""control assertion debugging tools.  'plain'
-                            performs no assertion debugging.  'reinterp'
-                            reinterprets assert statements after they failed
-                            to provide assertion expression information.
-                            'rewrite' (the default) rewrites assert
-                            statements in test modules on import to
-                            provide assert expression information. """)
-    group.addoption('--no-assert',
-                    action="store_true",
-                    default=False,
-                    dest="noassert",
-                    help="DEPRECATED equivalent to --assert=plain")
-    group.addoption('--nomagic', '--no-magic',
-                    action="store_true",
-                    default=False,
-                    help="DEPRECATED equivalent to --assert=plain")
+                    help="""Control assertion debugging tools.  'plain'
+                            performs no assertion debugging.  'rewrite'
+                            (the default) rewrites assert statements in
+                            test modules on import to provide assert
+                            expression information.""")
+
+
+def pytest_namespace():
+    return {'register_assert_rewrite': register_assert_rewrite}
+
+
+def register_assert_rewrite(*names):
+    """Register one or more module names to be rewritten on import.
+
+    This function will make sure that this module or all modules inside
+    the package will get their assert statements rewritten.
+    Thus you should make sure to call this before the module is
+    actually imported, usually in your __init__.py if you are a plugin
+    using a package.
+
+    :raise TypeError: if the given module names are not strings.
+    """
+    for name in names:
+        if not isinstance(name, str):
+            msg = 'expected module names as *args, got {0} instead'
+            raise TypeError(msg.format(repr(names)))
+    for hook in sys.meta_path:
+        if isinstance(hook, rewrite.AssertionRewritingHook):
+            importhook = hook
+            break
+    else:
+        importhook = DummyRewriteHook()
+    importhook.mark_rewrite(*names)
+
+
+class DummyRewriteHook(object):
+    """A no-op import hook for when rewriting is disabled."""
+
+    def mark_rewrite(self, *names):
+        pass
 
 
 class AssertionState:
@@ -40,51 +65,39 @@ class AssertionState:
     def __init__(self, config, mode):
         self.mode = mode
         self.trace = config.trace.root.get("assertion")
+        self.hook = None
 
 
-def pytest_configure(config):
-    mode = config.getvalue("assertmode")
-    if config.getvalue("noassert") or config.getvalue("nomagic"):
-        mode = "plain"
-    if mode == "rewrite":
-        try:
-            import ast  # noqa
-        except ImportError:
-            mode = "reinterp"
-        else:
-            # Both Jython and CPython 2.6.0 have AST bugs that make the
-            # assertion rewriting hook malfunction.
-            if (sys.platform.startswith('java') or
-                    sys.version_info[:3] == (2, 6, 0)):
-                mode = "reinterp"
-    if mode != "plain":
-        _load_modules(mode)
-        m = monkeypatch()
-        config._cleanup.append(m.undo)
-        m.setattr(py.builtin.builtins, 'AssertionError',
-                  reinterpret.AssertionError)  # noqa
-    hook = None
-    if mode == "rewrite":
-        hook = rewrite.AssertionRewritingHook()  # noqa
-        sys.meta_path.insert(0, hook)
-    warn_about_missing_assertion(mode)
-    config._assertstate = AssertionState(config, mode)
-    config._assertstate.hook = hook
-    config._assertstate.trace("configured with mode set to %r" % (mode,))
+def install_importhook(config):
+    """Try to install the rewrite hook, raise SystemError if it fails."""
+    # Both Jython and CPython 2.6.0 have AST bugs that make the
+    # assertion rewriting hook malfunction.
+    if (sys.platform.startswith('java') or
+            sys.version_info[:3] == (2, 6, 0)):
+        raise SystemError('rewrite not supported')
+
+    config._assertstate = AssertionState(config, 'rewrite')
+    config._assertstate.hook = hook = rewrite.AssertionRewritingHook(config)
+    sys.meta_path.insert(0, hook)
+    config._assertstate.trace('installed rewrite import 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)
+    return hook
 
 
 def pytest_collection(session):
     # this hook is only called when test modules are collected
     # so for example not in the master process of pytest-xdist
     # (which does not collect test modules)
-    hook = session.config._assertstate.hook
-    if hook is not None:
-        hook.set_session(session)
+    assertstate = getattr(session.config, '_assertstate', None)
+    if assertstate:
+        if assertstate.hook is not None:
+            assertstate.hook.set_session(session)
 
 
 def _running_on_ci():
@@ -141,35 +154,10 @@ def pytest_runtest_teardown(item):
 
 
 def pytest_sessionfinish(session):
-    hook = session.config._assertstate.hook
-    if hook is not None:
-        hook.session = None
-
-
-def _load_modules(mode):
-    """Lazily import assertion related code."""
-    global rewrite, reinterpret
-    from _pytest.assertion import reinterpret  # noqa
-    if mode == "rewrite":
-        from _pytest.assertion import rewrite  # noqa
-
-
-def warn_about_missing_assertion(mode):
-    try:
-        assert False
-    except AssertionError:
-        pass
-    else:
-        if mode == "rewrite":
-            specifically = ("assertions which are not in test modules "
-                            "will be ignored")
-        else:
-            specifically = "failing tests may report as passing"
-
-        sys.stderr.write("WARNING: " + specifically +
-                         " because assert statements are not executed "
-                         "by the underlying Python interpreter "
-                         "(are you using python -O?)\n")
+    assertstate = getattr(session.config, '_assertstate', None)
+    if assertstate:
+        if assertstate.hook is not None:
+            assertstate.hook.set_session(None)
 
 
 # Expose this plugin's implementation for the pytest_assertrepr_compare hook

_pytest/assertion/reinterpret.py

@@ -1,407 +0,0 @@
-"""
-Find intermediate evalutation results in assert statements through builtin AST.
-"""
-import ast
-import sys
-
-import _pytest._code
-import py
-from _pytest.assertion import util
-u = py.builtin._totext
-
-
-class AssertionError(util.BuiltinAssertionError):
-    def __init__(self, *args):
-        util.BuiltinAssertionError.__init__(self, *args)
-        if args:
-            # on Python2.6 we get len(args)==2 for: assert 0, (x,y)
-            # on Python2.7 and above we always get len(args) == 1
-            # with args[0] being the (x,y) tuple.
-            if len(args) > 1:
-                toprint = args
-            else:
-                toprint = args[0]
-            try:
-                self.msg = u(toprint)
-            except Exception:
-                self.msg = u(
-                    "<[broken __repr__] %s at %0xd>"
-                    % (toprint.__class__, id(toprint)))
-        else:
-            f = _pytest._code.Frame(sys._getframe(1))
-            try:
-                source = f.code.fullsource
-                if source is not None:
-                    try:
-                        source = source.getstatement(f.lineno, assertion=True)
-                    except IndexError:
-                        source = None
-                    else:
-                        source = str(source.deindent()).strip()
-            except py.error.ENOENT:
-                source = None
-                # this can also occur during reinterpretation, when the
-                # co_filename is set to "<run>".
-            if source:
-                self.msg = reinterpret(source, f, should_fail=True)
-            else:
-                self.msg = "<could not determine information>"
-            if not self.args:
-                self.args = (self.msg,)
-
-if sys.version_info > (3, 0):
-    AssertionError.__module__ = "builtins"
-
-if sys.platform.startswith("java"):
-    # See http://bugs.jython.org/issue1497
-    _exprs = ("BoolOp", "BinOp", "UnaryOp", "Lambda", "IfExp", "Dict",
-              "ListComp", "GeneratorExp", "Yield", "Compare", "Call",
-              "Repr", "Num", "Str", "Attribute", "Subscript", "Name",
-              "List", "Tuple")
-    _stmts = ("FunctionDef", "ClassDef", "Return", "Delete", "Assign",
-              "AugAssign", "Print", "For", "While", "If", "With", "Raise",
-              "TryExcept", "TryFinally", "Assert", "Import", "ImportFrom",
-              "Exec", "Global", "Expr", "Pass", "Break", "Continue")
-    _expr_nodes = set(getattr(ast, name) for name in _exprs)
-    _stmt_nodes = set(getattr(ast, name) for name in _stmts)
-    def _is_ast_expr(node):
-        return node.__class__ in _expr_nodes
-    def _is_ast_stmt(node):
-        return node.__class__ in _stmt_nodes
-else:
-    def _is_ast_expr(node):
-        return isinstance(node, ast.expr)
-    def _is_ast_stmt(node):
-        return isinstance(node, ast.stmt)
-
-try:
-    _Starred = ast.Starred
-except AttributeError:
-    # Python 2. Define a dummy class so isinstance() will always be False.
-    class _Starred(object): pass
-
-
-class Failure(Exception):
-    """Error found while interpreting AST."""
-
-    def __init__(self, explanation=""):
-        self.cause = sys.exc_info()
-        self.explanation = explanation
-
-
-def reinterpret(source, frame, should_fail=False):
-    mod = ast.parse(source)
-    visitor = DebugInterpreter(frame)
-    try:
-        visitor.visit(mod)
-    except Failure:
-        failure = sys.exc_info()[1]
-        return getfailure(failure)
-    if should_fail:
-        return ("(assertion failed, but when it was re-run for "
-                "printing intermediate values, it did not fail.  Suggestions: "
-                "compute assert expression before the assert or use --assert=plain)")
-
-def run(offending_line, frame=None):
-    if frame is None:
-        frame = _pytest._code.Frame(sys._getframe(1))
-    return reinterpret(offending_line, frame)
-
-def getfailure(e):
-    explanation = util.format_explanation(e.explanation)
-    value = e.cause[1]
-    if str(value):
-        lines = explanation.split('\n')
-        lines[0] += "  << %s" % (value,)
-        explanation = '\n'.join(lines)
-    text = "%s: %s" % (e.cause[0].__name__, explanation)
-    if text.startswith('AssertionError: assert '):
-        text = text[16:]
-    return text
-
-operator_map = {
-    ast.BitOr : "|",
-    ast.BitXor : "^",
-    ast.BitAnd : "&",
-    ast.LShift : "<<",
-    ast.RShift : ">>",
-    ast.Add : "+",
-    ast.Sub : "-",
-    ast.Mult : "*",
-    ast.Div : "/",
-    ast.FloorDiv : "//",
-    ast.Mod : "%",
-    ast.Eq : "==",
-    ast.NotEq : "!=",
-    ast.Lt : "<",
-    ast.LtE : "<=",
-    ast.Gt : ">",
-    ast.GtE : ">=",
-    ast.Pow : "**",
-    ast.Is : "is",
-    ast.IsNot : "is not",
-    ast.In : "in",
-    ast.NotIn : "not in"
-}
-
-unary_map = {
-    ast.Not : "not %s",
-    ast.Invert : "~%s",
-    ast.USub : "-%s",
-    ast.UAdd : "+%s"
-}
-
-
-class DebugInterpreter(ast.NodeVisitor):
-    """Interpret AST nodes to gleam useful debugging information. """
-
-    def __init__(self, frame):
-        self.frame = frame
-
-    def generic_visit(self, node):
-        # Fallback when we don't have a special implementation.
-        if _is_ast_expr(node):
-            mod = ast.Expression(node)
-            co = self._compile(mod)
-            try:
-                result = self.frame.eval(co)
-            except Exception:
-                raise Failure()
-            explanation = self.frame.repr(result)
-            return explanation, result
-        elif _is_ast_stmt(node):
-            mod = ast.Module([node])
-            co = self._compile(mod, "exec")
-            try:
-                self.frame.exec_(co)
-            except Exception:
-                raise Failure()
-            return None, None
-        else:
-            raise AssertionError("can't handle %s" %(node,))
-
-    def _compile(self, source, mode="eval"):
-        return compile(source, "<assertion interpretation>", mode)
-
-    def visit_Expr(self, expr):
-        return self.visit(expr.value)
-
-    def visit_Module(self, mod):
-        for stmt in mod.body:
-            self.visit(stmt)
-
-    def visit_Name(self, name):
-        explanation, result = self.generic_visit(name)
-        # See if the name is local.
-        source = "%r in locals() is not globals()" % (name.id,)
-        co = self._compile(source)
-        try:
-            local = self.frame.eval(co)
-        except Exception:
-            # have to assume it isn't
-            local = None
-        if local is None or not self.frame.is_true(local):
-            return name.id, result
-        return explanation, result
-
-    def visit_Compare(self, comp):
-        left = comp.left
-        left_explanation, left_result = self.visit(left)
-        for op, next_op in zip(comp.ops, comp.comparators):
-            next_explanation, next_result = self.visit(next_op)
-            op_symbol = operator_map[op.__class__]
-            explanation = "%s %s %s" % (left_explanation, op_symbol,
-                                        next_explanation)
-            source = "__exprinfo_left %s __exprinfo_right" % (op_symbol,)
-            co = self._compile(source)
-            try:
-                result = self.frame.eval(co, __exprinfo_left=left_result,
-                                         __exprinfo_right=next_result)
-            except Exception:
-                raise Failure(explanation)
-            try:
-                if not self.frame.is_true(result):
-                    break
-            except KeyboardInterrupt:
-                raise
-            except:
-                break
-            left_explanation, left_result = next_explanation, next_result
-
-        if util._reprcompare is not None:
-            res = util._reprcompare(op_symbol, left_result, next_result)
-            if res:
-                explanation = res
-        return explanation, result
-
-    def visit_BoolOp(self, boolop):
-        is_or = isinstance(boolop.op, ast.Or)
-        explanations = []
-        for operand in boolop.values:
-            explanation, result = self.visit(operand)
-            explanations.append(explanation)
-            if result == is_or:
-                break
-        name = is_or and " or " or " and "
-        explanation = "(" + name.join(explanations) + ")"
-        return explanation, result
-
-    def visit_UnaryOp(self, unary):
-        pattern = unary_map[unary.op.__class__]
-        operand_explanation, operand_result = self.visit(unary.operand)
-        explanation = pattern % (operand_explanation,)
-        co = self._compile(pattern % ("__exprinfo_expr",))
-        try:
-            result = self.frame.eval(co, __exprinfo_expr=operand_result)
-        except Exception:
-            raise Failure(explanation)
-        return explanation, result
-
-    def visit_BinOp(self, binop):
-        left_explanation, left_result = self.visit(binop.left)
-        right_explanation, right_result = self.visit(binop.right)
-        symbol = operator_map[binop.op.__class__]
-        explanation = "(%s %s %s)" % (left_explanation, symbol,
-                                      right_explanation)
-        source = "__exprinfo_left %s __exprinfo_right" % (symbol,)
-        co = self._compile(source)
-        try:
-            result = self.frame.eval(co, __exprinfo_left=left_result,
-                                     __exprinfo_right=right_result)
-        except Exception:
-            raise Failure(explanation)
-        return explanation, result
-
-    def visit_Call(self, call):
-        func_explanation, func = self.visit(call.func)
-        arg_explanations = []
-        ns = {"__exprinfo_func" : func}
-        arguments = []
-        for arg in call.args:
-            arg_explanation, arg_result = self.visit(arg)
-            if isinstance(arg, _Starred):
-                arg_name = "__exprinfo_star"
-                ns[arg_name] = arg_result
-                arguments.append("*%s" % (arg_name,))
-                arg_explanations.append("*%s" % (arg_explanation,))
-            else:
-                arg_name = "__exprinfo_%s" % (len(ns),)
-                ns[arg_name] = arg_result
-                arguments.append(arg_name)
-                arg_explanations.append(arg_explanation)
-        for keyword in call.keywords:
-            arg_explanation, arg_result = self.visit(keyword.value)
-            if keyword.arg:
-                arg_name = "__exprinfo_%s" % (len(ns),)
-                keyword_source = "%s=%%s" % (keyword.arg)
-                arguments.append(keyword_source % (arg_name,))
-                arg_explanations.append(keyword_source % (arg_explanation,))
-            else:
-                arg_name = "__exprinfo_kwds"
-                arguments.append("**%s" % (arg_name,))
-                arg_explanations.append("**%s" % (arg_explanation,))
-
-            ns[arg_name] = arg_result
-
-        if getattr(call, 'starargs', None):
-            arg_explanation, arg_result = self.visit(call.starargs)
-            arg_name = "__exprinfo_star"
-            ns[arg_name] = arg_result
-            arguments.append("*%s" % (arg_name,))
-            arg_explanations.append("*%s" % (arg_explanation,))
-
-        if getattr(call, 'kwargs', None):
-            arg_explanation, arg_result = self.visit(call.kwargs)
-            arg_name = "__exprinfo_kwds"
-            ns[arg_name] = arg_result
-            arguments.append("**%s" % (arg_name,))
-            arg_explanations.append("**%s" % (arg_explanation,))
-        args_explained = ", ".join(arg_explanations)
-        explanation = "%s(%s)" % (func_explanation, args_explained)
-        args = ", ".join(arguments)
-        source = "__exprinfo_func(%s)" % (args,)
-        co = self._compile(source)
-        try:
-            result = self.frame.eval(co, **ns)
-        except Exception:
-            raise Failure(explanation)
-        pattern = "%s\n{%s = %s\n}"
-        rep = self.frame.repr(result)
-        explanation = pattern % (rep, rep, explanation)
-        return explanation, result
-
-    def _is_builtin_name(self, name):
-        pattern = "%r not in globals() and %r not in locals()"
-        source = pattern % (name.id, name.id)
-        co = self._compile(source)
-        try:
-            return self.frame.eval(co)
-        except Exception:
-            return False
-
-    def visit_Attribute(self, attr):
-        if not isinstance(attr.ctx, ast.Load):
-            return self.generic_visit(attr)
-        source_explanation, source_result = self.visit(attr.value)
-        explanation = "%s.%s" % (source_explanation, attr.attr)
-        source = "__exprinfo_expr.%s" % (attr.attr,)
-        co = self._compile(source)
-        try:
-            try:
-                result = self.frame.eval(co, __exprinfo_expr=source_result)
-            except AttributeError:
-                # Maybe the attribute name needs to be mangled?
-                if not attr.attr.startswith("__") or attr.attr.endswith("__"):
-                    raise
-                source = "getattr(__exprinfo_expr.__class__, '__name__', '')"
-                co = self._compile(source)
-                class_name = self.frame.eval(co, __exprinfo_expr=source_result)
-                mangled_attr = "_" + class_name +  attr.attr
-                source = "__exprinfo_expr.%s" % (mangled_attr,)
-                co = self._compile(source)
-                result = self.frame.eval(co, __exprinfo_expr=source_result)
-        except Exception:
-            raise Failure(explanation)
-        explanation = "%s\n{%s = %s.%s\n}" % (self.frame.repr(result),
-                                              self.frame.repr(result),
-                                              source_explanation, attr.attr)
-        # Check if the attr is from an instance.
-        source = "%r in getattr(__exprinfo_expr, '__dict__', {})"
-        source = source % (attr.attr,)
-        co = self._compile(source)
-        try:
-            from_instance = self.frame.eval(co, __exprinfo_expr=source_result)
-        except Exception:
-            from_instance = None
-        if from_instance is None or self.frame.is_true(from_instance):
-            rep = self.frame.repr(result)
-            pattern = "%s\n{%s = %s\n}"
-            explanation = pattern % (rep, rep, explanation)
-        return explanation, result
-
-    def visit_Assert(self, assrt):
-        test_explanation, test_result = self.visit(assrt.test)
-        explanation = "assert %s" % (test_explanation,)
-        if not self.frame.is_true(test_result):
-            try:
-                raise util.BuiltinAssertionError
-            except Exception:
-                raise Failure(explanation)
-        return explanation, test_result
-
-    def visit_Assign(self, assign):
-        value_explanation, value_result = self.visit(assign.value)
-        explanation = "... = %s" % (value_explanation,)
-        name = ast.Name("__exprinfo_expr", ast.Load(),
-                        lineno=assign.value.lineno,
-                        col_offset=assign.value.col_offset)
-        new_assign = ast.Assign(assign.targets, name, lineno=assign.lineno,
-                                col_offset=assign.col_offset)
-        mod = ast.Module([new_assign])
-        co = self._compile(mod, "exec")
-        try:
-            self.frame.exec_(co, __exprinfo_expr=value_result)
-        except Exception:
-            raise Failure(explanation)
-        return explanation, value_result
-

_pytest/assertion/rewrite.py

@@ -1,6 +1,7 @@
 """Rewrite assertion AST to produce nice error messages"""
 
 import ast
+import _ast
 import errno
 import itertools
 import imp
@@ -10,6 +11,7 @@ import re
 import struct
 import sys
 import types
+from fnmatch import fnmatch
 
 import py
 from _pytest.assertion import util
@@ -44,20 +46,20 @@ else:
 class AssertionRewritingHook(object):
     """PEP302 Import hook which rewrites asserts."""
 
-    def __init__(self):
+    def __init__(self, config):
+        self.config = config
+        self.fnpats = config.getini("python_files")
         self.session = None
         self.modules = {}
+        self._rewritten_names = set()
         self._register_with_pkg_resources()
+        self._must_rewrite = set()
 
     def set_session(self, session):
-        self.fnpats = session.config.getini("python_files")
         self.session = session
 
     def find_module(self, name, path=None):
-        if self.session is None:
-            return None
-        sess = self.session
-        state = sess.config._assertstate
+        state = self.config._assertstate
         state.trace("find_module called for: %s" % name)
         names = name.rsplit(".", 1)
         lastname = names[-1]
@@ -78,7 +80,12 @@ class AssertionRewritingHook(object):
             tp = desc[2]
             if tp == imp.PY_COMPILED:
                 if hasattr(imp, "source_from_cache"):
-                    fn = imp.source_from_cache(fn)
+                    try:
+                        fn = imp.source_from_cache(fn)
+                    except ValueError:
+                        # Python 3 doesn't like orphaned but still-importable
+                        # .pyc files.
+                        fn = fn[:-1]
                 else:
                     fn = fn[:-1]
             elif tp != imp.PY_SOURCE:
@@ -86,24 +93,13 @@ class AssertionRewritingHook(object):
                 return None
         else:
             fn = os.path.join(pth, name.rpartition(".")[2] + ".py")
+
         fn_pypath = py.path.local(fn)
-        # Is this a test file?
-        if not sess.isinitpath(fn):
-            # We have to be very careful here because imports in this code can
-            # trigger a cycle.
-            self.session = None
-            try:
-                for pat in self.fnpats:
-                    if fn_pypath.fnmatch(pat):
-                        state.trace("matched test file %r" % (fn,))
-                        break
-                else:
-                    return None
-            finally:
-                self.session = sess
-        else:
-            state.trace("matched test file (was specified on cmdline): %r" %
-                        (fn,))
+        if not self._should_rewrite(name, fn_pypath, state):
+            return None
+
+        self._rewritten_names.add(name)
+
         # The requested module looks like a test file, so rewrite it. This is
         # the most magical part of the process: load the source, rewrite the
         # asserts, and load the rewritten source. We also cache the rewritten
@@ -140,7 +136,7 @@ class AssertionRewritingHook(object):
         co = _read_pyc(fn_pypath, pyc, state.trace)
         if co is None:
             state.trace("rewriting %r" % (fn,))
-            source_stat, co = _rewrite_test(state, fn_pypath)
+            source_stat, co = _rewrite_test(self.config, fn_pypath)
             if co is None:
                 # Probably a SyntaxError in the test.
                 return None
@@ -151,6 +147,55 @@ class AssertionRewritingHook(object):
         self.modules[name] = co, pyc
         return self
 
+    def _should_rewrite(self, name, fn_pypath, state):
+        # always rewrite conftest files
+        fn = str(fn_pypath)
+        if fn_pypath.basename == 'conftest.py':
+            state.trace("rewriting conftest file: %r" % (fn,))
+            return True
+
+        if self.session is not None:
+            if self.session.isinitpath(fn):
+                state.trace("matched test file (was specified on cmdline): %r" %
+                            (fn,))
+                return True
+
+        # modules not passed explicitly on the command line are only
+        # rewritten if they match the naming convention for test files
+        for pat in self.fnpats:
+            # use fnmatch instead of fn_pypath.fnmatch because the
+            # latter might trigger an import to fnmatch.fnmatch
+            # internally, which would cause this method to be
+            # called recursively
+            if fnmatch(fn_pypath.basename, pat):
+                state.trace("matched test file %r" % (fn,))
+                return True
+
+        for marked in self._must_rewrite:
+            if name.startswith(marked):
+                state.trace("matched marked file %r (from %r)" % (name, marked))
+                return True
+
+        return False
+
+    def mark_rewrite(self, *names):
+        """Mark import names as needing to be re-written.
+
+        The named module or package as well as any nested modules will
+        be re-written on import.
+        """
+        already_imported = set(names).intersection(set(sys.modules))
+        if already_imported:
+            for name in already_imported:
+                if name not in self._rewritten_names:
+                    self._warn_already_imported(name)
+        self._must_rewrite.update(names)
+
+    def _warn_already_imported(self, name):
+        self.config.warn(
+            'P1',
+            'Module already imported so can not be re-written: %s' % name)
+
     def load_module(self, name):
         # If there is an existing module object named 'fullname' in
         # sys.modules, the loader must use that existing module. (Otherwise,
@@ -235,14 +280,16 @@ def _write_pyc(state, co, source_stat, pyc):
         fp.close()
     return True
 
+
 RN = "\r\n".encode("utf-8")
 N = "\n".encode("utf-8")
 
 cookie_re = re.compile(r"^[ \t\f]*#.*coding[:=][ \t]*[-\w.]+")
 BOM_UTF8 = '\xef\xbb\xbf'
 
-def _rewrite_test(state, fn):
+def _rewrite_test(config, fn):
     """Try to read and rewrite *fn* and return the code object."""
+    state = config._assertstate
     try:
         stat = fn.stat()
         source = fn.read("rb")
@@ -287,7 +334,7 @@ def _rewrite_test(state, fn):
         # Let this pop up again in the real import.
         state.trace("failed to parse: %r" % (fn,))
         return None, None
-    rewrite_asserts(tree)
+    rewrite_asserts(tree, fn, config)
     try:
         co = compile(tree, fn.strpath, "exec")
     except SyntaxError:
@@ -343,9 +390,9 @@ def _read_pyc(source, pyc, trace=lambda x: None):
         return co
 
 
-def rewrite_asserts(mod):
+def rewrite_asserts(mod, module_path=None, config=None):
     """Rewrite the assert statements in mod."""
-    AssertionRewriter().run(mod)
+    AssertionRewriter(module_path, config).run(mod)
 
 
 def _saferepr(obj):
@@ -532,6 +579,11 @@ class AssertionRewriter(ast.NodeVisitor):
 
     """
 
+    def __init__(self, module_path, config):
+        super(AssertionRewriter, self).__init__()
+        self.module_path = module_path
+        self.config = config
+
     def run(self, mod):
         """Find all assert statements in *mod* and rewrite them."""
         if not mod.body:
@@ -672,6 +724,10 @@ class AssertionRewriter(ast.NodeVisitor):
         the expression is false.
 
         """
+        if isinstance(assert_.test, ast.Tuple) and self.config is not None:
+            fslocation = (self.module_path, assert_.lineno)
+            self.config.warn('R1', 'assertion is always true, perhaps '
+                              'remove parentheses?', fslocation=fslocation)
         self.statements = []
         self.variables = []
         self.variable_counter = itertools.count()
@@ -855,6 +911,8 @@ class AssertionRewriter(ast.NodeVisitor):
     def visit_Compare(self, comp):
         self.push_format_context()
         left_res, left_expl = self.visit(comp.left)
+        if isinstance(comp.left, (_ast.Compare, _ast.BoolOp)):
+            left_expl = "({0})".format(left_expl)
         res_variables = [self.variable() for i in range(len(comp.ops))]
         load_names = [ast.Name(v, ast.Load()) for v in res_variables]
         store_names = [ast.Name(v, ast.Store()) for v in res_variables]
@@ -864,6 +922,8 @@ class AssertionRewriter(ast.NodeVisitor):
         results = [left_res]
         for i, op, next_operand in it:
             next_res, next_expl = self.visit(next_operand)
+            if isinstance(next_operand, (_ast.Compare, _ast.BoolOp)):
+                next_expl = "({0})".format(next_expl)
             results.append(next_res)
             sym = binop_map[op.__class__]
             syms.append(ast.Str(sym))

_pytest/assertion/util.py

@@ -38,44 +38,11 @@ def format_explanation(explanation):
     displaying diffs.
     """
     explanation = ecu(explanation)
-    explanation = _collapse_false(explanation)
     lines = _split_explanation(explanation)
     result = _format_lines(lines)
     return u('\n').join(result)
 
 
-def _collapse_false(explanation):
-    """Collapse expansions of False
-
-    So this strips out any "assert False\n{where False = ...\n}"
-    blocks.
-    """
-    where = 0
-    while True:
-        start = where = explanation.find("False\n{False = ", where)
-        if where == -1:
-            break
-        level = 0
-        prev_c = explanation[start]
-        for i, c in enumerate(explanation[start:]):
-            if prev_c + c == "\n{":
-                level += 1
-            elif prev_c + c == "\n}":
-                level -= 1
-                if not level:
-                    break
-            prev_c = c
-        else:
-            raise AssertionError("unbalanced braces: %r" % (explanation,))
-        end = start + i
-        where = end
-        if explanation[end - 1] == '\n':
-            explanation = (explanation[:start] + explanation[start+15:end-1] +
-                           explanation[end+1:])
-            where -= 17
-    return explanation
-
-
 def _split_explanation(explanation):
     """Return a list of individual lines in the explanation
 
@@ -138,7 +105,7 @@ except NameError:
 def assertrepr_compare(config, op, left, right):
     """Return specialised explanations for some operators/operands"""
     width = 80 - 15 - len(op) - 2  # 15 chars indentation, 1 space around op
-    left_repr = py.io.saferepr(left, maxsize=int(width/2))
+    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') % (ecu(left_repr), op, ecu(right_repr))
@@ -225,9 +192,10 @@ def _diff_text(left, right, verbose=False):
                                   'characters in diff, use -v to show') % i]
                 left = left[:-i]
                 right = right[:-i]
+    keepends = True
     explanation += [line.strip('\n')
-                    for line in ndiff(left.splitlines(),
-                                      right.splitlines())]
+                    for line in ndiff(left.splitlines(keepends),
+                                      right.splitlines(keepends))]
     return explanation
 
 

_pytest/capture.py

@@ -4,6 +4,7 @@ per-test stdout/stderr capturing mechanism.
 """
 from __future__ import with_statement
 
+import contextlib
 import sys
 import os
 from tempfile import TemporaryFile
@@ -146,46 +147,48 @@ class CaptureManager:
     def pytest_internalerror(self, excinfo):
         self.reset_capturings()
 
-    def suspendcapture_item(self, item, when):
-        out, err = self.suspendcapture()
+    def suspendcapture_item(self, item, when, in_=False):
+        out, err = self.suspendcapture(in_=in_)
         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.fixture
 def capsys(request):
-    """enables capturing of writes to sys.stdout/sys.stderr and makes
+    """Enable capturing of writes to sys.stdout/sys.stderr and make
     captured output available via ``capsys.readouterr()`` method calls
     which return a ``(out, err)`` tuple.
     """
-    if "capfd" in request._funcargs:
+    if "capfd" in request.fixturenames:
         raise request.raiseerror(error_capsysfderror)
-    request.node._capfuncarg = c = CaptureFixture(SysCapture)
+    request.node._capfuncarg = c = CaptureFixture(SysCapture, request)
     return c
 
 @pytest.fixture
 def capfd(request):
-    """enables capturing of writes to file descriptors 1 and 2 and makes
+    """Enable capturing of writes to file descriptors 1 and 2 and make
     captured output available via ``capfd.readouterr()`` method calls
     which return a ``(out, err)`` tuple.
     """
-    if "capsys" in request._funcargs:
+    if "capsys" in request.fixturenames:
         request.raiseerror(error_capsysfderror)
     if not hasattr(os, 'dup'):
         pytest.skip("capfd funcarg needs os.dup")
-    request.node._capfuncarg = c = CaptureFixture(FDCapture)
+    request.node._capfuncarg = c = CaptureFixture(FDCapture, request)
     return c
 
 
 class CaptureFixture:
-    def __init__(self, captureclass):
+    def __init__(self, captureclass, request):
         self.captureclass = captureclass
+        self.request = request
 
     def _start(self):
         self._capture = MultiCapture(out=True, err=True, in_=False,
-                                       Capture=self.captureclass)
+                                     Capture=self.captureclass)
         self._capture.start_capturing()
 
     def close(self):
@@ -200,6 +203,15 @@ class CaptureFixture:
         except AttributeError:
             return self._outerr
 
+    @contextlib.contextmanager
+    def disabled(self):
+        capmanager = self.request.config.pluginmanager.getplugin('capturemanager')
+        capmanager.suspendcapture_item(self.request.node, "call", in_=True)
+        try:
+            yield
+        finally:
+            capmanager.resumecapture()
+
 
 def safe_text_dupfile(f, mode, default_encoding="UTF8"):
     """ return a open text file object that's a duplicate of f on the
@@ -444,6 +456,13 @@ class DontReadFromInput:
     def close(self):
         pass
 
+    @property
+    def buffer(self):
+        if sys.version_info >= (3,0):
+            return self
+        else:
+            raise AttributeError('redirected stdin has no attribute buffer')
+
 
 def _readline_workaround():
     """
@@ -452,7 +471,7 @@ def _readline_workaround():
 
     Pdb uses readline support where available--when not running from the Python
     prompt, the readline module is not imported until running the pdb REPL.  If
-    running py.test with the --pdb option this means the readline module is not
+    running pytest with the --pdb option this means the readline module is not
     imported until after I/O capture has been started.
 
     This is a problem for pyreadline, which is often used to implement readline

_pytest/compat.py

@@ -0,0 +1,230 @@
+"""
+python version compatibility code
+"""
+import sys
+import inspect
+import types
+import re
+import functools
+
+import py
+
+import  _pytest
+
+
+
+try:
+    import enum
+except ImportError:  # pragma: no cover
+    # Only available in Python 3.4+ or as a backport
+    enum = None
+
+_PY3 = sys.version_info > (3, 0)
+_PY2 = not _PY3
+
+
+NoneType = type(None)
+NOTSET = object()
+
+if hasattr(inspect, 'signature'):
+    def _format_args(func):
+        return str(inspect.signature(func))
+else:
+    def _format_args(func):
+        return inspect.formatargspec(*inspect.getargspec(func))
+
+isfunction = inspect.isfunction
+isclass = inspect.isclass
+# 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(''))
+
+
+def is_generator(func):
+    try:
+        return _pytest._code.getrawcode(func).co_flags & 32 # generator function
+    except AttributeError: # builtin functions have no bytecode
+        # assume them to not be generators
+        return False
+
+
+def getlocation(function, curdir):
+    import inspect
+    fn = py.path.local(inspect.getfile(function))
+    lineno = py.builtin._getcode(function).co_firstlineno
+    if fn.relto(curdir):
+        fn = fn.relto(curdir)
+    return "%s:%d" %(fn, lineno+1)
+
+
+def num_mock_patch_args(function):
+    """ return number of arguments used up by mock arguments (if any) """
+    patchings = getattr(function, "patchings", None)
+    if not patchings:
+        return 0
+    mock = sys.modules.get("mock", sys.modules.get("unittest.mock", None))
+    if mock is not None:
+        return len([p for p in patchings
+                        if not p.attribute_name and p.new is mock.DEFAULT])
+    return len(patchings)
+
+
+def getfuncargnames(function, startindex=None):
+    # XXX merge with main.py's varnames
+    #assert not isclass(function)
+    realfunction = function
+    while hasattr(realfunction, "__wrapped__"):
+        realfunction = realfunction.__wrapped__
+    if startindex is None:
+        startindex = inspect.ismethod(function) and 1 or 0
+    if realfunction != function:
+        startindex += num_mock_patch_args(function)
+        function = realfunction
+    if isinstance(function, functools.partial):
+        argnames = inspect.getargs(_pytest._code.getrawcode(function.func))[0]
+        partial = function
+        argnames = argnames[len(partial.args):]
+        if partial.keywords:
+            for kw in partial.keywords:
+                argnames.remove(kw)
+    else:
+        argnames = inspect.getargs(_pytest._code.getrawcode(function))[0]
+    defaults = getattr(function, 'func_defaults',
+                       getattr(function, '__defaults__', None)) or ()
+    numdefaults = len(defaults)
+    if numdefaults:
+        return tuple(argnames[startindex:-numdefaults])
+    return tuple(argnames[startindex:])
+
+
+
+if  sys.version_info[:2] == (2, 6):
+    def isclass(object):
+        """ Return true if the object is a class. Overrides inspect.isclass for
+        python 2.6 because it will return True for objects which always return
+        something on __getattr__ calls (see #1035).
+        Backport of https://hg.python.org/cpython/rev/35bf8f7a8edc
+        """
+        return isinstance(object, (type, types.ClassType))
+
+
+if _PY3:
+    import codecs
+
+    STRING_TYPES = bytes, str
+
+    def _escape_strings(val):
+        """If val is pure ascii, returns it as a str().  Otherwise, escapes
+        bytes objects into a sequence of escaped bytes:
+
+        b'\xc3\xb4\xc5\xd6' -> u'\\xc3\\xb4\\xc5\\xd6'
+
+        and escapes unicode objects into a sequence of escaped unicode
+        ids, e.g.:
+
+        '4\\nV\\U00043efa\\x0eMXWB\\x1e\\u3028\\u15fd\\xcd\\U0007d944'
+
+        note:
+           the obvious "v.decode('unicode-escape')" will return
+           valid utf-8 unicode if it finds them in bytes, but we
+           want to return escaped bytes for any byte, even if they match
+           a utf-8 string.
+
+        """
+        if isinstance(val, bytes):
+            if val:
+                # source: http://goo.gl/bGsnwC
+                encoded_bytes, _ = codecs.escape_encode(val)
+                return encoded_bytes.decode('ascii')
+            else:
+                # empty bytes crashes codecs.escape_encode (#1087)
+                return ''
+        else:
+            return val.encode('unicode_escape').decode('ascii')
+else:
+    STRING_TYPES = bytes, str, unicode
+
+    def _escape_strings(val):
+        """In py2 bytes and str are the same type, so return if it's a bytes
+        object, return it unchanged if it is a full ascii string,
+        otherwise escape it into its binary form.
+
+        If it's a unicode string, change the unicode characters into
+        unicode escapes.
+
+        """
+        if isinstance(val, bytes):
+            try:
+                return val.encode('ascii')
+            except UnicodeDecodeError:
+                return val.encode('string-escape')
+        else:
+            return val.encode('unicode-escape')
+
+
+def get_real_func(obj):
+    """ gets the real function object of the (possibly) wrapped object by
+    functools.wraps or functools.partial.
+    """
+    while hasattr(obj, "__wrapped__"):
+        obj = obj.__wrapped__
+    if isinstance(obj, functools.partial):
+        obj = obj.func
+    return obj
+
+
+def getfslineno(obj):
+    # xxx let decorators etc specify a sane ordering
+    obj = get_real_func(obj)
+    if hasattr(obj, 'place_as'):
+        obj = obj.place_as
+    fslineno = _pytest._code.getfslineno(obj)
+    assert isinstance(fslineno[1], int), obj
+    return fslineno
+
+
+def getimfunc(func):
+    try:
+        return func.__func__
+    except AttributeError:
+        try:
+            return func.im_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
+
+
+def _is_unittest_unexpected_success_a_failure():
+    """Return if the test suite should fail if a @expectedFailure unittest test PASSES.
+
+    From https://docs.python.org/3/library/unittest.html?highlight=unittest#unittest.TestResult.wasSuccessful:
+        Changed in version 3.4: Returns False if there were any
+        unexpectedSuccesses from tests marked with the expectedFailure() decorator.
+    """
+    return sys.version_info >= (3, 4)
+
+
+if _PY3:
+    def safe_str(v):
+        """returns v as string"""
+        return str(v)
+else:
+    def safe_str(v):
+        """returns v as string, converting to ascii if necessary"""
+        try:
+            return str(v)
+        except UnicodeError:
+            errors = 'replace'
+            return v.encode('ascii', errors)

_pytest/config.py

@@ -10,7 +10,9 @@ import py
 import sys, os
 import _pytest._code
 import _pytest.hookspec  # the extension point definitions
+import _pytest.assertion
 from _pytest._pluggy import PluginManager, HookimplMarker, HookspecMarker
+from _pytest.compat import safe_str
 
 hookimpl = HookimplMarker("pytest")
 hookspec = HookspecMarker("pytest")
@@ -25,6 +27,12 @@ class ConftestImportFailure(Exception):
         self.path = path
         self.excinfo = excinfo
 
+    def __str__(self):
+        etype, evalue, etb = self.excinfo
+        formatted = traceback.format_tb(etb)
+        # The level of the tracebacks we want to print is hand crafted :(
+        return repr(evalue) + '\n' + ''.join(formatted[2:])
+
 
 def main(args=None, plugins=None):
     """ return exit code, after performing an in-process test run.
@@ -57,15 +65,40 @@ def main(args=None, plugins=None):
 class cmdline:  # compatibility namespace
     main = staticmethod(main)
 
+
 class UsageError(Exception):
     """ error in pytest usage or invocation"""
 
+
+def filename_arg(path, optname):
+    """ Argparse type validator for filename arguments.
+
+    :path: path of filename
+    :optname: name of the option
+    """
+    if os.path.isdir(path):
+        raise UsageError("{0} must be a filename, given: {1}".format(optname, path))
+    return path
+
+
+def directory_arg(path, optname):
+    """Argparse type validator for directory arguments.
+
+    :path: path of directory
+    :optname: name of the option
+    """
+    if not os.path.isdir(path):
+        raise UsageError("{0} must be a directory, given: {1}".format(optname, path))
+    return path
+
+
 _preinit = []
 
 default_plugins = (
-     "mark main terminal runner python pdb unittest capture skipping "
-     "tmpdir monkeypatch recwarn pastebin helpconfig nose assertion genscript "
-     "junitxml resultlog doctest cacheprovider").split()
+     "mark main terminal runner python fixtures debugging unittest capture skipping "
+     "tmpdir monkeypatch recwarn pastebin helpconfig nose assertion "
+     "junitxml resultlog doctest cacheprovider freeze_support "
+     "setuponly setupplan").split()
 
 builtin_plugins = set(default_plugins)
 builtin_plugins.add("pytester")
@@ -97,6 +130,7 @@ def get_plugin_manager():
     return get_config().pluginmanager
 
 def _prepareconfig(args=None, plugins=None):
+    warning = None
     if args is None:
         args = sys.argv[1:]
     elif isinstance(args, py.path.local):
@@ -105,6 +139,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, posix=sys.platform != "win32")
+        from _pytest import deprecated
+        warning = deprecated.MAIN_STR_ARGS
     config = get_config()
     pluginmanager = config.pluginmanager
     try:
@@ -114,6 +150,8 @@ def _prepareconfig(args=None, plugins=None):
                     pluginmanager.consider_pluginarg(plugin)
                 else:
                     pluginmanager.register(plugin)
+        if warning:
+            config.warn('C1', warning)
         return pluginmanager.hook.pytest_cmdline_parse(
                 pluginmanager=pluginmanager, args=args)
     except BaseException:
@@ -139,6 +177,7 @@ class PytestPluginManager(PluginManager):
         self._conftestpath2mod = {}
         self._confcutdir = None
         self._noconftest = False
+        self._duplicatepaths = set()
 
         self.add_hookspecs(_pytest.hookspec)
         self.register(self)
@@ -152,6 +191,9 @@ class PytestPluginManager(PluginManager):
             self.trace.root.setwriter(err.write)
             self.enable_tracing()
 
+        # Config._consider_importhook will set a real object if required.
+        self.rewrite_hook = _pytest.assertion.DummyRewriteHook()
+
     def addhooks(self, module_or_class):
         """
         .. deprecated:: 2.8
@@ -360,7 +402,11 @@ class PytestPluginManager(PluginManager):
         self._import_plugin_specs(os.environ.get("PYTEST_PLUGINS"))
 
     def consider_module(self, mod):
-        self._import_plugin_specs(getattr(mod, "pytest_plugins", None))
+        plugins = getattr(mod, 'pytest_plugins', [])
+        if isinstance(plugins, str):
+            plugins = [plugins]
+        self.rewrite_hook.mark_rewrite(*plugins)
+        self._import_plugin_specs(plugins)
 
     def _import_plugin_specs(self, spec):
         if spec:
@@ -384,7 +430,7 @@ class PytestPluginManager(PluginManager):
         try:
             __import__(importspec)
         except ImportError as e:
-            new_exc = ImportError('Error importing plugin "%s": %s' % (modname, e))
+            new_exc = ImportError('Error importing plugin "%s": %s' % (modname, safe_str(e.args[0])))
             # copy over name and path attributes
             for attr in ('name', 'path'):
                 if hasattr(e, attr):
@@ -537,13 +583,18 @@ class ArgumentError(Exception):
 
 
 class Argument:
-    """class that mimics the necessary behaviour of optparse.Option """
+    """class that mimics the necessary behaviour of optparse.Option
+
+    its currently a least effort implementation
+    and ignoring choices and integer prefixes
+    https://docs.python.org/3/library/optparse.html#optparse-standard-option-types
+    """
     _typ_map = {
         'int': int,
         'string': str,
-        }
-    # enable after some grace period for plugin writers
-    TYPE_WARN = False
+        'float': float,
+        'complex': complex,
+    }
 
     def __init__(self, *names, **attrs):
         """store parms in private vars for use in add_argument"""
@@ -551,17 +602,12 @@ class Argument:
         self._short_opts = []
         self._long_opts = []
         self.dest = attrs.get('dest')
-        if self.TYPE_WARN:
-            try:
-                help = attrs['help']
-                if '%default' in help:
-                    warnings.warn(
-                        'pytest now uses argparse. "%default" should be'
-                        ' changed to "%(default)s" ',
-                        FutureWarning,
-                        stacklevel=3)
-            except KeyError:
-                pass
+        if '%default' in (attrs.get('help') or ''):
+            warnings.warn(
+                'pytest now uses argparse. "%default" should be'
+                ' changed to "%(default)s" ',
+                DeprecationWarning,
+                stacklevel=3)
         try:
             typ = attrs['type']
         except KeyError:
@@ -570,25 +616,23 @@ class Argument:
             # this might raise a keyerror as well, don't want to catch that
             if isinstance(typ, py.builtin._basestring):
                 if typ == 'choice':
-                    if self.TYPE_WARN:
-                        warnings.warn(
-                            'type argument to addoption() is a string %r.'
-                            ' For parsearg this is optional and when supplied '
-                            ' should be a type.'
-                            ' (options: %s)' % (typ, names),
-                            FutureWarning,
-                            stacklevel=3)
+                    warnings.warn(
+                        'type argument to addoption() is a string %r.'
+                        ' For parsearg this is optional and when supplied'
+                        ' should be a type.'
+                        ' (options: %s)' % (typ, names),
+                        DeprecationWarning,
+                        stacklevel=3)
                     # argparse expects a type here take it from
                     # the type of the first element
                     attrs['type'] = type(attrs['choices'][0])
                 else:
-                    if self.TYPE_WARN:
-                        warnings.warn(
-                            'type argument to addoption() is a string %r.'
-                            ' For parsearg this should be a type.'
-                            ' (options: %s)' % (typ, names),
-                            FutureWarning,
-                            stacklevel=3)
+                    warnings.warn(
+                        'type argument to addoption() is a string %r.'
+                        ' For parsearg this should be a type.'
+                        ' (options: %s)' % (typ, names),
+                        DeprecationWarning,
+                        stacklevel=3)
                     attrs['type'] = Argument._typ_map[typ]
                 # used in test_parseopt -> test_parse_defaultgetter
                 self.type = attrs['type']
@@ -655,20 +699,17 @@ class Argument:
                 self._long_opts.append(opt)
 
     def __repr__(self):
-        retval = 'Argument('
+        args = []
         if self._short_opts:
-            retval += '_short_opts: ' + repr(self._short_opts) + ', '
+            args += ['_short_opts: ' + repr(self._short_opts)]
         if self._long_opts:
-            retval += '_long_opts: ' + repr(self._long_opts) + ', '
-        retval += 'dest: ' + repr(self.dest) + ', '
+            args += ['_long_opts: ' + repr(self._long_opts)]
+        args += ['dest: ' + repr(self.dest)]
         if hasattr(self, 'type'):
-            retval += 'type: ' + repr(self.type) + ', '
+            args += ['type: ' + repr(self.type)]
         if hasattr(self, 'default'):
-            retval += 'default: ' + repr(self.default) + ', '
-        if retval[-2:] == ', ':  # always long enough to test ("Argument(" )
-            retval = retval[:-2]
-        retval += ')'
-        return retval
+            args += ['default: ' + repr(self.default)]
+        return 'Argument({0})'.format(', '.join(args))
 
 
 class OptionGroup:
@@ -686,6 +727,10 @@ class OptionGroup:
         results in help showing '--two-words' only, but --twowords gets
         accepted **and** the automatic destination is in args.twowords
         """
+        conflict = set(optnames).intersection(
+            name for opt in self.options for name in opt.names())
+        if conflict:
+            raise ValueError("option names %s already added" % conflict)
         option = Argument(*optnames, **attrs)
         self._addoption_instance(option, shortupper=False)
 
@@ -772,7 +817,7 @@ class DropShorterLongHelpFormatter(argparse.HelpFormatter):
             if len(option) == 2 or option[2] == ' ':
                 return_list.append(option)
             if option[2:] == short_long.get(option.replace('-', '')):
-                return_list.append(option.replace(' ', '='))
+                return_list.append(option.replace(' ', '=', 1))
         action._formatted_action_invocation = ', '.join(return_list)
         return action._formatted_action_invocation
 
@@ -797,9 +842,11 @@ class Notset:
     def __repr__(self):
         return "<NOTSET>"
 
+
 notset = Notset()
 FILE_OR_DIR = 'file_or_dir'
 
+
 class Config(object):
     """ access to configuration values, pluginmanager and plugin hooks.  """
 
@@ -822,9 +869,11 @@ class Config(object):
         self._warn = self.pluginmanager._warn
         self.pluginmanager.register(self, "pytestconfig")
         self._configured = False
+
         def do_setns(dic):
             import pytest
             setns(pytest, dic)
+
         self.hook.pytest_namespace.call_historic(do_setns, {})
         self.hook.pytest_addoption.call_historic(kwargs=dict(parser=self._parser))
 
@@ -908,7 +957,7 @@ class Config(object):
 
     def _initini(self, args):
         ns, unknown_args = self._parser.parse_known_and_unknown_args(args, namespace=self.option.copy())
-        r = determine_setup(ns.inifilename, ns.file_or_dir + unknown_args)
+        r = determine_setup(ns.inifilename, ns.file_or_dir + unknown_args, warnfunc=self.warn)
         self.rootdir, self.inifile, self.inicfg = r
         self._parser.extra_info['rootdir'] = self.rootdir
         self._parser.extra_info['inifile'] = self.inifile
@@ -916,19 +965,71 @@ class Config(object):
         self._parser.addini('addopts', 'extra command line options', 'args')
         self._parser.addini('minversion', 'minimally required pytest version')
 
+    def _consider_importhook(self, args, entrypoint_name):
+        """Install the PEP 302 import hook if using assertion re-writing.
+
+        Needs to parse the --assert=<mode> option from the commandline
+        and find all the installed plugins to mark them for re-writing
+        by the importhook.
+        """
+        ns, unknown_args = self._parser.parse_known_and_unknown_args(args)
+        mode = ns.assertmode
+        if mode == 'rewrite':
+            try:
+                hook = _pytest.assertion.install_importhook(self)
+            except SystemError:
+                mode = 'plain'
+            else:
+                import pkg_resources
+                self.pluginmanager.rewrite_hook = hook
+                for entrypoint in pkg_resources.iter_entry_points('pytest11'):
+                    # 'RECORD' available for plugins installed normally (pip install)
+                    # 'SOURCES.txt' available for plugins installed in dev mode (pip install -e)
+                    # for installed plugins 'SOURCES.txt' returns an empty list, and vice-versa
+                    # so it shouldn't be an issue
+                    for metadata in ('RECORD', 'SOURCES.txt'):
+                        for entry in entrypoint.dist._get_metadata(metadata):
+                            fn = entry.split(',')[0]
+                            is_simple_module = os.sep not in fn and fn.endswith('.py')
+                            is_package = fn.count(os.sep) == 1 and fn.endswith('__init__.py')
+                            if is_simple_module:
+                                module_name, ext = os.path.splitext(fn)
+                                hook.mark_rewrite(module_name)
+                            elif is_package:
+                                package_name = os.path.dirname(fn)
+                                hook.mark_rewrite(package_name)
+        self._warn_about_missing_assertion(mode)
+
+    def _warn_about_missing_assertion(self, mode):
+        try:
+            assert False
+        except AssertionError:
+            pass
+        else:
+            if mode == 'plain':
+                sys.stderr.write("WARNING: ASSERTIONS ARE NOT EXECUTED"
+                                 " and FAILING TESTS WILL PASS.  Are you"
+                                 " using python -O?")
+            else:
+                sys.stderr.write("WARNING: assertions not in test modules or"
+                                 " plugins will be ignored"
+                                 " because assert statements are not executed "
+                                 "by the underlying Python interpreter "
+                                 "(are you using python -O?)\n")
+
     def _preparse(self, args, addopts=True):
         self._initini(args)
         if addopts:
             args[:] = shlex.split(os.environ.get('PYTEST_ADDOPTS', '')) + args
             args[:] = self.getini("addopts") + args
         self._checkversion()
+        entrypoint_name = 'pytest11'
+        self._consider_importhook(args, entrypoint_name)
         self.pluginmanager.consider_preparse(args)
-        try:
-            self.pluginmanager.load_setuptools_entrypoints("pytest11")
-        except ImportError as e:
-            self.warn("I2", "could not load setuptools entry import: %s" % (e,))
+        self.pluginmanager.load_setuptools_entrypoints(entrypoint_name)
         self.pluginmanager.consider_env()
         self.known_args_namespace = ns = self._parser.parse_known_args(args, namespace=self.option.copy())
+        confcutdir = self.known_args_namespace.confcutdir
         if self.known_args_namespace.confcutdir is None and self.inifile:
             confcutdir = py.path.local(self.inifile).dirname
             self.known_args_namespace.confcutdir = confcutdir
@@ -999,14 +1100,16 @@ class Config(object):
             description, type, default = self._parser._inidict[name]
         except KeyError:
             raise ValueError("unknown configuration value: %r" %(name,))
-        try:
-            value = self.inicfg[name]
-        except KeyError:
-            if default is not None:
-                return default
-            if type is None:
-                return ''
-            return []
+        value = self._get_override_ini_value(name)
+        if value is None:
+            try:
+                value = self.inicfg[name]
+            except KeyError:
+                if default is not None:
+                    return default
+                if type is None:
+                    return ''
+                return []
         if type == "pathlist":
             dp = py.path.local(self.inicfg.config.path).dirpath()
             l = []
@@ -1037,6 +1140,23 @@ class Config(object):
             l.append(relroot)
         return l
 
+    def _get_override_ini_value(self, name):
+        value = None
+        # override_ini is a list of list, to support both -o foo1=bar1 foo2=bar2 and
+        # and -o foo1=bar1 -o foo2=bar2 options
+        # always use the last item if multiple value set for same ini-name,
+        # e.g. -o foo=bar1 -o foo=bar2 will set foo to bar2
+        if self.getoption("override_ini", None):
+            for ini_config_list in self.option.override_ini:
+                for ini_config in ini_config_list:
+                    try:
+                        (key, user_ini_value) = ini_config.split("=", 1)
+                    except ValueError:
+                        raise UsageError("-o/--override-ini expects option=value style.")
+                    if key == name:
+                        value = user_ini_value
+        return value
+
     def getoption(self, name, default=notset, skip=False):
         """ return command line option value.
 
@@ -1074,7 +1194,18 @@ def exists(path, ignore=EnvironmentError):
     except ignore:
         return False
 
-def getcfg(args, inibasenames):
+def getcfg(args, warnfunc=None):
+    """
+    Search the list of arguments for a valid ini-file for pytest,
+    and return a tuple of (rootdir, inifile, cfg-dict).
+
+    note: warnfunc is an optional function used to warn
+        about ini-files that use deprecated features.
+        This parameter should be removed when pytest
+        adopts standard deprecation warnings (#1804).
+    """
+    from _pytest.deprecated import SETUP_CFG_PYTEST
+    inibasenames = ["pytest.ini", "tox.ini", "setup.cfg"]
     args = [x for x in args if not str(x).startswith("-")]
     if not args:
         args = [py.path.local()]
@@ -1086,7 +1217,11 @@ def getcfg(args, inibasenames):
                 if exists(p):
                     iniconfig = py.iniconfig.IniConfig(p)
                     if 'pytest' in iniconfig.sections:
+                        if inibasename == 'setup.cfg' and warnfunc:
+                            warnfunc('C1', SETUP_CFG_PYTEST)
                         return base, p, iniconfig['pytest']
+                    if inibasename == 'setup.cfg' and 'tool:pytest' in iniconfig.sections:
+                        return base, p, iniconfig['tool:pytest']
                     elif inibasename == "pytest.ini":
                         # allowed to be empty
                         return base, p, {}
@@ -1101,6 +1236,8 @@ def get_common_ancestor(args):
         if str(arg)[0] == "-":
             continue
         p = py.path.local(arg)
+        if not p.exists():
+            continue
         if common_ancestor is None:
             common_ancestor = p
         else:
@@ -1114,29 +1251,40 @@ def get_common_ancestor(args):
                     common_ancestor = shared
     if common_ancestor is None:
         common_ancestor = py.path.local()
-    elif not common_ancestor.isdir():
+    elif common_ancestor.isfile():
         common_ancestor = common_ancestor.dirpath()
     return common_ancestor
 
 
-def determine_setup(inifile, args):
+def get_dirs_from_args(args):
+    return [d for d in (py.path.local(x) for x in args
+                        if not str(x).startswith("-"))
+            if d.exists()]
+
+
+def determine_setup(inifile, args, warnfunc=None):
+    dirs = get_dirs_from_args(args)
     if inifile:
         iniconfig = py.iniconfig.IniConfig(inifile)
         try:
             inicfg = iniconfig["pytest"]
         except KeyError:
             inicfg = None
-        rootdir = get_common_ancestor(args)
+        rootdir = get_common_ancestor(dirs)
     else:
-        ancestor = get_common_ancestor(args)
-        rootdir, inifile, inicfg = getcfg(
-            [ancestor], ["pytest.ini", "tox.ini", "setup.cfg"])
+        ancestor = get_common_ancestor(dirs)
+        rootdir, inifile, inicfg = getcfg([ancestor], warnfunc=warnfunc)
         if rootdir is None:
             for rootdir in ancestor.parts(reverse=True):
                 if rootdir.join("setup.py").exists():
                     break
             else:
-                rootdir = ancestor
+                rootdir, inifile, inicfg = getcfg(dirs, warnfunc=warnfunc)
+                if rootdir is None:
+                    rootdir = get_common_ancestor([py.path.local(), ancestor])
+                    is_fs_root = os.path.splitdrive(str(rootdir))[1] == os.sep
+                    if is_fs_root:
+                        rootdir = ancestor
     return rootdir, inifile, inicfg or {}
 
 

_pytest/debugging.py

@@ -8,21 +8,35 @@ import pytest
 
 def pytest_addoption(parser):
     group = parser.getgroup("general")
-    group._addoption('--pdb',
-               action="store_true", dest="usepdb", default=False,
-               help="start the interactive Python debugger on errors.")
+    group._addoption(
+        '--pdb', dest="usepdb", action="store_true",
+        help="start the interactive Python debugger on errors.")
+    group._addoption(
+        '--pdbcls', dest="usepdb_cls", metavar="modulename:classname",
+        help="start a custom interactive Python debugger on errors. "
+             "For example: --pdbcls=IPython.terminal.debugger:TerminalPdb")
 
 def pytest_namespace():
     return {'set_trace': pytestPDB().set_trace}
 
 def pytest_configure(config):
-    if config.getvalue("usepdb"):
+    if config.getvalue("usepdb") or config.getvalue("usepdb_cls"):
         config.pluginmanager.register(PdbInvoke(), 'pdbinvoke')
+        if config.getvalue("usepdb_cls"):
+            modname, classname = config.getvalue("usepdb_cls").split(":")
+            __import__(modname)
+            pdb_cls = getattr(sys.modules[modname], classname)
+        else:
+            pdb_cls = pdb.Pdb
+        pytestPDB._pdb_cls = pdb_cls
 
     old = (pdb.set_trace, pytestPDB._pluginmanager)
+
     def fin():
         pdb.set_trace, pytestPDB._pluginmanager = old
         pytestPDB._config = None
+        pytestPDB._pdb_cls = pdb.Pdb
+
     pdb.set_trace = pytest.set_trace
     pytestPDB._pluginmanager = config.pluginmanager
     pytestPDB._config = config
@@ -32,6 +46,7 @@ class pytestPDB:
     """ Pseudo PDB that defers to the real pdb. """
     _pluginmanager = None
     _config = None
+    _pdb_cls = pdb.Pdb
 
     def set_trace(self):
         """ invoke PDB set_trace debugging, dropping any IO capturing. """
@@ -45,7 +60,7 @@ class pytestPDB:
             tw.line()
             tw.sep(">", "PDB set_trace (IO-capturing turned off)")
             self._pluginmanager.hook.pytest_enter_pdb(config=self._config)
-        pdb.Pdb().set_trace(frame)
+        self._pdb_cls().set_trace(frame)
 
 
 class PdbInvoke:
@@ -98,7 +113,7 @@ def _find_last_non_hidden_frame(stack):
 
 
 def post_mortem(t):
-    class Pdb(pdb.Pdb):
+    class Pdb(pytestPDB._pdb_cls):
         def get_stack(self, f, t):
             stack, i = pdb.Pdb.get_stack(self, f, t)
             if f is None:

_pytest/deprecated.py

@@ -0,0 +1,24 @@
+"""
+This module contains deprecation messages and bits of code used elsewhere in the codebase
+that is planned to be removed in the next pytest release.
+
+Keeping it in a central location makes it easy to track what is deprecated and should
+be removed when the time comes.
+"""
+
+
+MAIN_STR_ARGS = 'passing a string to pytest.main() is deprecated, ' \
+                      'pass a list of arguments instead.'
+
+YIELD_TESTS = 'yield tests are deprecated, and scheduled to be removed in pytest 4.0'
+
+FUNCARG_PREFIX = (
+    '{name}: declaring fixtures using "pytest_funcarg__" prefix is deprecated '
+    'and scheduled to be removed in pytest 4.0.  '
+    'Please remove the prefix and use the @pytest.fixture decorator instead.')
+
+SETUP_CFG_PYTEST = '[pytest] section in setup.cfg files is deprecated, use [tool:pytest] instead.'
+
+GETFUNCARGVALUE = "use of getfuncargvalue is deprecated, use getfixturevalue"
+
+RESULT_LOG = '--result-log is deprecated and scheduled for removal in pytest 4.0'

_pytest/doctest.py

@@ -4,10 +4,23 @@ from __future__ import absolute_import
 import traceback
 
 import pytest
-from _pytest._code.code import TerminalRepr, ReprFileLocation, ExceptionInfo
-from _pytest.python import FixtureRequest
+from _pytest._code.code import ExceptionInfo, ReprFileLocation, TerminalRepr
+from _pytest.fixtures import FixtureRequest
 
 
+DOCTEST_REPORT_CHOICE_NONE = 'none'
+DOCTEST_REPORT_CHOICE_CDIFF = 'cdiff'
+DOCTEST_REPORT_CHOICE_NDIFF = 'ndiff'
+DOCTEST_REPORT_CHOICE_UDIFF = 'udiff'
+DOCTEST_REPORT_CHOICE_ONLY_FIRST_FAILURE = 'only_first_failure'
+
+DOCTEST_REPORT_CHOICES = (
+    DOCTEST_REPORT_CHOICE_NONE,
+    DOCTEST_REPORT_CHOICE_CDIFF,
+    DOCTEST_REPORT_CHOICE_NDIFF,
+    DOCTEST_REPORT_CHOICE_UDIFF,
+    DOCTEST_REPORT_CHOICE_ONLY_FIRST_FAILURE,
+)
 
 def pytest_addoption(parser):
     parser.addini('doctest_optionflags', 'option flags for doctests',
@@ -17,6 +30,11 @@ def pytest_addoption(parser):
         action="store_true", default=False,
         help="run doctests in all .py modules",
         dest="doctestmodules")
+    group.addoption("--doctest-report",
+        type=str.lower, default="udiff",
+        help="choose another output format for diffs on doctest failure",
+        choices=DOCTEST_REPORT_CHOICES,
+        dest="doctestreport")
     group.addoption("--doctest-glob",
         action="append", default=[], metavar="pat",
         help="doctests file matching pattern, default: test*.txt",
@@ -59,7 +77,6 @@ class ReprFailDoctest(TerminalRepr):
 
 
 class DoctestItem(pytest.Item):
-
     def __init__(self, name, parent, runner=None, dtest=None):
         super(DoctestItem, self).__init__(name, parent)
         self.runner = runner
@@ -70,7 +87,9 @@ class DoctestItem(pytest.Item):
     def setup(self):
         if self.dtest is not None:
             self.fixture_request = _setup_fixtures(self)
-            globs = dict(getfixture=self.fixture_request.getfuncargvalue)
+            globs = dict(getfixture=self.fixture_request.getfixturevalue)
+            for name, value in self.fixture_request.getfixturevalue('doctest_namespace').items():
+                globs[name] = value
             self.dtest.globs.update(globs)
 
     def runtest(self):
@@ -92,7 +111,7 @@ class DoctestItem(pytest.Item):
             message = excinfo.type.__name__
             reprlocation = ReprFileLocation(filename, lineno, message)
             checker = _get_checker()
-            REPORT_UDIFF = doctest.REPORT_UDIFF
+            report_choice = _get_report_choice(self.config.getoption("doctestreport"))
             if lineno is not None:
                 lines = doctestfailure.test.docstring.splitlines(False)
                 # add line numbers to the left of the error message
@@ -108,7 +127,7 @@ class DoctestItem(pytest.Item):
                     indent = '...'
             if excinfo.errisinstance(doctest.DocTestFailure):
                 lines += checker.output_difference(example,
-                        doctestfailure.got, REPORT_UDIFF).split("\n")
+                        doctestfailure.got, report_choice).split("\n")
             else:
                 inner_excinfo = ExceptionInfo(excinfo.value.exc_info)
                 lines += ["UNEXPECTED EXCEPTION: %s" %
@@ -144,20 +163,19 @@ def get_optionflags(parent):
     return flag_acc
 
 
-class DoctestTextfile(DoctestItem, pytest.Module):
+class DoctestTextfile(pytest.Module):
+    obj = None
 
-    def runtest(self):
+    def collect(self):
         import doctest
-        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__'
+        globs = {'__name__': '__main__'}
+
 
         optionflags = get_optionflags(self)
         runner = doctest.DebugRunner(verbose=0, optionflags=optionflags,
@@ -165,8 +183,8 @@ class DoctestTextfile(DoctestItem, pytest.Module):
 
         parser = doctest.DocTestParser()
         test = parser.get_doctest(text, globs, name, filename, 0)
-        _check_all_skipped(test)
-        runner.run(test)
+        if test.examples:
+            yield DoctestItem(test.name, self, runner, test)
 
 
 def _check_all_skipped(test):
@@ -288,3 +306,26 @@ def _get_allow_bytes_flag():
     """
     import doctest
     return doctest.register_optionflag('ALLOW_BYTES')
+
+
+def _get_report_choice(key):
+    """
+    This function returns the actual `doctest` module flag value, we want to do it as late as possible to avoid
+    importing `doctest` and all its dependencies when parsing options, as it adds overhead and breaks tests.
+    """
+    import doctest
+
+    return {
+        DOCTEST_REPORT_CHOICE_UDIFF: doctest.REPORT_UDIFF,
+        DOCTEST_REPORT_CHOICE_CDIFF: doctest.REPORT_CDIFF,
+        DOCTEST_REPORT_CHOICE_NDIFF: doctest.REPORT_NDIFF,
+        DOCTEST_REPORT_CHOICE_ONLY_FIRST_FAILURE: doctest.REPORT_ONLY_FIRST_FAILURE,
+        DOCTEST_REPORT_CHOICE_NONE: 0,
+    }[key]
+
+@pytest.fixture(scope='session')
+def doctest_namespace():
+    """
+    Inject names into the doctest namespace.
+    """
+    return dict()

_pytest/freeze_support.py

@@ -0,0 +1,45 @@
+"""
+Provides a function to report all internal modules for using freezing tools
+pytest
+"""
+
+def pytest_namespace():
+    return {'freeze_includes': freeze_includes}
+
+
+def freeze_includes():
+    """
+    Returns a list of module names used by py.test that should be
+    included by cx_freeze.
+    """
+    import py
+    import _pytest
+    result = list(_iter_all_modules(py))
+    result += list(_iter_all_modules(_pytest))
+    return result
+
+
+def _iter_all_modules(package, prefix=''):
+    """
+    Iterates over the names of all modules that can be found in the given
+    package, recursively.
+    Example:
+        _iter_all_modules(_pytest) ->
+            ['_pytest.assertion.newinterpret',
+             '_pytest.capture',
+             '_pytest.core',
+             ...
+            ]
+    """
+    import os
+    import pkgutil
+    if type(package) is not str:
+        path, prefix = package.__path__[0], package.__name__ + '.'
+    else:
+        path = package
+    for _, name, is_package in pkgutil.iter_modules([path]):
+        if is_package:
+            for m in _iter_all_modules(os.path.join(path, name), prefix=name + '.'):
+                yield prefix + m
+        else:
+            yield prefix + name

_pytest/genscript.py

@@ -1,132 +0,0 @@
-""" (deprecated) generate a single-file self-contained version of pytest """
-import os
-import sys
-import pkgutil
-
-import py
-import _pytest
-
-
-
-def find_toplevel(name):
-    for syspath in sys.path:
-        base = py.path.local(syspath)
-        lib = base/name
-        if lib.check(dir=1):
-            return lib
-        mod = base.join("%s.py" % name)
-        if mod.check(file=1):
-            return mod
-    raise LookupError(name)
-
-def pkgname(toplevel, rootpath, path):
-    parts = path.parts()[len(rootpath.parts()):]
-    return '.'.join([toplevel] + [x.purebasename for x in parts])
-
-def pkg_to_mapping(name):
-    toplevel = find_toplevel(name)
-    name2src = {}
-    if toplevel.check(file=1): # module
-        name2src[toplevel.purebasename] = toplevel.read()
-    else: # package
-        for pyfile in toplevel.visit('*.py'):
-            pkg = pkgname(name, toplevel, pyfile)
-            name2src[pkg] = pyfile.read()
-        # 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):
-    import base64, pickle, zlib
-    data = pickle.dumps(mapping, 2)
-    data = zlib.compress(data, 9)
-    data = base64.encodestring(data)
-    data = data.decode('ascii')
-    return data
-
-
-def compress_packages(names):
-    mapping = {}
-    for name in names:
-        mapping.update(pkg_to_mapping(name))
-    return compress_mapping(mapping)
-
-def generate_script(entry, packages):
-    data = compress_packages(packages)
-    tmpl = py.path.local(__file__).dirpath().join('standalonetemplate.py')
-    exe = tmpl.read()
-    exe = exe.replace('@SOURCES@', data)
-    exe = exe.replace('@ENTRY@', entry)
-    return exe
-
-
-def pytest_addoption(parser):
-    group = parser.getgroup("debugconfig")
-    group.addoption("--genscript", action="store", default=None,
-        dest="genscript", metavar="path",
-        help="create standalone pytest script at given target path.")
-
-def pytest_cmdline_main(config):
-    import _pytest.config
-    genscript = config.getvalue("genscript")
-    if genscript:
-        tw = _pytest.config.create_terminal_writer(config)
-        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++")
-        else:
-            tw.line("WARNING: generated script will not run on python2.6 "
-                    "due to 'argparse' dependency. Use python2.6 "
-                    "to generate a python2.6 compatible script", red=True)
-        script = generate_script(
-            'import pytest; raise SystemExit(pytest.cmdline.main())',
-            deps,
-        )
-        genscript = py.path.local(genscript)
-        genscript.write(script)
-        tw.line("generated pytest standalone script: %s" % genscript,
-                bold=True)
-        return 0
-
-
-def pytest_namespace():
-    return {'freeze_includes': freeze_includes}
-
-
-def freeze_includes():
-    """
-    Returns a list of module names used by py.test that should be
-    included by cx_freeze.
-    """
-    result = list(_iter_all_modules(py))
-    result += list(_iter_all_modules(_pytest))
-    return result
-
-
-def _iter_all_modules(package, prefix=''):
-    """
-    Iterates over the names of all modules that can be found in the given
-    package, recursively.
-
-    Example:
-        _iter_all_modules(_pytest) ->
-            ['_pytest.assertion.newinterpret',
-             '_pytest.capture',
-             '_pytest.core',
-             ...
-            ]
-    """
-    if type(package) is not str:
-        path, prefix = package.__path__[0], package.__name__ + '.'
-    else:
-        path = package
-    for _, name, is_package in pkgutil.iter_modules([path]):
-        if is_package:
-            for m in _iter_all_modules(os.path.join(path, name), prefix=name + '.'):
-                yield prefix + m
-        else:
-            yield prefix + name

_pytest/helpconfig.py

@@ -20,6 +20,10 @@ def pytest_addoption(parser):
     group.addoption('--debug',
                action="store_true", dest="debug", default=False,
                help="store internal tracing debug information in 'pytestdebug.log'.")
+    group._addoption(
+        '-o', '--override-ini', nargs='*', dest="override_ini",
+        action="append",
+        help="override config option with option=value style, e.g. `-o xfail_strict=True`.")
 
 
 @pytest.hookimpl(hookwrapper=True)
@@ -37,12 +41,14 @@ def pytest_cmdline_parse():
         config.trace.root.setwriter(debugfile.write)
         undo_tracing = config.pluginmanager.enable_tracing()
         sys.stderr.write("writing pytestdebug information to %s\n" % path)
+
         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):
@@ -67,9 +73,8 @@ def showhelp(config):
     tw.write(config._parser.optparser.format_help())
     tw.line()
     tw.line()
-    #tw.sep( "=", "config file settings")
-    tw.line("[pytest] ini-options in the next "
-            "pytest.ini|tox.ini|setup.cfg file:")
+    tw.line("[pytest] ini-options in the first "
+            "pytest.ini|tox.ini|setup.cfg file found:")
     tw.line()
 
     for name in config._parser._ininames:
@@ -92,8 +97,8 @@ def showhelp(config):
     tw.line()
     tw.line()
 
-    tw.line("to see available markers type: py.test --markers")
-    tw.line("to see available fixtures type: py.test --fixtures")
+    tw.line("to see available markers type: pytest --markers")
+    tw.line("to see available fixtures type: pytest --fixtures")
     tw.line("(shown according to specified file_or_dir or current dir "
             "if not specified)")
 

_pytest/hookspec.py

@@ -34,7 +34,7 @@ def pytest_addoption(parser):
     .. note::
 
         This function should be implemented only in plugins or ``conftest.py``
-        files situated at the tests root directory due to how py.test
+        files situated at the tests root directory due to how pytest
         :ref:`discovers plugins during startup <pluginorder>`.
 
     :arg parser: To add command line options, call
@@ -156,6 +156,12 @@ def pytest_pyfunc_call(pyfuncitem):
 def pytest_generate_tests(metafunc):
     """ generate (multiple) parametrized calls to a test function."""
 
+@hookspec(firstresult=True)
+def pytest_make_parametrize_id(config, val):
+    """Return a user-friendly string representation of the given ``val`` that will be used
+    by @pytest.mark.parametrize calls. Return None if the hook doesn't know about ``val``.
+    """
+
 # -------------------------------------------------------------------------
 # generic runtest related hooks
 # -------------------------------------------------------------------------
@@ -212,6 +218,19 @@ def pytest_runtest_logreport(report):
     """ process a test setup/call/teardown report relating to
     the respective phase of executing a test. """
 
+# -------------------------------------------------------------------------
+# Fixture related hooks
+# -------------------------------------------------------------------------
+
+@hookspec(firstresult=True)
+def pytest_fixture_setup(fixturedef, request):
+    """ performs fixture setup execution. """
+
+def pytest_fixture_post_finalizer(fixturedef):
+    """ called after fixture teardown, but before the cache is cleared so
+    the fixture result cache ``fixturedef.cached_result`` can
+    still be accessed."""
+
 # -------------------------------------------------------------------------
 # test session related hooks
 # -------------------------------------------------------------------------
@@ -250,7 +269,7 @@ def pytest_report_header(config, startdir):
 def pytest_report_teststatus(report):
     """ return result-category, shortletter and verbose word for reporting."""
 
-def pytest_terminal_summary(terminalreporter):
+def pytest_terminal_summary(terminalreporter, exitstatus):
     """ add additional section in terminal summary reporting.  """
 
 

_pytest/junitxml.py

@@ -8,12 +8,14 @@ Based on initial code from Ross Lawley.
 # Output conforms to https://github.com/jenkinsci/xunit-plugin/blob/master/
 # src/main/resources/org/jenkinsci/plugins/xunit/types/model/xsd/junit-10.xsd
 
+import functools
 import py
 import os
 import re
 import sys
 import time
 import pytest
+from _pytest.config import filename_arg
 
 # Python 2.X and 3.X compatibility
 if sys.version_info[0] < 3:
@@ -27,6 +29,7 @@ else:
 class Junit(py.xml.Namespace):
     pass
 
+
 # We need to get the subset of the invalid unicode ranges according to
 # XML 1.0 which are valid in this python build.  Hence we calculate
 # this dynamically instead of hardcoding it.  The spec range of valid
@@ -118,13 +121,10 @@ class _NodeReporter(object):
 
     def _write_captured_output(self, report):
         for capname in ('out', 'err'):
-            allcontent = ""
-            for name, content in report.get_sections("Captured std%s" %
-                                                     capname):
-                allcontent += content
-            if allcontent:
+            content = getattr(report, 'capstd' + capname)
+            if content:
                 tag = getattr(Junit, 'system-' + capname)
-                self.append(tag(bin_xml_escape(allcontent)))
+                self.append(tag(bin_xml_escape(content)))
 
     def append_pass(self, report):
         self.add_stats('passed')
@@ -159,8 +159,12 @@ class _NodeReporter(object):
             Junit.skipped, "collection skipped", report.longrepr)
 
     def append_error(self, report):
+        if getattr(report, 'when', None) == 'teardown':
+            msg = "test teardown failure"
+        else:
+            msg = "test setup failure"
         self._add_simple(
-            Junit.error, "test setup failure", report.longrepr)
+            Junit.error, msg, report.longrepr)
         self._write_captured_output(report)
 
     def append_skipped(self, report):
@@ -186,8 +190,8 @@ class _NodeReporter(object):
 
 @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
+    """Add extra xml properties to the tag for the calling test.
+    The fixture is callable with ``(name, value)``, with value being automatically
     xml-encoded.
     """
     request.node.warn(
@@ -212,6 +216,7 @@ def pytest_addoption(parser):
         action="store",
         dest="xmlpath",
         metavar="path",
+        type=functools.partial(filename_arg, optname="--junitxml"),
         default=None,
         help="create junit-xml style report file at given path.")
     group.addoption(
@@ -265,6 +270,7 @@ class LogXML(object):
         ], 0)
         self.node_reporters = {}  # nodeid -> _NodeReporter
         self.node_reporters_ordered = []
+        self.global_properties = []
 
     def finalize(self, report):
         nodeid = getattr(report, 'nodeid', report)
@@ -284,9 +290,12 @@ class LogXML(object):
         if key in self.node_reporters:
             # TODO: breasks for --dist=each
             return self.node_reporters[key]
+
         reporter = _NodeReporter(nodeid, self)
+
         self.node_reporters[key] = reporter
         self.node_reporters_ordered.append(reporter)
+
         return reporter
 
     def add_stats(self, key):
@@ -369,10 +378,12 @@ class LogXML(object):
         suite_stop_time = time.time()
         suite_time_delta = suite_stop_time - self.suite_start_time
 
-        numtests = self.stats['passed'] + self.stats['failure'] + self.stats['skipped']
+        numtests = self.stats['passed'] + self.stats['failure'] + self.stats['skipped'] + self.stats['error']
 
         logfile.write('<?xml version="1.0" encoding="utf-8"?>')
+
         logfile.write(Junit.testsuite(
+            self._get_global_properties_node(),
             [x.to_xml() for x in self.node_reporters_ordered],
             name="pytest",
             errors=self.stats['error'],
@@ -385,3 +396,18 @@ class LogXML(object):
     def pytest_terminal_summary(self, terminalreporter):
         terminalreporter.write_sep("-",
                                    "generated xml file: %s" % (self.logfile))
+
+    def add_global_property(self, name, value):
+        self.global_properties.append((str(name), bin_xml_escape(value)))
+
+    def _get_global_properties_node(self):
+        """Return a Junit node containing custom properties, if any.
+        """
+        if self.global_properties:
+            return Junit.properties(
+                    [
+                        Junit.property(name=name, value=value)
+                        for name, value in self.global_properties
+                    ]
+            )
+        return ''

_pytest/main.py

@@ -1,7 +1,6 @@
 """ core implementation of testing process: init, session, runtest loop. """
-import imp
+import functools
 import os
-import re
 import sys
 
 import _pytest
@@ -13,6 +12,7 @@ try:
 except ImportError:
     from UserDict import DictMixin as MappingMixin
 
+from _pytest.config import directory_arg
 from _pytest.runner import collect_one_node
 
 tracebackcutdir = py.path.local(_pytest.__file__).dirpath()
@@ -25,11 +25,9 @@ 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'])
+        type="args", default=['.*', 'build', 'dist', '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",
@@ -38,8 +36,8 @@ def pytest_addoption(parser):
     #            "**/test_*.py", "**/*_test.py"]
     #)
     group = parser.getgroup("general", "running and selection options")
-    group._addoption('-x', '--exitfirst', action="store_true", default=False,
-               dest="exitfirst",
+    group._addoption('-x', '--exitfirst', action="store_const",
+               dest="maxfail", const=1,
                help="exit instantly on first error or failed test."),
     group._addoption('--maxfail', metavar="num",
                action="store", type=int, dest="maxfail", default=0,
@@ -48,6 +46,9 @@ def pytest_addoption(parser):
                help="run pytest in strict mode, warnings become errors.")
     group._addoption("-c", metavar="file", type=str, dest="inifilename",
                help="load configuration from `file` instead of trying to locate one of the implicit configuration files.")
+    group._addoption("--continue-on-collection-errors", action="store_true",
+               default=False, dest="continue_on_collection_errors",
+               help="Force test execution even if collection errors occur.")
 
     group = parser.getgroup("collect", "collection")
     group.addoption('--collectonly', '--collect-only', action="store_true",
@@ -59,11 +60,14 @@ def pytest_addoption(parser):
     # when changing this to --conf-cut-dir, config.py Conftest.setinitial
     # needs upgrading as well
     group.addoption('--confcutdir', dest="confcutdir", default=None,
-        metavar="dir",
+        metavar="dir", type=functools.partial(directory_arg, optname="--confcutdir"),
         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.addoption('--keepduplicates', '--keep-duplicates', action="store_true",
+        dest="keepduplicates", default=False,
+        help="Keep duplicate tests.")
 
     group = parser.getgroup("debugconfig",
         "test session debugging and configuration")
@@ -75,10 +79,10 @@ def pytest_namespace():
     collect = dict(Item=Item, Collector=Collector, File=File, Session=Session)
     return dict(collect=collect)
 
+
 def pytest_configure(config):
     pytest.config = config # compatibiltiy
-    if config.option.exitfirst:
-        config.option.maxfail = 1
+
 
 def wrap_session(config, doit):
     """Skeleton command line program"""
@@ -96,6 +100,10 @@ def wrap_session(config, doit):
             raise
         except KeyboardInterrupt:
             excinfo = _pytest._code.ExceptionInfo()
+            if initstate < 2 and isinstance(
+                    excinfo.value, pytest.exit.Exception):
+                sys.stderr.write('{0}: {1}\n'.format(
+                    excinfo.typename, excinfo.value.msg))
             config.hook.pytest_keyboard_interrupt(excinfo=excinfo)
             session.exitstatus = EXIT_INTERRUPTED
         except:
@@ -133,20 +141,16 @@ def pytest_collection(session):
     return session.perform_collect()
 
 def pytest_runtestloop(session):
+    if (session.testsfailed and
+            not session.config.option.continue_on_collection_errors):
+        raise session.Interrupted(
+            "%d errors during collection" % session.testsfailed)
+
     if session.config.option.collectonly:
         return True
 
-    def getnextitem(i):
-        # this is a function to avoid python2
-        # keeping sys.exc_info set when calling into a test
-        # python2 keeps sys.exc_info till the frame is left
-        try:
-            return session.items[i+1]
-        except IndexError:
-            return None
-
     for i, item in enumerate(session.items):
-        nextitem = getnextitem(i)
+        nextitem = session.items[i+1] if i+1 < len(session.items) else None
         item.config.hook.pytest_runtest_protocol(item=item, nextitem=nextitem)
         if session.shouldstop:
             raise session.Interrupted(session.shouldstop)
@@ -159,7 +163,21 @@ def pytest_ignore_collect(path, config):
     excludeopt = config.getoption("ignore")
     if excludeopt:
         ignore_paths.extend([py.path.local(x) for x in excludeopt])
-    return path in ignore_paths
+
+    if path in ignore_paths:
+        return True
+
+    # Skip duplicate paths.
+    keepduplicates = config.getoption("keepduplicates")
+    duplicate_paths = config.pluginmanager._duplicatepaths
+    if not keepduplicates:
+        if path in duplicate_paths:
+            return True
+        else:
+            duplicate_paths.add(path)
+
+    return False
+
 
 class FSHookProxy:
     def __init__(self, fspath, pm, remove_mods):
@@ -174,7 +192,9 @@ class FSHookProxy:
 
 def compatproperty(name):
     def fget(self):
-        # deprecated - use pytest.name
+        import warnings
+        warnings.warn("This usage is deprecated, please use pytest.{0} instead".format(name),
+                      PendingDeprecationWarning, stacklevel=2)
         return getattr(pytest, name)
 
     return property(fget)
@@ -276,7 +296,7 @@ class Node(object):
         if fslocation is None:
             fslocation = getattr(self, "fspath", None)
         else:
-            fslocation = "%s:%s" % fslocation[:2]
+            fslocation = "%s:%s" % (fslocation[0], fslocation[1] + 1)
 
         self.ihook.pytest_logwarning.call_historic(kwargs=dict(
             code=code, message=message,
@@ -392,7 +412,10 @@ class Node(object):
         if self.config.option.fulltrace:
             style="long"
         else:
+            tb = _pytest._code.Traceback([excinfo.traceback[-1]])
             self._prunetraceback(excinfo)
+            if len(excinfo.traceback) == 0:
+                excinfo.traceback = tb
             tbfilter = False  # prunetraceback already does it
             if style == "auto":
                 style = "long"
@@ -403,7 +426,13 @@ class Node(object):
             else:
                 style = "long"
 
-        return excinfo.getrepr(funcargs=True,
+        try:
+            os.getcwd()
+            abspath = False
+        except OSError:
+            abspath = True
+
+        return excinfo.getrepr(funcargs=True, abspath=abspath,
                                showlocals=self.config.option.showlocals,
                                style=style, tbfilter=tbfilter)
 
@@ -510,7 +539,6 @@ class Session(FSCollector):
     def __init__(self, config):
         FSCollector.__init__(self, config.rootdir, parent=None,
                              config=config, session=self)
-        self._fs2hookproxy = {}
         self.testsfailed = 0
         self.testscollected = 0
         self.shouldstop = False
@@ -541,23 +569,18 @@ class Session(FSCollector):
         return path in self._initialpaths
 
     def gethookproxy(self, fspath):
-        try:
-            return self._fs2hookproxy[fspath]
-        except KeyError:
-            # 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
+        # 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
+        return proxy
 
     def perform_collect(self, args=None, genitems=True):
         hook = self.config.hook
@@ -649,44 +672,39 @@ class Session(FSCollector):
         return True
 
     def _tryconvertpyarg(self, x):
-        mod = None
-        path = [os.path.abspath('.')] + sys.path
-        for name in x.split('.'):
-            # ignore anything that's not a proper name here
-            # else something like --pyargs will mess up '.'
-            # since imp.find_module will actually sometimes work for it
-            # but it's supposed to be considered a filesystem path
-            # not a package
-            if name_re.match(name) is None:
-                return x
-            try:
-                fd, mod, type_ = imp.find_module(name, path)
-            except ImportError:
-                return x
-            else:
-                if fd is not None:
-                    fd.close()
+        """Convert a dotted module name to path.
 
-            if type_[2] != imp.PKG_DIRECTORY:
-                path = [os.path.dirname(mod)]
-            else:
-                path = [mod]
-        return mod
+        """
+        import pkgutil
+        try:
+            loader = pkgutil.find_loader(x)
+        except ImportError:
+            return x
+        if loader is None:
+            return x
+        # This method is sometimes invoked when AssertionRewritingHook, which
+        # does not define a get_filename method, is already in place:
+        try:
+            path = loader.get_filename(x)
+        except AttributeError:
+            # Retrieve path from AssertionRewritingHook:
+            path = loader.modules[x][0].co_filename
+        if loader.is_package(x):
+            path = os.path.dirname(path)
+        return path
 
     def _parsearg(self, arg):
         """ return (fspath, names) tuple after checking the file exists. """
-        arg = str(arg)
-        if self.config.option.pyargs:
-            arg = self._tryconvertpyarg(arg)
         parts = str(arg).split("::")
+        if self.config.option.pyargs:
+            parts[0] = self._tryconvertpyarg(parts[0])
         relpath = parts[0].replace("/", os.sep)
         path = self.config.invocation_dir.join(relpath, abs=True)
         if not path.check():
             if self.config.option.pyargs:
-                msg = "file or package not found: "
+                raise pytest.UsageError("file or package not found: " + arg + " (missing __init__.py?)")
             else:
-                msg = "file not found: "
-            raise pytest.UsageError(msg + arg)
+                raise pytest.UsageError("file not found: " + arg)
         parts[0] = path
         return parts
 

_pytest/mark.py

@@ -19,7 +19,7 @@ def pytest_addoption(parser):
         help="only run tests which match the given substring expression. "
              "An expression is a python evaluatable expression "
              "where all names are substring-matched against test names "
-             "and their parent classes. Example: -k 'test_method or test "
+             "and their parent classes. Example: -k 'test_method or test_"
              "other' matches all test functions and classes whose name "
              "contains 'test_method' or 'test_other'. "
              "Additionally keywords are matched to classes and functions "
@@ -54,6 +54,8 @@ def pytest_cmdline_main(config):
             tw.line()
         config._ensure_unconfigure()
         return 0
+
+
 pytest_cmdline_main.tryfirst = True
 
 
@@ -283,6 +285,21 @@ class MarkDecorator:
         return self.__class__(self.name, args=args, kwargs=kw)
 
 
+def extract_argvalue(maybe_marked_args):
+    # TODO: incorrect mark data, the old code wanst able to collect lists
+    # individual parametrized argument sets can be wrapped in a series
+    # of markers in which case we unwrap the values and apply the mark
+    # at Function init
+    newmarks = {}
+    argval = maybe_marked_args
+    while isinstance(argval, MarkDecorator):
+        newmark = MarkDecorator(argval.markname,
+                                argval.args[:-1], argval.kwargs)
+        newmarks[newmark.markname] = newmark
+        argval = argval.args[-1]
+    return argval, newmarks
+
+
 class MarkInfo:
     """ Marking object created by :class:`MarkDecorator` instances. """
     def __init__(self, name, args, kwargs):

_pytest/monkeypatch.py

@@ -5,11 +5,14 @@ import re
 
 from py.builtin import _basestring
 
+import pytest
+
 RE_IMPORT_ERROR_NAME = re.compile("^No module named (.*)$")
 
 
-def pytest_funcarg__monkeypatch(request):
-    """The returned ``monkeypatch`` funcarg provides these
+@pytest.fixture
+def monkeypatch(request):
+    """The returned ``monkeypatch`` fixture provides these
     helper methods to modify objects, dictionaries or os.environ::
 
         monkeypatch.setattr(obj, name, value, raising=True)
@@ -22,11 +25,11 @@ def pytest_funcarg__monkeypatch(request):
         monkeypatch.chdir(path)
 
     All modifications will be undone after the requesting
-    test function has finished. The ``raising``
+    test function or fixture has finished. The ``raising``
     parameter determines if a KeyError or AttributeError
     will be raised if the set/deletion operation has no target.
     """
-    mpatch = monkeypatch()
+    mpatch = MonkeyPatch()
     request.addfinalizer(mpatch.undo)
     return mpatch
 
@@ -93,8 +96,9 @@ class Notset:
 notset = Notset()
 
 
-class monkeypatch:
-    """ Object keeping a record of setattr/item/env/syspath changes. """
+class MonkeyPatch:
+    """ Object returned by the ``monkeypatch`` fixture keeping a record of setattr/item/env/syspath changes.
+    """
 
     def __init__(self):
         self._setattr = []
@@ -220,10 +224,10 @@ class monkeypatch:
         """ 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.
-        
+
         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,

_pytest/pastebin.py

@@ -11,6 +11,7 @@ def pytest_addoption(parser):
         choices=['failed', 'all'],
         help="send failed|all info to bpaste.net pastebin service.")
 
+
 @pytest.hookimpl(trylast=True)
 def pytest_configure(config):
     import py
@@ -23,13 +24,16 @@ def pytest_configure(config):
             # pastebin file will be utf-8 encoded binary file
             config._pastebinfile = tempfile.TemporaryFile('w+b')
             oldwrite = tr._tw.write
+
             def tee_write(s, **kwargs):
                 oldwrite(s, **kwargs)
                 if py.builtin._istext(s):
                     s = s.encode('utf-8')
                 config._pastebinfile.write(s)
+
             tr._tw.write = tee_write
 
+
 def pytest_unconfigure(config):
     if hasattr(config, '_pastebinfile'):
         # get terminal contents and delete file
@@ -45,6 +49,7 @@ def pytest_unconfigure(config):
         pastebinurl = create_new_paste(sessionlog)
         tr.write_line("pastebin session-log: %s\n" % pastebinurl)
 
+
 def create_new_paste(contents):
     """
     Creates a new paste using bpaste.net service.
@@ -72,6 +77,7 @@ def create_new_paste(contents):
     else:
         return 'bad response: ' + response
 
+
 def pytest_terminal_summary(terminalreporter):
     import _pytest.config
     if terminalreporter.config.option.pastebin != "failed":

_pytest/pytester.py

@@ -16,6 +16,7 @@ from _pytest._code import Source
 import py
 import pytest
 from _pytest.main import Session, EXIT_OK
+from _pytest.assertion.rewrite import AssertionRewritingHook
 
 
 def pytest_addoption(parser):
@@ -123,15 +124,18 @@ def getexecutable(name, cache={}):
     except KeyError:
         executable = py.path.local.sysfind(name)
         if executable:
+            import subprocess
+            popen = subprocess.Popen([str(executable), "--version"],
+                universal_newlines=True, stderr=subprocess.PIPE)
+            out, err = popen.communicate()
             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
+            elif popen.returncode != 0:
+                # Handle pyenv's 127.
+                executable = None
         cache[name] = executable
         return executable
 
@@ -318,7 +322,8 @@ def linecomp(request):
     return LineComp()
 
 
-def pytest_funcarg__LineMatcher(request):
+@pytest.fixture(name='LineMatcher')
+def LineMatcher_fixture(request):
     return LineMatcher
 
 
@@ -374,10 +379,10 @@ class RunResult:
 
 
 class Testdir:
-    """Temporary test directory with tools to test/run py.test itself.
+    """Temporary test directory with tools to test/run pytest itself.
 
     This is based on the ``tmpdir`` fixture but provides a number of
-    methods which aid with testing py.test itself.  Unless
+    methods which aid with testing pytest itself.  Unless
     :py:meth:`chdir` is used all methods will use :py:attr:`tmpdir` as
     current working directory.
 
@@ -473,11 +478,14 @@ class Testdir:
         ret = None
         for name, value in items:
             p = self.tmpdir.join(name).new(ext=ext)
+            p.dirpath().ensure_dir()
             source = Source(value)
+
             def my_totext(s, encoding="utf-8"):
                 if py.builtin._isbytes(s):
                     s = py.builtin._totext(s, encoding=encoding)
                 return s
+
             source_unicode = "\n".join([my_totext(line) for line in source.lines])
             source = py.builtin._totext(source_unicode)
             content = source.strip().encode("utf-8") # + "\n"
@@ -588,7 +596,7 @@ class Testdir:
         """Return the collection node of a file.
 
         This is like :py:meth:`getnode` but uses
-        :py:meth:`parseconfigure` to create the (configured) py.test
+        :py:meth:`parseconfigure` to create the (configured) pytest
         Config instance.
 
         :param path: A :py:class:`py.path.local` instance of the file.
@@ -656,7 +664,7 @@ class Testdir:
         :py:class:`HookRecorder` instance.
 
         This runs the :py:func:`pytest.main` function to run all of
-        py.test inside the test process itself like
+        pytest 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.
 
@@ -669,7 +677,7 @@ class Testdir:
         """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
+        pytest 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`.
@@ -681,9 +689,21 @@ class Testdir:
            ``pytest.main()`` instance should use.
 
         :return: A :py:class:`HookRecorder` instance.
-
         """
+        # When running py.test inline any plugins active in the main
+        # test process are already imported.  So this disables the
+        # warning which will trigger to say they can no longer be
+        # re-written, which is fine as they are already re-written.
+        orig_warn = AssertionRewritingHook._warn_already_imported
+
+        def revert():
+            AssertionRewritingHook._warn_already_imported = orig_warn
+
+        self.request.addfinalizer(revert)
+        AssertionRewritingHook._warn_already_imported = lambda *a: None
+
         rec = []
+
         class Collect:
             def pytest_configure(x, config):
                 rec.append(self.make_hook_recorder(config.pluginmanager))
@@ -718,10 +738,13 @@ class Testdir:
             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:
@@ -755,9 +778,9 @@ class Testdir:
         return args
 
     def parseconfig(self, *args):
-        """Return a new py.test Config instance from given commandline args.
+        """Return a new pytest Config instance from given commandline args.
 
-        This invokes the py.test bootstrapping code in _pytest.config
+        This invokes the pytest 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.
@@ -777,7 +800,7 @@ class Testdir:
         return config
 
     def parseconfigure(self, *args):
-        """Return a new py.test configured Config instance.
+        """Return a new pytest configured Config instance.
 
         This returns a new :py:class:`_pytest.config.Config` instance
         like :py:meth:`parseconfig`, but also calls the
@@ -792,7 +815,7 @@ class Testdir:
     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
+        This writes the source to a python file and runs pytest's
         collection on the resulting module, returning the test item
         for the requested function name.
 
@@ -812,7 +835,7 @@ class Testdir:
     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
+        This writes the source to a python file and runs pytest's
         collection on the resulting module, returning all test items
         contained within.
 
@@ -824,7 +847,7 @@ class Testdir:
         """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
+        and then runs the pytest collection on it, returning the
         collection node for the test module.
 
         :param source: The source code of the module to collect.
@@ -924,7 +947,7 @@ class Testdir:
 
     def _getpytestargs(self):
         # we cannot use "(sys.executable,script)"
-        # because on windows the script is e.g. a py.test.exe
+        # because on windows the script is e.g. a pytest.exe
         return (sys.executable, _pytest_fullpath,) # noqa
 
     def runpython(self, script):
@@ -939,7 +962,7 @@ class Testdir:
         return self.run(sys.executable, "-c", command)
 
     def runpytest_subprocess(self, *args, **kwargs):
-        """Run py.test as a subprocess with given arguments.
+        """Run pytest as a subprocess with given arguments.
 
         Any plugins added to the :py:attr:`plugins` list will added
         using the ``-p`` command line option.  Addtionally
@@ -967,9 +990,9 @@ class Testdir:
         return self.run(*args)
 
     def spawn_pytest(self, string, expect_timeout=10.0):
-        """Run py.test using pexpect.
+        """Run pytest using pexpect.
 
-        This makes sure to use the right py.test and sets up the
+        This makes sure to use the right pytest and sets up the
         temporary directory locations.
 
         The pexpect child is returned.
@@ -988,8 +1011,6 @@ class Testdir:
         pexpect = pytest.importorskip("pexpect", "3.0")
         if hasattr(sys, 'pypy_version_info') and '64' in platform.machine():
             pytest.skip("pypy-64 bit not supported")
-        if sys.platform == "darwin":
-            pytest.xfail("pexpect does not work reliably on darwin?!")
         if sys.platform.startswith("freebsd"):
             pytest.xfail("pexpect does not work reliably on freebsd")
         logfile = self.tmpdir.join("spawn.out").open("wb")
@@ -1035,6 +1056,7 @@ class LineMatcher:
 
     def __init__(self,  lines):
         self.lines = lines
+        self._log_output = []
 
     def str(self):
         """Return the entire original text."""
@@ -1058,10 +1080,11 @@ class LineMatcher:
         for line in lines2:
             for x in self.lines:
                 if line == x or fnmatch(x, line):
-                    print_("matched: ", repr(line))
+                    self._log("matched: ", repr(line))
                     break
             else:
-                raise ValueError("line %r not found in output" % line)
+                self._log("line %r not found in output" % line)
+                raise ValueError(self._log_text)
 
     def get_lines_after(self, fnline):
         """Return all lines following the given line in the text.
@@ -1073,6 +1096,13 @@ class LineMatcher:
                 return self.lines[i+1:]
         raise ValueError("line %r not found in output" % fnline)
 
+    def _log(self, *args):
+        self._log_output.append(' '.join((str(x) for x in args)))
+
+    @property
+    def _log_text(self):
+        return '\n'.join(self._log_output)
+
     def fnmatch_lines(self, lines2):
         """Search the text for matching lines.
 
@@ -1082,8 +1112,6 @@ class LineMatcher:
         stdout.
 
         """
-        def show(arg1, arg2):
-            py.builtin.print_(arg1, arg2, file=sys.stderr)
         lines2 = self._getlines(lines2)
         lines1 = self.lines[:]
         nextline = None
@@ -1094,17 +1122,18 @@ class LineMatcher:
             while lines1:
                 nextline = lines1.pop(0)
                 if line == nextline:
-                    show("exact match:", repr(line))
+                    self._log("exact match:", repr(line))
                     break
                 elif fnmatch(nextline, line):
-                    show("fnmatch:", repr(line))
-                    show("   with:", repr(nextline))
+                    self._log("fnmatch:", repr(line))
+                    self._log("   with:", repr(nextline))
                     break
                 else:
                     if not nomatchprinted:
-                        show("nomatch:", repr(line))
+                        self._log("nomatch:", repr(line))
                         nomatchprinted = True
-                    show("    and:", repr(nextline))
+                    self._log("    and:", repr(nextline))
                 extralines.append(nextline)
             else:
-                pytest.fail("remains unmatched: %r, see stderr" % (line,))
+                self._log("remains unmatched: %r" % (line,))
+                pytest.fail(self._log_text)

_pytest/recwarn.py

@@ -36,8 +36,13 @@ def deprecated_call(func=None, *args, **kwargs):
 
     This function can be used as a context manager::
 
+        >>> import warnings
+        >>> def api_call_v2():
+        ...     warnings.warn('use v3 of this api', DeprecationWarning)
+        ...     return 200
+
         >>> with deprecated_call():
-        ...    myobject.deprecated_method()
+        ...    assert api_call_v2() == 200
 
     Note: we cannot use WarningsRecorder here because it is still subject
     to the mechanism that prevents warnings of the same type from being

_pytest/resultlog.py

@@ -9,7 +9,7 @@ def pytest_addoption(parser):
     group = parser.getgroup("terminal reporting", "resultlog plugin options")
     group.addoption('--resultlog', '--result-log', action="store",
         metavar="path", default=None,
-        help="path for machine-readable result log.")
+        help="DEPRECATED path for machine-readable result log.")
 
 def pytest_configure(config):
     resultlog = config.option.resultlog
@@ -22,6 +22,9 @@ def pytest_configure(config):
         config._resultlog = ResultLog(config, logfile)
         config.pluginmanager.register(config._resultlog)
 
+        from _pytest.deprecated import RESULT_LOG
+        config.warn('C1', RESULT_LOG)
+
 def pytest_unconfigure(config):
     resultlog = getattr(config, '_resultlog', None)
     if resultlog:

_pytest/runner.py

@@ -73,7 +73,10 @@ def runtestprotocol(item, log=True, nextitem=None):
     rep = call_and_report(item, "setup", log)
     reports = [rep]
     if rep.passed:
-        reports.append(call_and_report(item, "call", log))
+        if item.config.option.setupshow:
+            show_test_item(item)
+        if not item.config.option.setuponly:
+            reports.append(call_and_report(item, "call", log))
     reports.append(call_and_report(item, "teardown", log,
         nextitem=nextitem))
     # after all teardown hooks have been called
@@ -83,6 +86,16 @@ def runtestprotocol(item, log=True, nextitem=None):
         item.funcargs = None
     return reports
 
+def show_test_item(item):
+    """Show test function, parameters and the fixtures of the test item."""
+    tw = item.config.get_terminal_writer()
+    tw.line()
+    tw.write(' ' * 8)
+    tw.write(item._nodeid)
+    used_fixtures = sorted(item._fixtureinfo.name2fixturedefs.keys())
+    if used_fixtures:
+        tw.write(' (fixtures used: {0})'.format(', '.join(used_fixtures)))
+
 def pytest_runtest_setup(item):
     item.session._setupstate.prepare(item)
 
@@ -198,6 +211,36 @@ class BaseReport(object):
             if name.startswith(prefix):
                 yield prefix, content
 
+    @property
+    def longreprtext(self):
+        """
+        Read-only property that returns the full string representation
+        of ``longrepr``.
+
+        .. versionadded:: 3.0
+        """
+        tw = py.io.TerminalWriter(stringio=True)
+        tw.hasmarkup = False
+        self.toterminal(tw)
+        exc = tw.stringio.getvalue()
+        return exc.strip()
+
+    @property
+    def capstdout(self):
+        """Return captured text from stdout, if capturing is enabled
+
+        .. versionadded:: 3.0
+        """
+        return ''.join(content for (prefix, content) in self.get_sections('Captured stdout'))
+
+    @property
+    def capstderr(self):
+        """Return captured text from stderr, if capturing is enabled
+
+        .. versionadded:: 3.0
+        """
+        return ''.join(content for (prefix, content) in self.get_sections('Captured stderr'))
+
     passed = property(lambda x: x.outcome == "passed")
     failed = property(lambda x: x.outcome == "failed")
     skipped = property(lambda x: x.outcome == "skipped")
@@ -263,8 +306,10 @@ class TestReport(BaseReport):
         #: one of 'setup', 'call', 'teardown' to indicate runtest phase.
         self.when = when
 
-        #: list of (secname, data) extra information which needs to
-        #: marshallable
+        #: list of pairs ``(str, str)`` of extra information which needs to
+        #: marshallable. Used by pytest to add captured text
+        #: from ``stdout`` and ``stderr``, but may be used by other plugins
+        #: to add arbitrary information to reports.
         self.sections = list(sections)
 
         #: time it took to run just the test
@@ -447,10 +492,16 @@ class Skipped(OutcomeException):
     # in order to have Skipped exception printing shorter/nicer
     __module__ = 'builtins'
 
+    def __init__(self, msg=None, pytrace=True, allow_module_level=False):
+        OutcomeException.__init__(self, msg=msg, pytrace=pytrace)
+        self.allow_module_level = allow_module_level
+
+
 class Failed(OutcomeException):
     """ raised from an explicit call to pytest.fail() """
     __module__ = 'builtins'
 
+
 class Exit(KeyboardInterrupt):
     """ raised for immediate program exits (no tracebacks/summaries)"""
     def __init__(self, msg="unknown reason"):
@@ -464,8 +515,10 @@ def exit(msg):
     __tracebackhide__ = True
     raise Exit(msg)
 
+
 exit.Exception = Exit
 
+
 def skip(msg=""):
     """ skip an executing test with the given message.  Note: it's usually
     better to use the pytest.mark.skipif marker to declare a test to be
@@ -474,8 +527,11 @@ def skip(msg=""):
     """
     __tracebackhide__ = True
     raise Skipped(msg=msg)
+
+
 skip.Exception = Skipped
 
+
 def fail(msg="", pytrace=True):
     """ explicitly fail an currently-executing test with the given Message.
 
@@ -484,6 +540,8 @@ def fail(msg="", pytrace=True):
     """
     __tracebackhide__ = True
     raise Failed(msg=msg, pytrace=pytrace)
+
+
 fail.Exception = Failed
 
 
@@ -494,10 +552,14 @@ def importorskip(modname, minversion=None):
     """
     __tracebackhide__ = True
     compile(modname, '', 'eval') # to catch syntaxerrors
+    should_skip = False
     try:
         __import__(modname)
     except ImportError:
-        skip("could not import %r" %(modname,))
+        # Do not raise chained exception here(#1485)
+        should_skip = True
+    if should_skip:
+        raise Skipped("could not import %r" %(modname,), allow_module_level=True)
     mod = sys.modules[modname]
     if minversion is None:
         return mod
@@ -506,10 +568,11 @@ def importorskip(modname, minversion=None):
         try:
             from pkg_resources import parse_version as pv
         except ImportError:
-            skip("we have a required version for %r but can not import "
-                 "no pkg_resources to parse version strings." %(modname,))
+            raise Skipped("we have a required version for %r but can not import "
+                          "pkg_resources to parse version strings." % (modname,),
+                          allow_module_level=True)
         if verattr is None or pv(verattr) < pv(minversion):
-            skip("module %r has __version__ %r, required is: %r" %(
-                 modname, verattr, minversion))
+            raise Skipped("module %r has __version__ %r, required is: %r" %(
+                          modname, verattr, minversion), allow_module_level=True)
     return mod
 

_pytest/setuponly.py

@@ -0,0 +1,72 @@
+import pytest
+import sys
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("debugconfig")
+    group.addoption('--setuponly', '--setup-only', action="store_true",
+                    help="only setup fixtures, do not execute tests.")
+    group.addoption('--setupshow', '--setup-show', action="store_true",
+                    help="show setup of fixtures while executing tests.")
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_fixture_setup(fixturedef, request):
+    yield
+    config = request.config
+    if config.option.setupshow:
+        if hasattr(request, 'param'):
+            # Save the fixture parameter so ._show_fixture_action() can
+            # display it now and during the teardown (in .finish()).
+            if fixturedef.ids:
+                if callable(fixturedef.ids):
+                    fixturedef.cached_param = fixturedef.ids(request.param)
+                else:
+                    fixturedef.cached_param = fixturedef.ids[
+                        request.param_index]
+            else:
+                fixturedef.cached_param = request.param
+        _show_fixture_action(fixturedef, 'SETUP')
+
+
+def pytest_fixture_post_finalizer(fixturedef):
+    if hasattr(fixturedef, "cached_result"):
+        config = fixturedef._fixturemanager.config
+        if config.option.setupshow:
+            _show_fixture_action(fixturedef, 'TEARDOWN')
+            if hasattr(fixturedef, "cached_param"):
+                del fixturedef.cached_param
+
+
+def _show_fixture_action(fixturedef, msg):
+    config = fixturedef._fixturemanager.config
+    capman = config.pluginmanager.getplugin('capturemanager')
+    if capman:
+        out, err = capman.suspendcapture()
+
+    tw = config.get_terminal_writer()
+    tw.line()
+    tw.write(' ' * 2 * fixturedef.scopenum)
+    tw.write('{step} {scope} {fixture}'.format(
+        step=msg.ljust(8),  # align the output to TEARDOWN
+        scope=fixturedef.scope[0].upper(),
+        fixture=fixturedef.argname))
+
+    if msg == 'SETUP':
+        deps = sorted(arg for arg in fixturedef.argnames if arg != 'request')
+        if deps:
+            tw.write(' (fixtures used: {0})'.format(', '.join(deps)))
+
+    if hasattr(fixturedef, 'cached_param'):
+        tw.write('[{0}]'.format(fixturedef.cached_param))
+
+    if capman:
+        capman.resumecapture()
+        sys.stdout.write(out)
+        sys.stderr.write(err)
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_cmdline_main(config):
+    if config.option.setuponly:
+        config.option.setupshow = True

_pytest/setupplan.py

@@ -0,0 +1,23 @@
+import pytest
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("debugconfig")
+    group.addoption('--setupplan', '--setup-plan', action="store_true",
+                    help="show what fixtures and tests would be executed but "
+                    "don't execute anything.")
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_fixture_setup(fixturedef, request):
+    # Will return a dummy fixture if the setuponly option is provided.
+    if request.config.option.setupplan:
+        fixturedef.cached_result = (None, None, None)
+        return fixturedef.cached_result
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_cmdline_main(config):
+    if config.option.setupplan:
+        config.option.setuponly = True
+        config.option.setupshow = True

_pytest/skipping.py

@@ -25,8 +25,10 @@ def pytest_configure(config):
     if config.option.runxfail:
         old = pytest.xfail
         config._cleanup.append(lambda: setattr(pytest, "xfail", old))
+
         def nop(*args, **kwargs):
             pass
+
         nop.Exception = XFailed
         setattr(pytest, "xfail", nop)
 
@@ -65,6 +67,8 @@ def xfail(reason=""):
     """ xfail an executing test or setup functions with the given reason."""
     __tracebackhide__ = True
     raise XFailed(reason)
+
+
 xfail.Exception = XFailed
 
 
@@ -108,11 +112,7 @@ class MarkEvaluator:
 
     def _getglobals(self):
         d = {'os': os, 'sys': sys, 'config': self.item.config}
-        func = self.item.obj
-        try:
-            d.update(func.__globals__)
-        except AttributeError:
-            d.update(func.func_globals)
+        d.update(self.item.obj.__globals__)
         return d
 
     def _istrue(self):
@@ -228,9 +228,16 @@ def pytest_runtest_makereport(item, call):
     evalskip = getattr(item, '_evalskip', None)
     # unitttest special case, see setting of _unexpectedsuccess
     if hasattr(item, '_unexpectedsuccess') and rep.when == "call":
-        # we need to translate into how pytest encodes xpass
-        rep.wasxfail = "reason: " + repr(item._unexpectedsuccess)
-        rep.outcome = "failed"
+        from _pytest.compat import _is_unittest_unexpected_success_a_failure
+        if item._unexpectedsuccess:
+            rep.longrepr = "Unexpected success: {0}".format(item._unexpectedsuccess)
+        else:
+            rep.longrepr = "Unexpected success"
+        if _is_unittest_unexpected_success_a_failure():
+            rep.outcome = "failed"
+        else:
+            rep.outcome = "passed"
+            rep.wasxfail = rep.longrepr
     elif item.config.option.runxfail:
         pass   # don't interefere
     elif call.excinfo and call.excinfo.errisinstance(pytest.xfail.Exception):
@@ -245,8 +252,15 @@ def pytest_runtest_makereport(item, call):
                 rep.outcome = "skipped"
                 rep.wasxfail = evalxfail.getexplanation()
         elif call.when == "call":
-            rep.outcome = "failed"  # xpass outcome
-            rep.wasxfail = evalxfail.getexplanation()
+            strict_default = item.config.getini('xfail_strict')
+            is_strict_xfail = evalxfail.get('strict', strict_default)
+            explanation = evalxfail.getexplanation()
+            if is_strict_xfail:
+                rep.outcome = "failed"
+                rep.longrepr = "[XPASS(strict)] {0}".format(explanation)
+            else:
+                rep.outcome = "passed"
+                rep.wasxfail = explanation
     elif evalskip is not None and rep.skipped and type(rep.longrepr) is tuple:
         # skipped by mark.skipif; change the location of the failure
         # to point to the item definition, otherwise it will display
@@ -260,7 +274,7 @@ def pytest_report_teststatus(report):
     if hasattr(report, "wasxfail"):
         if report.skipped:
             return "xfailed", "x", "xfail"
-        elif report.failed:
+        elif report.passed:
             return "xpassed", "X", ("XPASS", {'yellow': True})
 
 # called by the terminalreporter instance/plugin

_pytest/standalonetemplate.py

@@ -1,89 +0,0 @@
-#! /usr/bin/env python
-
-# Hi There!
-# You may be wondering what this giant blob of binary data here is, you might
-# even be worried that we're up to something nefarious (good for you for being
-# paranoid!). This is a base64 encoding of a zip file, this zip file contains
-# a fully functional basic pytest script.
-#
-# Pytest is a thing that tests packages, pytest itself is a package that some-
-# one might want to install, especially if they're looking to run tests inside
-# some package they want to install. Pytest has a lot of code to collect and
-# execute tests, and other such sort of "tribal knowledge" that has been en-
-# coded in its code base. Because of this we basically include a basic copy
-# of pytest inside this blob. We do this  because it let's you as a maintainer
-# or application developer who wants people who don't deal with python much to
-# easily run tests without installing the complete pytest package.
-#
-# If you're wondering how this is created: you can create it yourself if you
-# have a complete pytest installation by using this command on the command-
-# line: ``py.test --genscript=runtests.py``.
-
-sources = """
-@SOURCES@"""
-
-import sys
-import base64
-import zlib
-
-class DictImporter(object):
-    def __init__(self, sources):
-        self.sources = sources
-
-    def find_module(self, fullname, path=None):
-        if fullname == "argparse" and sys.version_info >= (2,7):
-            # we were generated with <python2.7 (which pulls in argparse)
-            # but we are running now on a stdlib which has it, so use that.
-            return None
-        if fullname in self.sources:
-            return self
-        if fullname + '.__init__' in self.sources:
-            return self
-        return None
-
-    def load_module(self, fullname):
-        # print "load_module:",  fullname
-        from types import ModuleType
-        try:
-            s = self.sources[fullname]
-            is_pkg = False
-        except KeyError:
-            s = self.sources[fullname + '.__init__']
-            is_pkg = True
-
-        co = compile(s, fullname, 'exec')
-        module = sys.modules.setdefault(fullname, ModuleType(fullname))
-        module.__file__ = "%s/%s" % (__file__, fullname)
-        module.__loader__ = self
-        if is_pkg:
-            module.__path__ = [fullname]
-
-        do_exec(co, module.__dict__) # noqa
-        return sys.modules[fullname]
-
-    def get_source(self, name):
-        res = self.sources.get(name)
-        if res is None:
-            res = self.sources.get(name + '.__init__')
-        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
-        sources = sources.encode("ascii") # ensure bytes
-        sources = pickle.loads(zlib.decompress(base64.decodebytes(sources)))
-    else:
-        import cPickle as pickle
-        exec("def do_exec(co, loc): exec co in loc\n")
-        sources = pickle.loads(zlib.decompress(base64.decodestring(sources)))
-
-    importer = DictImporter(sources)
-    sys.meta_path.insert(0, importer)
-    entry = "@ENTRY@"
-    do_exec(entry, locals()) # noqa

_pytest/terminal.py

@@ -20,16 +20,18 @@ def pytest_addoption(parser):
     group._addoption('-q', '--quiet', action="count",
                dest="quiet", default=0, help="decrease verbosity."),
     group._addoption('-r',
-         action="store", dest="reportchars", default=None, metavar="chars",
+         action="store", dest="reportchars", default='', metavar="chars",
          help="show extra test summary info as specified by chars (f)ailed, "
-              "(E)error, (s)skipped, (x)failed, (X)passed (w)pytest-warnings "
-              "(p)passed, (P)passed with output, (a)all except pP.")
+              "(E)error, (s)skipped, (x)failed, (X)passed, "
+              "(p)passed, (P)passed with output, (a)all except pP. "
+              "The pytest warnings are displayed at all times except when "
+              "--disable-pytest-warnings is set")
+    group._addoption('--disable-pytest-warnings', default=False,
+                     dest='disablepytestwarnings', action='store_true',
+                     help='disable warnings summary, overrides -r w flag')
     group._addoption('-l', '--showlocals',
          action="store_true", dest="showlocals", default=False,
          help="show locals in tracebacks (disabled by default).")
-    group._addoption('--report',
-         action="store", dest="report", default=None, metavar="opts",
-         help="(deprecated, use -r)")
     group._addoption('--tb', metavar="style",
                action="store", dest="tbstyle", default='auto',
                choices=['auto', 'long', 'short', 'no', 'line', 'native'],
@@ -54,18 +56,11 @@ def pytest_configure(config):
 
 def getreportopt(config):
     reportopts = ""
-    optvalue = config.option.report
-    if optvalue:
-        py.builtin.print_("DEPRECATED: use -r instead of --report option.",
-            file=sys.stderr)
-        if optvalue:
-            for setting in optvalue.split(","):
-                setting = setting.strip()
-                if setting == "skipped":
-                    reportopts += "s"
-                elif setting == "xfailed":
-                    reportopts += "x"
     reportchars = config.option.reportchars
+    if not config.option.disablepytestwarnings and 'w' not in reportchars:
+        reportchars += 'w'
+    elif config.option.disablepytestwarnings and 'w' in reportchars:
+        reportchars = reportchars.replace('w', '')
     if reportchars:
         for char in reportchars:
             if char not in reportopts and char != 'a':
@@ -366,7 +361,8 @@ class TerminalReporter:
             EXIT_OK, EXIT_TESTSFAILED, EXIT_INTERRUPTED, EXIT_USAGEERROR,
             EXIT_NOTESTSCOLLECTED)
         if exitstatus in summary_exit_codes:
-            self.config.hook.pytest_terminal_summary(terminalreporter=self)
+            self.config.hook.pytest_terminal_summary(terminalreporter=self,
+                                                     exitstatus=exitstatus)
             self.summary_errors()
             self.summary_failures()
             self.summary_warnings()
@@ -462,6 +458,15 @@ class TerminalReporter:
                     self.write_sep("_", msg)
                     self._outrep_summary(rep)
 
+    def print_teardown_sections(self, rep):
+        for secname, content in rep.sections:
+            if 'teardown' in secname:
+                self._tw.sep('-', secname)
+                if content[-1:] == "\n":
+                    content = content[:-1]
+                self._tw.line(content)
+
+
     def summary_failures(self):
         if self.config.option.tbstyle != "no":
             reports = self.getreports('failed')
@@ -477,6 +482,9 @@ class TerminalReporter:
                     markup = {'red': True, 'bold': True}
                     self.write_sep("_", msg, **markup)
                     self._outrep_summary(rep)
+                    for report in self.getreports(''):
+                        if report.nodeid == rep.nodeid and report.when == 'teardown':
+                            self.print_teardown_sections(report)
 
     def summary_errors(self):
         if self.config.option.tbstyle != "no":
@@ -517,16 +525,8 @@ class TerminalReporter:
 
     def summary_deselected(self):
         if 'deselected' in self.stats:
-            l = []
-            k = self.config.option.keyword
-            if k:
-                l.append("-k%s" % k)
-            m = self.config.option.markexpr
-            if m:
-                l.append("-m %r" % m)
-            if l:
-                self.write_sep("=", "%d tests deselected by %r" % (
-                    len(self.stats['deselected']), " ".join(l)), bold=True)
+            self.write_sep("=", "%d tests deselected" % (
+                len(self.stats['deselected'])), bold=True)
 
 def repr_pythonversion(v=None):
     if v is None:

_pytest/tmpdir.py

@@ -3,7 +3,7 @@ import re
 
 import pytest
 import py
-from _pytest.monkeypatch import monkeypatch
+from _pytest.monkeypatch import MonkeyPatch
 
 
 class TempdirFactory:
@@ -81,6 +81,7 @@ def get_user():
     except (ImportError, KeyError):
         return None
 
+
 # backward compatibility
 TempdirHandler = TempdirFactory
 
@@ -92,7 +93,7 @@ def pytest_configure(config):
     available at pytest_configure time, but ideally should be moved entirely
     to the tmpdir_factory session fixture.
     """
-    mp = monkeypatch()
+    mp = MonkeyPatch()
     t = TempdirFactory(config)
     config._cleanup.extend([mp.undo, t.finish])
     mp.setattr(config, '_tmpdirhandler', t, raising=False)
@@ -108,7 +109,7 @@ def tmpdir_factory(request):
 
 @pytest.fixture
 def tmpdir(request, tmpdir_factory):
-    """return a temporary directory path object
+    """Return a temporary directory path object
     which is unique to each test function invocation,
     created as a sub directory of the base temporary
     directory.  The returned object is a `py.path.local`_

_pytest/unittest.py

@@ -50,6 +50,8 @@ class UnitTestCase(pytest.Class):
         foundsomething = False
         for name in loader.getTestCaseNames(self.obj):
             x = getattr(self.obj, name)
+            if not getattr(x, '__test__', True):
+                continue
             funcobj = getattr(x, 'im_func', x)
             transfer_markers(funcobj, cls, module)
             yield TestCaseFunction(name, parent=self)
@@ -92,6 +94,9 @@ class TestCaseFunction(pytest.Function):
     def teardown(self):
         if hasattr(self._testcase, 'teardown_method'):
             self._testcase.teardown_method(self._obj)
+        # Allow garbage collection on TestCase instance attributes.
+        self._testcase = None
+        self._obj = None
 
     def startTest(self, testcase):
         pass
@@ -148,7 +153,12 @@ class TestCaseFunction(pytest.Function):
         pass
 
     def runtest(self):
-        self._testcase(result=self)
+        if self.config.pluginmanager.get_plugin("pdbinvoke") is None:
+            self._testcase(result=self)
+        else:
+            # disables tearDown and cleanups for post mortem debugging (see #1890)
+            self._testcase.debug()
+
 
     def _prunetraceback(self, excinfo):
         pytest.Function._prunetraceback(self, excinfo)
@@ -176,6 +186,7 @@ def pytest_runtest_protocol(item):
         ut = sys.modules['twisted.python.failure']
         Failure__init__ = ut.Failure.__init__
         check_testcase_implements_trial_reporter()
+
         def excstore(self, exc_value=None, exc_type=None, exc_tb=None,
             captureVars=None):
             if exc_value is None:
@@ -189,6 +200,7 @@ def pytest_runtest_protocol(item):
                     captureVars=captureVars)
             except TypeError:
                 Failure__init__(self, exc_value, exc_type, exc_tb)
+
         ut.Failure.__init__ = excstore
         yield
         ut.Failure.__init__ = Failure__init__

_pytest/vendored_packages/README.md

@@ -10,4 +10,4 @@ $ pip install -U pluggy==<version> --no-compile --target=_pytest/vendored_packag
 ```
 
 And commit the modified files. The `pluggy-<version>.dist-info` directory 
-created by `pip` should be ignored.
+created by `pip` should be added as well.

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

@@ -1,8 +0,0 @@
-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/metadata.json

@@ -1 +0,0 @@
-{"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

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

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

@@ -1,3 +1,4 @@
+
 Plugin registration and hook calling for Python
 ===============================================
 

_pytest/vendored_packages/pluggy-0.4.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

_pytest/vendored_packages/pluggy-0.4.0.dist-info/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 holger krekel (rather uses bitbucket/hpk42) 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

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

@@ -1,8 +1,8 @@
 Metadata-Version: 2.0
 Name: pluggy
-Version: 0.3.1
+Version: 0.4.0
 Summary: plugin and hook calling mechanisms for python
-Home-page: UNKNOWN
+Home-page: https://github.com/pytest-dev/pluggy
 Author: Holger Krekel
 Author-email: holger at merlinux.eu
 License: MIT license
@@ -27,6 +27,7 @@ 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
 ===============================================
 

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

@@ -0,0 +1,9 @@
+pluggy.py,sha256=u0oG9cv-oLOkNvEBlwnnu8pp1AyxpoERgUO00S3rvpQ,31543
+pluggy-0.4.0.dist-info/DESCRIPTION.rst,sha256=ltvjkFd40LW_xShthp6RRVM6OB_uACYDFR3kTpKw7o4,307
+pluggy-0.4.0.dist-info/LICENSE.txt,sha256=ruwhUOyV1HgE9F35JVL9BCZ9vMSALx369I4xq9rhpkM,1134
+pluggy-0.4.0.dist-info/METADATA,sha256=pe2hbsqKFaLHC6wAQPpFPn0KlpcPfLBe_BnS4O70bfk,1364
+pluggy-0.4.0.dist-info/RECORD,,
+pluggy-0.4.0.dist-info/WHEEL,sha256=9Z5Xm-eel1bTS7e6ogYiKz0zmPEqDwIypurdHN1hR40,116
+pluggy-0.4.0.dist-info/metadata.json,sha256=T3go5L2qOa_-H-HpCZi3EoVKb8sZ3R-fOssbkWo2nvM,1119
+pluggy-0.4.0.dist-info/top_level.txt,sha256=xKSCRhai-v9MckvMuWqNz16c1tbsmOggoMSwTgcpYHE,7
+pluggy-0.4.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4

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

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

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

@@ -0,0 +1 @@
+{"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"], "extensions": {"python.details": {"contacts": [{"email": "holger at merlinux.eu", "name": "Holger Krekel", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst", "license": "LICENSE.txt"}, "project_urls": {"Home": "https://github.com/pytest-dev/pluggy"}}}, "generator": "bdist_wheel (0.29.0)", "license": "MIT license", "metadata_version": "2.0", "name": "pluggy", "platform": "unix", "summary": "plugin and hook calling mechanisms for python", "version": "0.4.0"}

_pytest/vendored_packages/pluggy.py

@@ -67,8 +67,9 @@ Pluggy currently consists of functionality for:
 import sys
 import inspect
 
-__version__ = '0.3.1'
-__all__ = ["PluginManager", "PluginValidationError",
+__version__ = '0.4.0'
+
+__all__ = ["PluginManager", "PluginValidationError", "HookCallError",
            "HookspecMarker", "HookimplMarker"]
 
 _py3 = sys.version_info > (3, 0)
@@ -308,7 +309,7 @@ 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 new hooks by calling ``add_hookspec(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
@@ -374,7 +375,10 @@ class PluginManager(object):
 
     def parse_hookimpl_opts(self, plugin, name):
         method = getattr(plugin, name)
-        res = getattr(method, self.project_name + "_impl", None)
+        try:
+            res = getattr(method, self.project_name + "_impl", None)
+        except Exception:
+            res = {}
         if res is not None and not isinstance(res, dict):
             # false positive
             res = None
@@ -455,6 +459,10 @@ class PluginManager(object):
         """ Return a plugin or None for the given name. """
         return self._name2plugin.get(name)
 
+    def has_plugin(self, name):
+        """ Return True if a plugin with the given name is registered. """
+        return self.get_plugin(name) is not None
+
     def get_name(self, plugin):
         """ Return name for registered plugin or None if not registered. """
         for name, val in self._name2plugin.items():
@@ -492,7 +500,8 @@ class PluginManager(object):
     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
+        from pkg_resources import (iter_entry_points, DistributionNotFound,
+                                   VersionConflict)
         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):
@@ -501,6 +510,9 @@ class PluginManager(object):
                 plugin = ep.load()
             except DistributionNotFound:
                 continue
+            except VersionConflict as e:
+                raise PluginValidationError(
+                    "Plugin %r could not be loaded: %s!" % (ep.name, e))
             self.register(plugin, name=ep.name)
             self._plugin_distinfo.append((plugin, ep.dist))
         return len(self._plugin_distinfo)
@@ -573,7 +585,7 @@ class _MultiCall:
 
     # XXX note that the __multicall__ argument is supported only
     # for pytest compatibility reasons.  It was never officially
-    # supported there and is explicitly deprecated since 2.8
+    # 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.
 
@@ -590,7 +602,13 @@ class _MultiCall:
 
         while self.hook_impls:
             hook_impl = self.hook_impls.pop()
-            args = [all_kwargs[argname] for argname in hook_impl.argnames]
+            try:
+                args = [all_kwargs[argname] for argname in hook_impl.argnames]
+            except KeyError:
+                for argname in hook_impl.argnames:
+                    if argname not in all_kwargs:
+                        raise HookCallError(
+                            "hook call must provide argument %r" % (argname,))
             if hook_impl.hookwrapper:
                 return _wrapped_call(hook_impl.function(*args), self.execute)
             res = hook_impl.function(*args)
@@ -629,7 +647,10 @@ def varnames(func, startindex=None):
         startindex = 1
     else:
         if not inspect.isfunction(func) and not inspect.ismethod(func):
-            func = getattr(func, '__call__', func)
+            try:
+                func = getattr(func, '__call__', func)
+            except Exception:
+                return ()
         if startindex is None:
             startindex = int(inspect.ismethod(func))
 
@@ -763,6 +784,10 @@ class PluginValidationError(Exception):
     """ plugin failed validation. """
 
 
+class HookCallError(Exception):
+    """ Hook was called wrongly. """
+
+
 if hasattr(inspect, 'signature'):
     def _formatdef(func):
         return "%s%s" % (

appveyor.yml

@@ -5,24 +5,37 @@ environment:
     # using pytestbot account as detailed here:
     # https://www.appveyor.com/docs/build-configuration#secure-variables
 
+  matrix:
+  # coveralls is not in the default env list
+  - TOXENV: "coveralls"
+  # note: please use "tox --listenvs" to populate the build matrix below
+  - TOXENV: "linting"
+  - TOXENV: "py26"
+  - TOXENV: "py27"
+  - TOXENV: "py33"
+  - TOXENV: "py34"
+  - TOXENV: "py35"
+  - TOXENV: "pypy"
+  - TOXENV: "py27-pexpect"
+  - TOXENV: "py27-xdist"
+  - TOXENV: "py27-trial"
+  - TOXENV: "py35-pexpect"
+  - TOXENV: "py35-xdist"
+  - TOXENV: "py35-trial"
+  - TOXENV: "py27-nobyte"
+  - TOXENV: "doctesting"
+  - TOXENV: "freeze"
+  - TOXENV: "docs"
+
 install:
   - echo Installed Pythons
   - dir c:\Python*
 
-  # install pypy using choco (redirect to a file and write to console in case
-  # choco install returns non-zero, because choco install python.pypy is too
-  # noisy)
-  - choco install python.pypy > pypy-inst.log 2>&1 || (type pypy-inst.log & exit /b 1)
-  - set PATH=C:\tools\pypy\pypy;%PATH% # so tox can find pypy
-  - echo PyPy installed
-  - pypy --version
+  - if "%TOXENV%" == "pypy" call scripts\install-pypy.bat
 
   - C:\Python35\python -m pip install tox
 
 build: false  # Not a C# project, build stuff at the test step instead.
 
 test_script:
-  - C:\Python35\python -m tox
-  # coveralls is not in tox's envlist, plus for PRs the secure variable
-  # is not defined so we have to check for it
-  - if defined COVERALLS_REPO_TOKEN C:\Python35\python -m tox -e coveralls
+  - call scripts\call-tox.bat

doc/en/Makefile

@@ -19,10 +19,9 @@ REGENDOC_ARGS := \
 	--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
 
-    
+
 help:
 	@echo "Please use \`make <target>' where <target> is one of"
 	@echo "  html       to make standalone HTML files"
@@ -36,22 +35,6 @@ help:
 clean:
 	-rm -rf $(BUILDDIR)/*
 
-SITETARGET=$(shell ./_getdoctarget.py)
-
-showtarget:
-	@echo $(SITETARGET)
-
-install: html
-	 # for access talk to someone with login rights to
-	 # pytest-dev@pytest.org to add your ssh key
-	 rsync -avz _build/html/ pytest-dev@pytest.org:pytest.org/$(SITETARGET)
-
-installpdf: latexpdf
-	@scp $(BUILDDIR)/latex/pytest.pdf pytest-dev@pytest.org:pytest.org/$(SITETARGET)
-
-installall: clean install installpdf
-	@echo "done"
-
 regen:
 	PYTHONDONTWRITEBYTECODE=1 COLUMNS=76 regendoc --update *.rst */*.rst ${REGENDOC_ARGS}
 

doc/en/_getdoctarget.py

@@ -1,16 +0,0 @@
-#!/usr/bin/env python
-
-import py
-
-def get_version_string():
-    fn = py.path.local(__file__).join("..", "..", "..",
-                                      "_pytest", "__init__.py")
-    for line in fn.readlines():
-        if "version" in line and not line.strip().startswith('#'):
-            return eval(line.split("=")[-1])
-
-def get_minor_version_string():
-    return ".".join(get_version_string().split(".")[:2])
-
-if __name__ == "__main__":
-    print (get_minor_version_string())

doc/en/_templates/layout.html

@@ -1,19 +1,5 @@
 {% extends "!layout.html" %}
 {% block header %}
-<div align="center" xmlns="http://www.w3.org/1999/html" style="background-color: lightgreen;  padding: .5em">
-  <h4>
-      Want to help improve pytest?  Please 
-    <a href="https://www.indiegogo.com/projects/python-testing-sprint-mid-2016#/">
-        contribute to
-    </a>
-    or 
-    <a href="announce/sprint2016.html">
-        join
-    </a>
-    our upcoming sprint in June 2016!
-
-  </h4>
-</div>
   {{super()}}
 {% endblock %}
 {% block footer %}

doc/en/_templates/links.html

@@ -1,16 +1,11 @@
 <h3>Useful Links</h3>
 <ul>
-  <li>
-    <a href="https://www.indiegogo.com/projects/python-testing-sprint-mid-2016#/">
-      <b>Sprint funding campaign</b>
-    </a>
-  </li>
   <li><a href="{{ pathto('index') }}">The pytest Website</a></li>
   <li><a href="{{ pathto('contributing') }}">Contribution Guide</a></li>
   <li><a href="https://pypi.python.org/pypi/pytest">pytest @ PyPI</a></li>
   <li><a href="https://github.com/pytest-dev/pytest/">pytest @ GitHub</a></li>
   <li><a href="http://plugincompat.herokuapp.com/">3rd party plugins</a></li>
   <li><a href="https://github.com/pytest-dev/pytest/issues">Issue Tracker</a></li>
-  <li><a href="http://pytest.org/latest/pytest.pdf">PDF Documentation</a>
+  <li><a href="https://media.readthedocs.org/pdf/pytest/latest/pytest.pdf">PDF Documentation</a>
 </ul>
 

doc/en/adopt.rst

@@ -1,3 +1,7 @@
+:orphan:
+
+.. warnings about this file not being included in any toctree will be suppressed by :orphan:
+
 
 April 2015 is "adopt pytest month"
 =============================================

doc/en/announce/index.rst

@@ -5,9 +5,15 @@ Release announcements
 .. toctree::
    :maxdepth: 2
 
-
+   
+   release-3.0.5
+   release-3.0.4
+   release-3.0.3
+   release-3.0.2
+   release-3.0.1
+   release-3.0.0
    sprint2016
-   release-2.9.1
+   release-2.9.2
    release-2.9.1
    release-2.9.0
    release-2.8.7

doc/en/announce/release-2.6.3.rst

@@ -41,7 +41,7 @@ Changes 2.6.3
   dep).  Thanks Charles Cloud for analysing the issue.
 
 - fix conftest related fixture visibility issue: when running with a
-  CWD outside a test package pytest would get fixture discovery wrong.
+  CWD outside of a test package pytest would get fixture discovery wrong.
   Thanks to Wolfgang Schnerring for figuring out a reproducable example.
 
 - Introduce pytest_enter_pdb hook (needed e.g. by pytest_timeout to cancel the

doc/en/announce/release-2.9.1.rst

@@ -63,3 +63,5 @@ The py.test Development Team
 .. _#649: https://github.com/pytest-dev/pytest/issues/649
 
 .. _@asottile: https://github.com/asottile
+.. _@nicoddemus: https://github.com/nicoddemus
+.. _@tomviner: https://github.com/tomviner

doc/en/announce/release-2.9.2.rst

@@ -1,4 +1,4 @@
-pytest-2.9.1
+pytest-2.9.2
 ============
 
 pytest is a mature Python testing tool with more than a 1100 tests
@@ -69,5 +69,10 @@ The py.test Development Team
 .. _#1496: https://github.com/pytest-dev/pytest/issue/1496
 .. _#1524: https://github.com/pytest-dev/pytest/issue/1524
 
-.. _@prusse-martin: https://github.com/prusse-martin
 .. _@astraw38: https://github.com/astraw38
+.. _@hackebrot: https://github.com/hackebrot
+.. _@omarkohl: https://github.com/omarkohl
+.. _@pquentin: https://github.com/pquentin
+.. _@prusse-martin: https://github.com/prusse-martin
+.. _@RonnyPfannschmidt: https://github.com/RonnyPfannschmidt
+.. _@tomviner: https://github.com/tomviner

doc/en/announce/release-3.0.0.rst

@@ -0,0 +1,82 @@
+pytest-3.0.0
+============
+
+The pytest team is proud to announce the 3.0.0 release!
+
+pytest is a mature Python testing tool with more than a 1600 tests
+against itself, passing on many different interpreters and platforms.
+
+This release contains a lot of bugs fixes and improvements, and much of
+the work done on it was possible because of the 2016 Sprint[1], which
+was funded by an indiegogo campaign which raised over US$12,000 with 
+nearly 100 backers. 
+
+There's a "What's new in pytest 3.0" [2] blog post highlighting the 
+major features in this release.
+
+To see the complete changelog and documentation, please visit:
+
+    http://docs.pytest.org
+
+As usual, you can upgrade from pypi via:
+
+    pip install -U pytest
+
+Thanks to all who contributed to this release, among them:
+
+    AbdealiJK
+    Ana Ribeiro
+    Antony Lee
+    Brandon W Maister
+    Brianna Laugher
+    Bruno Oliveira
+    Ceridwen
+    Christian Boelsen
+    Daniel Hahler
+    Danielle Jenkins
+    Dave Hunt
+    Diego Russo
+    Dmitry Dygalo
+    Edoardo Batini
+    Eli Boyarski
+    Florian Bruhin
+    Floris Bruynooghe
+    Greg Price
+    Guyzmo
+    HEAD KANGAROO
+    JJ
+    Javi Romero
+    Javier Domingo Cansino
+    Kale Kundert
+    Kalle Bronsen
+    Marius Gedminas
+    Matt Williams
+    Mike Lundy
+    Oliver Bestwalter
+    Omar Kohl
+    Raphael Pierzina
+    RedBeardCode
+    Roberto Polli
+    Romain Dorgueil
+    Roman Bolshakov
+    Ronny Pfannschmidt
+    Stefan Zimmermann
+    Steffen Allner
+    Tareq Alayan
+    Ted Xiao
+    Thomas Grainger
+    Tom Viner
+    TomV
+    Vasily Kuznetsov
+    aostr
+    marscher
+    palaviv
+    satoru
+    taschini
+
+
+Happy testing,
+The Pytest Development Team
+
+[1] http://blog.pytest.org/2016/pytest-development-sprint/
+[2] http://blog.pytest.org/2016/whats-new-in-pytest-30/

doc/en/announce/release-3.0.1.rst

@@ -0,0 +1,26 @@
+pytest-3.0.1
+============
+
+pytest 3.0.1 has just been released to PyPI.
+
+This release fixes some regressions reported in version 3.0.0, being a
+drop-in replacement. To upgrade:
+
+  pip install --upgrade pytest
+  
+The changelog is available at http://doc.pytest.org/en/latest/changelog.html.
+
+Thanks to all who contributed to this release, among them:
+
+      Adam Chainz
+      Andrew Svetlov
+      Bruno Oliveira
+      Daniel Hahler
+      Dmitry Dygalo
+      Florian Bruhin
+      Marcin Bachry
+      Ronny Pfannschmidt
+      matthiasha
+
+Happy testing,
+The py.test Development Team

doc/en/announce/release-3.0.2.rst

@@ -0,0 +1,24 @@
+pytest-3.0.2
+============
+
+pytest 3.0.2 has just been released to PyPI.
+
+This release fixes some regressions and bugs reported in version 3.0.1, being a
+drop-in replacement. To upgrade::
+
+  pip install --upgrade pytest
+  
+The changelog is available at http://doc.pytest.org/en/latest/changelog.html.
+
+Thanks to all who contributed to this release, among them:
+
+* Ahn Ki-Wook
+* Bruno Oliveira
+* Florian Bruhin
+* Jordan Guymon
+* Raphael Pierzina
+* Ronny Pfannschmidt
+* mbyt
+
+Happy testing,
+The pytest Development Team

doc/en/announce/release-3.0.3.rst

@@ -0,0 +1,27 @@
+pytest-3.0.3
+============
+
+pytest 3.0.3 has just been released to PyPI.
+
+This release fixes some regressions and bugs reported in the last version, 
+being a drop-in replacement. To upgrade::
+
+  pip install --upgrade pytest
+  
+The changelog is available at http://doc.pytest.org/en/latest/changelog.html.
+
+Thanks to all who contributed to this release, among them:
+
+* Bruno Oliveira
+* Florian Bruhin
+* Floris Bruynooghe
+* Huayi Zhang
+* Lev Maximov
+* Raquel Alegre
+* Ronny Pfannschmidt
+* Roy Williams
+* Tyler Goodlet
+* mbyt
+
+Happy testing,
+The pytest Development Team

doc/en/announce/release-3.0.4.rst

@@ -0,0 +1,29 @@
+pytest-3.0.4
+============
+
+pytest 3.0.4 has just been released to PyPI.
+
+This release fixes some regressions and bugs reported in the last version, 
+being a drop-in replacement. To upgrade::
+
+  pip install --upgrade pytest
+  
+The changelog is available at http://doc.pytest.org/en/latest/changelog.html.
+
+Thanks to all who contributed to this release, among them:
+
+* Bruno Oliveira
+* Dan Wandschneider
+* Florian Bruhin
+* Georgy Dyuldin
+* Grigorii Eremeev
+* Jason R. Coombs
+* Manuel Jacob
+* Mathieu Clabaut
+* Michael Seifert
+* Nikolaus Rath
+* Ronny Pfannschmidt
+* Tom V
+
+Happy testing,
+The pytest Development Team

doc/en/announce/release-3.0.5.rst

@@ -0,0 +1,27 @@
+pytest-3.0.5
+============
+
+pytest 3.0.5 has just been released to PyPI.
+
+This is a bug-fix release, being a drop-in replacement. To upgrade::
+
+  pip install --upgrade pytest
+  
+The changelog is available at http://doc.pytest.org/en/latest/changelog.html.
+
+Thanks to all who contributed to this release, among them:
+
+* Ana Vojnovic
+* Bruno Oliveira
+* Daniel Hahler
+* Duncan Betts
+* Igor Starikov
+* Ismail
+* Luke Murphy
+* Ned Batchelder
+* Ronny Pfannschmidt
+* Sebastian Ramacher
+* nmundar
+
+Happy testing,
+The pytest Development Team

doc/en/announce/sprint2016.rst

@@ -4,9 +4,9 @@ python testing sprint June 20th-26th 2016
 .. image:: ../img/freiburg2.jpg
    :width: 400
 
-The pytest core group is heading towards the biggest sprint
-in its history, to take place in the black forest town Freiburg
-in Germany.  As of February 2016 we have started a `funding
+The pytest core group held the biggest sprint
+in its history in June 2016, taking place in the black forest town Freiburg
+in Germany.  In February 2016 we started a `funding
 campaign on Indiegogo to cover expenses
 <http://igg.me/at/pytest-sprint/x/4034848>`_ The page also mentions
 some preliminary topics:
@@ -35,71 +35,30 @@ some preliminary topics:
 Participants
 --------------
 
-Here are preliminary participants who said they are likely to come,
-given some expenses funding::
-
-    Anatoly Bubenkoff, Netherlands
-    Andreas Pelme, Personalkollen, Sweden
-    Anthony Wang, Splunk, US
-    Brianna Laugher, Australia
-    Bruno Oliveira, Brazil
-    Danielle Jenkins, Splunk, US
-    Dave Hunt, UK
-    Florian Bruhin, Switzerland
-    Floris Bruynooghe, Cobe.io, UK
-    Holger Krekel, merlinux, Germany
-    Oliver Bestwalter, Avira, Germany
-    Omar Kohl, Germany
-    Raphael Pierzina, FanDuel, UK
-    Tom Viner, UK
-
-    <your name here?>
-
-Other contributors and experienced newcomers are invited to join as well
-but please send a mail to the pytest-dev mailing list if you intend to
-do so somewhat soon, also how much funding you need if so.  And if you
-are working for a company and using pytest heavily you are welcome to
-join and we encourage your company to provide some funding for the
-sprint.  They may see it, and rightfully so, as a very cheap and deep
-training which brings you together with the experts in the field :)
+Over 20 participants took part from 4 continents, including employees
+from Splunk, Personalkollen, Cobe.io, FanDuel and Dolby. Some newcomers
+mixed with developers who have worked on pytest since its beginning, and
+of course everyone in between.
 
 
 Sprint organisation, schedule
 -------------------------------
 
-tentative schedule:
+People arrived in Freiburg on the 19th, with sprint development taking
+place on 20th, 21st, 22nd, 24th and 25th. On the 23rd we took a break
+day for some hot hiking in the Black Forest.
 
-- 19/20th arrival in Freiburg
-- 20th social get together, initial hacking
-- 21/22th full sprint days
-- 23rd break day, hiking
-- 24/25th full sprint days
-- 26th departure
+Sprint activity was organised heavily around pairing, with plenty of group
+discusssions to take advantage of the high bandwidth, and lightning talks
+as well.
 
-We might adjust according to weather to make sure that if
-we do some hiking or excursion we'll have good weather.
-Freiburg is one of the sunniest places in Germany so
-it shouldn't be too much of a constraint.
-
-
-Accomodation
-----------------
-
-We'll see to arrange for renting a flat with multiple
-beds/rooms.  Hotels are usually below 100 per night.
-The earlier we book the better.
 
 Money / funding
 ---------------
 
-The Indiegogo campaign asks for 11000 USD which should cover
-the costs for flights and accomodation, renting a sprint place
-and maybe a bit of food as well.
 
-If your organisation wants to support the sprint but prefers
-to give money according to an invoice, get in contact with
-holger at http://merlinux.eu who can invoice your organisation
-properly.
+The Indiegogo campaign aimed for 11000 USD and in the end raised over
+12000, to reimburse travel costs, pay for a sprint venue and catering.
 
-If we have excess money we'll use for further sprint/travel
-funding for pytest/tox contributors.
+Excess money is reserved for further sprint/travel funding for pytest/tox
+contributors.

doc/en/assert.rst

@@ -24,9 +24,9 @@ following::
 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
+    $ pytest test_assert1.py
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     
@@ -85,6 +85,15 @@ and if you need to have access to the actual exception info you may use::
 the actual exception raised.  The main attributes of interest are
 ``.type``, ``.value`` and ``.traceback``.
 
+.. versionchanged:: 3.0
+
+In the context manager form you may use the keyword argument
+``message`` to specify a custom failure message::
+
+     >>> with raises(ZeroDivisionError, message="Expecting ZeroDivisionError"):
+     ...    pass
+     ... Failed: Expecting ZeroDivisionError
+
 If you want to write test code that works on Python 2.4 as well,
 you may also use two other ways to test for an expected exception::
 
@@ -110,6 +119,24 @@ exceptions your own code is deliberately raising, whereas using
 like documenting unfixed bugs (where the test describes what "should" happen)
 or bugs in dependencies.
 
+If you want to test that a regular expression matches on the string
+representation of an exception (like the ``TestCase.assertRaisesRegexp`` method
+from ``unittest``) you can use the ``ExceptionInfo.match`` method::
+
+    import pytest
+
+    def myfunc():
+        raise ValueError("Exception 123 raised")
+
+    def test_match():
+        with pytest.raises(ValueError) as excinfo:
+            myfunc()
+        excinfo.match(r'.* 123 .*')
+
+The regexp parameter of the ``match`` method is matched with the ``re.search``
+function. So in the above example ``excinfo.match('123')`` would have worked as
+well.
+
 
 .. _`assertwarns`:
 
@@ -141,9 +168,9 @@ when it encounters comparisons.  For example::
 
 if you run this module::
 
-    $ py.test test_assert2.py
+    $ pytest test_assert2.py
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     
@@ -181,6 +208,7 @@ It is possible to add your own detailed explanations by implementing
 the ``pytest_assertrepr_compare`` hook.
 
 .. autofunction:: _pytest.hookspec.pytest_assertrepr_compare
+   :noindex:
 
 As an example consider adding the following hook in a conftest.py which
 provides an alternative explanation for ``Foo`` objects::
@@ -210,7 +238,7 @@ now, given this test module::
 you can run the test module and get the custom output defined in
 the conftest file::
 
-   $ py.test -q test_foocompare.py
+   $ pytest -q test_foocompare.py
    F
    ======= FAILURES ========
    _______ test_compare ________
@@ -287,3 +315,6 @@ For further information, Benjamin Peterson wrote up `Behind the scenes of pytest
 .. versionchanged:: 2.1
    Introduce the ``--assert`` option. Deprecate ``--no-assert`` and
    ``--nomagic``.
+
+.. versionchanged:: 3.0
+   Removes the ``--no-assert`` and``--nomagic`` options.

doc/en/backwards-compatibility.rst

@@ -0,0 +1,12 @@
+.. _backwards-compatibility:
+
+Backwards Compatibility Policy
+==============================
+
+Keeping backwards compatibility has a very high priority in the pytest project. Although we have deprecated functionality over the years, most of it is still supported. All deprecations in pytest were done because simpler or more efficient ways of accomplishing the same tasks have emerged, making the old way of doing things unnecessary.
+
+With the pytest 3.0 release we introduced a clear communication scheme for when we will actually remove the old busted joint and politely ask you to use the new hotness instead, while giving you enough time to adjust your tests or raise concerns if there are valid reasons to keep deprecated functionality around.
+
+To communicate changes we are already issuing deprecation warnings, but they are not displayed by default. In pytest 3.0 we changed the default setting so that pytest deprecation warnings are displayed if not explicitly silenced (with ``--disable-pytest-warnings``).
+
+We will only remove deprecated functionality in major releases (e.g. if we deprecate something in 3.0 we will remove it in 4.0), and keep it around for at least two minor releases (e.g. if we deprecate something in 3.9 and 4.0 is the next release, we will not remove it in 4.0 but in 5.0).

doc/en/bash-completion.rst

@@ -18,11 +18,11 @@ For global activation of all argcomplete enabled python applications run::
 
 For permanent (but not global) ``pytest`` activation, use::
 
-        register-python-argcomplete py.test >> ~/.bashrc
+        register-python-argcomplete pytest >> ~/.bashrc
 
 For one-time activation of argcomplete for ``pytest`` only, use::
 
-        eval "$(register-python-argcomplete py.test)"
+        eval "$(register-python-argcomplete pytest)"
 
 
 

doc/en/builtin.rst

@@ -35,6 +35,11 @@ Examples at :ref:`assertraises`.
 
 .. autofunction:: deprecated_call
 
+Comparing floating point numbers
+--------------------------------
+
+.. autoclass:: approx
+
 Raising a specific test outcome
 --------------------------------------
 
@@ -48,18 +53,18 @@ you can rather use declarative marks, see :ref:`skipping`.
 .. autofunction:: _pytest.skipping.xfail
 .. autofunction:: _pytest.runner.exit
 
-fixtures and requests
+Fixtures and requests
 -----------------------------------------------------
 
 To mark a fixture function:
 
-.. autofunction:: _pytest.python.fixture
+.. autofunction:: _pytest.fixtures.fixture
 
 Tutorial at :ref:`fixtures`.
 
 The ``request`` object that can be used from fixture functions.
 
-.. autoclass:: _pytest.python.FixtureRequest()
+.. autoclass:: _pytest.fixtures.FixtureRequest()
     :members:
 
 
@@ -72,7 +77,7 @@ Builtin fixtures/function arguments
 You can ask for available builtin or project-custom
 :ref:`fixtures <fixtures>` by typing::
 
-    $ py.test -q --fixtures
+    $ pytest -q --fixtures
     cache
         Return a cache object that can persist state between testing sessions.
         
@@ -84,19 +89,23 @@ You can ask for available builtin or project-custom
         
         Values can be any object handled by the json stdlib module.
     capsys
-        enables capturing of writes to sys.stdout/sys.stderr and makes
+        Enable capturing of writes to sys.stdout/sys.stderr and make
         captured output available via ``capsys.readouterr()`` method calls
         which return a ``(out, err)`` tuple.
     capfd
-        enables capturing of writes to file descriptors 1 and 2 and makes
+        Enable capturing of writes to file descriptors 1 and 2 and make
         captured output available via ``capfd.readouterr()`` method calls
         which return a ``(out, err)`` tuple.
+    doctest_namespace
+        Inject names into the doctest namespace.
+    pytestconfig
+        the pytest config object with access to command line opts.
     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
+        Add 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
+        The returned ``monkeypatch`` fixture provides these
         helper methods to modify objects, dictionaries or os.environ::
         
         monkeypatch.setattr(obj, name, value, raising=True)
@@ -109,11 +118,9 @@ You can ask for available builtin or project-custom
         monkeypatch.chdir(path)
         
         All modifications will be undone after the requesting
-        test function has finished. The ``raising``
+        test function or fixture has finished. The ``raising``
         parameter determines if a KeyError or AttributeError
         will be raised if the set/deletion operation has no target.
-    pytestconfig
-        the pytest config object with access to command line opts.
     recwarn
         Return a WarningsRecorder instance that provides these methods:
         
@@ -125,7 +132,7 @@ You can ask for available builtin or project-custom
     tmpdir_factory
         Return a TempdirFactory instance for the test session.
     tmpdir
-        return a temporary directory path object
+        Return a temporary directory path object
         which is unique to each test function invocation,
         created as a sub directory of the base temporary
         directory.  The returned object is a `py.path.local`_

doc/en/cache.rst

@@ -15,7 +15,7 @@ Usage
 ---------
 
 The plugin provides two command line options to rerun failures from the
-last ``py.test`` invocation:
+last ``pytest`` invocation:
 
 * ``--lf``, ``--last-failed`` - to only re-run the failures.
 * ``--ff``, ``--failed-first`` - to run the failures first and then the rest of
@@ -25,7 +25,7 @@ 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.
+**json encodable** values between ``pytest`` invocations.
 
 .. note::
 
@@ -49,7 +49,7 @@ First, let's create 50 test invocation of which only 2 fail::
 
 If you run this for the first time you will see two failures::
 
-    $ py.test -q
+    $ pytest -q
     .................F.......F........................
     ======= FAILURES ========
     _______ test_num[17] ________
@@ -78,9 +78,9 @@ If you run this for the first time you will see two failures::
 
 If you then run it with ``--lf``::
 
-    $ py.test --lf
+    $ pytest --lf
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     run-last-failure: rerun last 2 failures
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 50 items
@@ -110,6 +110,7 @@ If you then run it with ``--lf``::
     E          Failed: bad luck
     
     test_50.py:6: Failed
+    ======= 48 tests deselected ========
     ======= 2 failed, 48 deselected in 0.12 seconds ========
 
 You have run only the two failing test from the last run, while 48 tests have
@@ -119,9 +120,9 @@ 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
+    $ pytest --ff
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     run-last-failure: rerun last 2 failures first
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 50 items
@@ -163,7 +164,7 @@ The new config.cache object
 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::
+across pytest invocations::
 
     # content of test_caching.py
     import pytest
@@ -184,7 +185,7 @@ across py.test invocations::
 If you run this command once, it will take a while because
 of the sleep::
 
-    $ py.test -q
+    $ pytest -q
     F
     ======= FAILURES ========
     _______ test_function ________
@@ -201,7 +202,7 @@ of the sleep::
 If you run it a second time the value will be retrieved from
 the cache and this will be quick::
 
-    $ py.test -q
+    $ pytest -q
     F
     ======= FAILURES ========
     _______ test_function ________
@@ -222,27 +223,20 @@ Inspecting Cache content
 -------------------------------
 
 You can always peek at the content of the cache using the
-``--cache-clear`` command line option::
+``--cache-show`` command line option::
 
-    $ py.test --cache-clear
+    $ py.test --cache-show
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
-    collected 1 items
+    cachedir: $REGENDOC_TMPDIR/.cache
+    ------------------------------- cache values -------------------------------
+    example/value contains:
+      42
+    cache/lastfailed contains:
+      {'test_caching.py::test_function': True}
     
-    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 ========
+    ======= no tests ran in 0.12 seconds ========
 
 Clearing Cache content
 -------------------------------
@@ -250,7 +244,7 @@ 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
+    pytest --cache-clear
 
 This is recommended for invocations from Continous Integration
 servers where isolation and correctness is more important

doc/en/capture.rst

@@ -36,9 +36,9 @@ There are two ways in which ``pytest`` can perform capturing:
 
 You can influence output capturing mechanisms from the command line::
 
-    py.test -s            # disable all capturing
-    py.test --capture=sys # replace sys.stdout/stderr with in-mem files
-    py.test --capture=fd  # also point filedescriptors 1 and 2 to temp file
+    pytest -s            # disable all capturing
+    pytest --capture=sys # replace sys.stdout/stderr with in-mem files
+    pytest --capture=fd  # also point filedescriptors 1 and 2 to temp file
 
 .. _printdebugging:
 
@@ -62,9 +62,9 @@ is that you can use print statements for debugging::
 and running this module will show you precisely the output
 of the failing function and hide the other one::
 
-    $ py.test
+    $ pytest
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     
@@ -97,7 +97,7 @@ that performs some output related checks:
         out, err = capsys.readouterr()
         assert out == "hello\n"
         assert err == "world\n"
-        print "next"
+        print ("next")
         out, err = capsys.readouterr()
         assert out == "next\n"
 
@@ -115,4 +115,19 @@ same interface but allows to also capture output from
 libraries or subprocesses that directly write to operating
 system level output streams (FD1 and FD2).
 
+
+.. versionadded:: 3.0
+
+To temporarily disable capture within a test, both ``capsys``
+and ``capfd`` have a ``disabled()`` method that can be used
+as a context manager, disabling capture inside the ``with`` block:
+
+.. code-block:: python
+
+    def test_disabling_capturing(capsys):
+        print('this output is captured')
+        with capsys.disabled():
+            print('output not captured, going directly to sys.stdout')
+        print('this output is also captured')
+
 .. include:: links.inc

doc/en/conf.py

@@ -19,11 +19,8 @@
 # The short X.Y version.
 
 import os, sys
-sys.path.insert(0, os.path.dirname(__file__))
-import _getdoctarget
-
-version = _getdoctarget.get_minor_version_string()
-release = _getdoctarget.get_version_string()
+from _pytest import __version__ as version
+release = ".".join(version.split(".")[:2])
 
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
@@ -127,7 +124,7 @@ html_theme_options = {
 
 # The name for this set of Sphinx documents.  If None, it defaults to
 # "<project> v<release> documentation".
-html_title = None
+html_title = 'pytest documentation'
 
 # A shorter title for the navigation bar.  Default is the same as html_title.
 html_short_title = "pytest-%s" % release
@@ -144,7 +141,7 @@ html_favicon = "img/pytest1favi.ico"
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
+# html_static_path = ['_static']
 
 # If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
 # using the given strftime format.

doc/en/contents.rst

@@ -3,37 +3,58 @@
 Full pytest documentation
 ===========================
 
-`Download latest version as PDF <pytest.pdf>`_
+`Download latest version as PDF <https://media.readthedocs.org/pdf/pytest/latest/pytest.pdf>`_
 
 .. `Download latest version as EPUB <http://media.readthedocs.org/epub/pytest/latest/pytest.epub>`_
 
 .. toctree::
    :maxdepth: 2
 
-   overview
-   apiref
-   example/index
+   getting-started
+   usage
+   assert
+   builtin
+   fixture
    monkeypatch
    tmpdir
    capture
    recwarn
+   doctest
+   mark
+   skipping
+   parametrize
    cache
+   unittest
+   nose
+   xunit_setup
    plugins
+   writing_plugins
 
+   example/index
+   goodpractices
+   customize
+   bash-completion
+
+   backwards-compatibility
+   license
    contributing
    talks
+   projects
+   faq
+   contact
 
 .. only:: html
 
    .. toctree::
+      :maxdepth: 1
 
-      funcarg_compare
       announce/index
 
 .. only:: html
 
    .. toctree::
       :hidden:
+      :maxdepth: 1
 
       changelog
 

doc/en/customize.rst

@@ -7,7 +7,7 @@ Command line options and configuration file settings
 You can get help on command line options and values in INI-style
 configurations files by using the general help option::
 
-    py.test -h   # prints options _and_ config file settings
+    pytest -h   # prints options _and_ config file settings
 
 This will display command line and configuration file settings
 which were registered by installed plugins.
@@ -29,25 +29,39 @@ project/testrun-specific information.
 
 Here is the algorithm which finds the rootdir from ``args``:
 
-- determine the common ancestor directory for the specified ``args``.
+- determine the common ancestor directory for the specified ``args`` that are
+  recognised as paths that exist in the file system. If no such paths are
+  found, the common ancestor directory is set to the current working directory.
 
-- look for ``pytest.ini``, ``tox.ini`` and ``setup.cfg`` files in the
-  ancestor directory and upwards.  If one is matched, it becomes the
-  ini-file and its directory becomes the rootdir.  An existing
-  ``pytest.ini`` file will always be considered a match whereas
-  ``tox.ini`` and ``setup.cfg`` will only match if they contain
-  a ``[pytest]`` section.
+- look for ``pytest.ini``, ``tox.ini`` and ``setup.cfg`` files in the ancestor
+  directory and upwards.  If one is matched, it becomes the ini-file and its
+  directory becomes the rootdir.
 
-- if no ini-file was found, look for ``setup.py`` upwards from
-  the common ancestor directory to determine the ``rootdir``.
+- if no ini-file was found, look for ``setup.py`` upwards from the common
+  ancestor directory to determine the ``rootdir``.
 
-- if no ini-file and no ``setup.py`` was found, use the already
-  determined common ancestor as root directory.  This allows to
-  work with pytest in structures that are not part of a package
-  and don't have any particular ini-file configuration.
+- if no ``setup.py`` was found, look for ``pytest.ini``, ``tox.ini`` and
+  ``setup.cfg`` in each of the specified ``args`` and upwards. If one is
+  matched, it becomes the ini-file and its directory becomes the rootdir.
 
-Note that options from multiple ini-files candidates are never merged,
-the first one wins (``pytest.ini`` always wins even if it does not
+- if no ini-file was found, use the already determined common ancestor as root
+  directory. This allows to work with pytest in structures that are not part of
+  a package and don't have any particular ini-file configuration.
+
+If no ``args`` are given, pytest collects test below the current working
+directory and also starts determining the rootdir from there. 
+
+:warning: custom pytest plugin commandline arguments may include a path, as in
+    ``pytest --log-output ../../test.log args``. Then ``args`` is mandatory,
+    otherwise pytest uses the folder of test.log for rootdir determination
+    (see also `issue 1435 <https://github.com/pytest-dev/pytest/issues/1435>`_).
+    A dot ``.`` for referencing to the current working directory is also
+    possible.
+
+Note that an existing ``pytest.ini`` file will always be considered a match,
+whereas ``tox.ini`` and ``setup.cfg`` will only match if they contain a
+``[pytest]`` or ``[tool:pytest]`` section, respectively. Options from multiple ini-files candidates are never
+merged - the first one wins (``pytest.ini`` always wins, even if it does not
 contain a ``[pytest]`` section).
 
 The ``config`` object will subsequently carry these attributes:
@@ -62,14 +76,14 @@ per-testrun information.
 
 Example::
 
-    py.test path/to/testdir path/other/
+    pytest path/to/testdir path/other/
 
 will determine the common ancestor as ``path`` and then
 check for ini-files as follows::
 
     # first look for pytest.ini files
     path/pytest.ini
-    path/setup.cfg  # must also contain [pytest] section to match
+    path/setup.cfg  # must also contain [tool:pytest] section to match
     path/tox.ini    # must also contain [pytest] section to match
     pytest.ini
     ... # all the way down to the root
@@ -126,9 +140,9 @@ Builtin configuration file options
         [pytest]
         addopts = --maxfail=2 -rf  # exit after 2 failures, report fail info
 
-   issuing ``py.test test_hello.py`` actually means::
+   issuing ``pytest test_hello.py`` actually means::
 
-        py.test --maxfail=2 -rf test_hello.py
+        pytest --maxfail=2 -rf test_hello.py
 
    Default is to add no options.
 
@@ -144,13 +158,13 @@ Builtin configuration file options
         [seq]   matches any character in seq
         [!seq]  matches any char not in seq
 
-   Default patterns are ``'.*', 'CVS', '_darcs', '{arch}', '*.egg'``.
+   Default patterns are ``'.*', 'build', 'dist', 'CVS', '_darcs', '{arch}', '*.egg'``.
    Setting a ``norecursedirs`` replaces the default.  Here is an example of
    how to avoid certain directories:
 
    .. code-block:: ini
 
-        # content of setup.cfg
+        # content of pytest.ini
         [pytest]
         norecursedirs = .svn _build tmp*
 
@@ -218,7 +232,7 @@ Builtin configuration file options
 .. confval:: doctest_optionflags
 
    One or more doctest flag names from the standard ``doctest`` module.
-   :doc:`See how py.test handles doctests <doctest>`.
+   :doc:`See how pytest handles doctests <doctest>`.
 
 .. confval:: confcutdir
 

doc/en/doctest.rst

@@ -6,7 +6,7 @@ By default all files matching the ``test*.txt`` pattern will
 be run through the python standard ``doctest`` module.  You
 can change the pattern by issuing::
 
-    py.test --doctest-glob='*.rst'
+    pytest --doctest-glob='*.rst'
 
 on the command line. Since version ``2.9``, ``--doctest-glob``
 can be given multiple times in the command-line.
@@ -15,7 +15,7 @@ You can also trigger running of doctests
 from docstrings in all python modules (including regular
 python test modules)::
 
-    py.test --doctest-modules
+    pytest --doctest-modules
 
 You can make these changes permanent in your project by
 putting them into a pytest.ini file like this:
@@ -45,11 +45,11 @@ and another like this::
         """
         return 42
 
-then you can just invoke ``py.test`` without command line options::
+then you can just invoke ``pytest`` without command line options::
 
-    $ py.test
+    $ pytest
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: pytest.ini
     collected 1 items
     
@@ -68,7 +68,7 @@ Also, :ref:`usefixtures` and :ref:`autouse` fixtures are supported
 when executing text doctest files.
 
 The standard ``doctest`` module provides some setting flags to configure the
-strictness of doctest tests. In py.test You can enable those flags those flags
+strictness of doctest tests. In pytest You can enable those flags those flags
 using the configuration file. To make pytest ignore trailing whitespaces and
 ignore lengthy exception stack traces you can just write:
 
@@ -77,7 +77,7 @@ ignore lengthy exception stack traces you can just write:
     [pytest]
     doctest_optionflags= NORMALIZE_WHITESPACE IGNORE_EXCEPTION_DETAIL
 
-py.test also introduces new options to allow doctests to run in Python 2 and
+pytest also introduces new options to allow doctests to run in Python 2 and
 Python 3 unchanged:
 
 * ``ALLOW_UNICODE``: when enabled, the ``u`` prefix is stripped from unicode
@@ -103,3 +103,50 @@ itself::
     'Hello'
 
 
+The 'doctest_namespace' fixture
+-------------------------------
+
+.. versionadded:: 3.0
+
+The ``doctest_namespace`` fixture can be used to inject items into the
+namespace in which your doctests run. It is intended to be used within
+your own fixtures to provide the tests that use them with context.
+
+``doctest_namespace`` is a standard ``dict`` object into which you
+place the objects you want to appear in the doctest namespace::
+
+    # content of conftest.py
+    import numpy
+    @pytest.fixture(autouse=True)
+    def add_np(doctest_namespace):
+        doctest_namespace['np'] = numpy
+
+which can then be used in your doctests directly::
+
+    # content of numpy.py
+    def arange():
+        """
+        >>> a = np.arange(10)
+        >>> len(a)
+        10
+        """
+        pass
+
+
+Output format
+-------------
+
+.. versionadded:: 3.0
+
+You can change the diff output format on failure for your doctests
+by using one of standard doctest modules format in options
+(see :data:`python:doctest.REPORT_UDIFF`, :data:`python:doctest.REPORT_CDIFF`,
+:data:`python:doctest.REPORT_NDIFF`, :data:`python:doctest.REPORT_ONLY_FIRST_FAILURE`)::
+
+    pytest --doctest-modules --doctest-report none
+    pytest --doctest-modules --doctest-report udiff
+    pytest --doctest-modules --doctest-report cdiff
+    pytest --doctest-modules --doctest-report ndiff
+    pytest --doctest-modules --doctest-report only_first_failure
+
+

doc/en/example/costlysetup/conftest.py

@@ -4,8 +4,8 @@ import pytest
 @pytest.fixture("session")
 def setup(request):
     setup = CostlySetup()
-    request.addfinalizer(setup.finalize)
-    return setup
+    yield setup
+    setup.finalize()
 
 class CostlySetup:
     def __init__(self):

doc/en/example/layout1/setup.cfg

@@ -1,4 +0,0 @@
-[pytest]
-testfilepatterns =
-    ${topdir}/tests/unit/test_${basename}
-    ${topdir}/tests/functional/*.py

doc/en/example/markers.rst

@@ -29,23 +29,23 @@ You can "mark" a test function with custom metadata like this::
 
 You can then restrict a test run to only run tests marked with ``webtest``::
 
-    $ py.test -v -m webtest
+    $ pytest -v -m webtest
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.5
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0 -- $PYTHON_PREFIX/bin/python3.5
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 4 items
     
     test_server.py::test_send_http PASSED
     
-    ======= 3 tests deselected by "-m 'webtest'" ========
+    ======= 3 tests deselected ========
     ======= 1 passed, 3 deselected in 0.12 seconds ========
 
 Or the inverse, running all tests except the webtest ones::
 
-    $ py.test -v -m "not webtest"
+    $ pytest -v -m "not webtest"
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.5
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0 -- $PYTHON_PREFIX/bin/python3.5
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 4 items
@@ -54,7 +54,7 @@ Or the inverse, running all tests except the webtest ones::
     test_server.py::test_another PASSED
     test_server.py::TestClass::test_method PASSED
     
-    ======= 1 tests deselected by "-m 'not webtest'" ========
+    ======= 1 tests deselected ========
     ======= 3 passed, 1 deselected in 0.12 seconds ========
 
 Selecting tests based on their node ID
@@ -64,9 +64,9 @@ You can provide one or more :ref:`node IDs <node-id>` as positional
 arguments to select only specified tests. This makes it easy to select
 tests based on their module, class, method, or function name::
 
-    $ py.test -v test_server.py::TestClass::test_method
+    $ pytest -v test_server.py::TestClass::test_method
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.5
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0 -- $PYTHON_PREFIX/bin/python3.5
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 5 items
@@ -77,9 +77,9 @@ tests based on their module, class, method, or function name::
 
 You can also select on the class::
 
-    $ py.test -v test_server.py::TestClass
+    $ pytest -v test_server.py::TestClass
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.5
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0 -- $PYTHON_PREFIX/bin/python3.5
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 4 items
@@ -90,9 +90,9 @@ You can also select on the class::
 
 Or select multiple nodes::
 
-  $ py.test -v test_server.py::TestClass test_server.py::test_send_http
+  $ pytest -v test_server.py::TestClass test_server.py::test_send_http
   ======= test session starts ========
-  platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.5
+  platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0 -- $PYTHON_PREFIX/bin/python3.5
   cachedir: .cache
   rootdir: $REGENDOC_TMPDIR, inifile: 
   collecting ... collected 8 items
@@ -115,8 +115,8 @@ Or select multiple nodes::
     ``module.py::function[param]``.
 
     Node IDs for failing tests are displayed in the test summary info
-    when running py.test with the ``-rf`` option.  You can also
-    construct Node IDs from the output of ``py.test --collectonly``.
+    when running pytest with the ``-rf`` option.  You can also
+    construct Node IDs from the output of ``pytest --collectonly``.
 
 Using ``-k expr`` to select tests based on their name
 -------------------------------------------------------
@@ -128,23 +128,23 @@ which implements a substring match on the test names instead of the
 exact match on markers that ``-m`` provides.  This makes it easy to
 select tests based on their names::
 
-    $ py.test -v -k http  # running with the above defined example module
+    $ pytest -v -k http  # running with the above defined example module
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.5
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0 -- $PYTHON_PREFIX/bin/python3.5
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 4 items
     
     test_server.py::test_send_http PASSED
     
-    ======= 3 tests deselected by '-khttp' ========
+    ======= 3 tests deselected ========
     ======= 1 passed, 3 deselected in 0.12 seconds ========
 
 And you can also run all tests except the ones that match the keyword::
 
-    $ py.test -k "not send_http" -v
+    $ pytest -k "not send_http" -v
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.5
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0 -- $PYTHON_PREFIX/bin/python3.5
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 4 items
@@ -153,14 +153,14 @@ And you can also run all tests except the ones that match the keyword::
     test_server.py::test_another PASSED
     test_server.py::TestClass::test_method PASSED
     
-    ======= 1 tests deselected by '-knot send_http' ========
+    ======= 1 tests deselected ========
     ======= 3 passed, 1 deselected in 0.12 seconds ========
 
 Or to select "http" and "quick" tests::
 
-    $ py.test -k "http or quick" -v
+    $ pytest -k "http or quick" -v
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.5
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0 -- $PYTHON_PREFIX/bin/python3.5
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 4 items
@@ -168,7 +168,7 @@ Or to select "http" and "quick" tests::
     test_server.py::test_send_http PASSED
     test_server.py::test_something_quick PASSED
     
-    ======= 2 tests deselected by '-khttp or quick' ========
+    ======= 2 tests deselected ========
     ======= 2 passed, 2 deselected in 0.12 seconds ========
 
 .. note::
@@ -198,7 +198,7 @@ Registering markers for your test suite is simple::
 
 You can ask which markers exist for your test suite - the list includes our just defined ``webtest`` markers::
 
-    $ py.test --markers
+    $ pytest --markers
     @pytest.mark.webtest: mark a test as a webtest.
     
     @pytest.mark.skip(reason=None): skip the given test function with an optional reason. Example: skip(reason="no way of currently testing this") skips the test.
@@ -225,7 +225,7 @@ For an example on how to add and work with markers from a plugin, see
 
     * there is one place in your test suite defining your markers
 
-    * asking for existing markers via ``py.test --markers`` gives good output
+    * asking for existing markers via ``pytest --markers`` gives good output
 
     * typos in function markers are treated as an error if you use
       the ``--strict`` option. Future versions of ``pytest`` are probably
@@ -350,9 +350,9 @@ A test file using this local plugin::
 and an example invocations specifying a different environment than what
 the test needs::
 
-    $ py.test -E stage2
+    $ pytest -E stage2
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     
@@ -362,9 +362,9 @@ the test needs::
 
 and here is one that specifies exactly the environment needed::
 
-    $ py.test -E stage1
+    $ pytest -E stage1
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     
@@ -374,7 +374,7 @@ and here is one that specifies exactly the environment needed::
 
 The ``--markers`` option always gives you a list of available markers::
 
-    $ py.test --markers
+    $ pytest --markers
     @pytest.mark.env(name): mark test to run only on named environment
     
     @pytest.mark.skip(reason=None): skip the given test function with an optional reason. Example: skip(reason="no way of currently testing this") skips the test.
@@ -427,7 +427,7 @@ test function.  From a conftest file we can read it like this::
 
 Let's run this without capturing output and see what we get::
 
-    $ py.test -q -s
+    $ pytest -q -s
     glob args=('function',) kwargs={'x': 3}
     glob args=('class',) kwargs={'x': 2}
     glob args=('module',) kwargs={'x': 1}
@@ -483,9 +483,9 @@ Let's do a little test file to show how this looks like::
 
 then you will see two test skipped and two executed tests as expected::
 
-    $ py.test -rs # this option reports skip reasons
+    $ pytest -rs # this option reports skip reasons
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 4 items
     
@@ -497,15 +497,15 @@ then you will see two test skipped and two executed tests as expected::
 
 Note that if you specify a platform via the marker-command line option like this::
 
-    $ py.test -m linux2
+    $ pytest -m linux2
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 4 items
     
     test_plat.py s
     
-    ======= 3 tests deselected by "-m 'linux2'" ========
+    ======= 3 tests deselected ========
     ======= 1 skipped, 3 deselected in 0.12 seconds ========
 
 then the unmarked-tests will not be run.  It is thus a way to restrict the run to the specific tests.
@@ -549,9 +549,9 @@ We want to dynamically define two markers and can do it in a
 
 We can now use the ``-m option`` to select one set::
 
-  $ py.test -m interface --tb=short
+  $ pytest -m interface --tb=short
   ======= test session starts ========
-  platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+  platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
   rootdir: $REGENDOC_TMPDIR, inifile: 
   collected 4 items
   
@@ -566,14 +566,14 @@ We can now use the ``-m option`` to select one set::
   test_module.py:6: in test_interface_complex
       assert 0
   E   assert 0
-  ======= 2 tests deselected by "-m 'interface'" ========
+  ======= 2 tests deselected ========
   ======= 2 failed, 2 deselected in 0.12 seconds ========
 
 or to select both "event" and "interface" tests::
 
-  $ py.test -m "interface or event" --tb=short
+  $ pytest -m "interface or event" --tb=short
   ======= test session starts ========
-  platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+  platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
   rootdir: $REGENDOC_TMPDIR, inifile: 
   collected 4 items
   
@@ -592,5 +592,5 @@ or to select both "event" and "interface" tests::
   test_module.py:9: in test_event_simple
       assert 0
   E   assert 0
-  ======= 1 tests deselected by "-m 'interface or event'" ========
+  ======= 1 tests deselected ========
   ======= 3 failed, 1 deselected in 0.12 seconds ========

doc/en/example/multipython.py

@@ -6,7 +6,7 @@ import py
 import pytest
 import _pytest._code
 
-pythonlist = ['python2.6', 'python2.7', 'python3.3']
+pythonlist = ['python2.6', 'python2.7', 'python3.4', 'python3.5']
 @pytest.fixture(params=pythonlist)
 def python1(request, tmpdir):
     picklefile = tmpdir.join("data.pickle")

doc/en/example/nonpython.rst

@@ -25,13 +25,13 @@ You can create a simple example file:
 and if you installed `PyYAML`_ or a compatible YAML-parser you can
 now execute the test specification::
 
-    nonpython $ py.test test_simple.yml
+    nonpython $ pytest test_simple.yml
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR/nonpython, inifile: 
     collected 2 items
     
-    test_simple.yml .F
+    test_simple.yml F.
     
     ======= FAILURES ========
     _______ usecase: hello ________
@@ -57,15 +57,15 @@ your own domain specific testing language this way.
 ``reportinfo()`` is used for representing the test location and is also
 consulted when reporting in ``verbose`` mode::
 
-    nonpython $ py.test -v
+    nonpython $ pytest -v
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.5
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0 -- $PYTHON_PREFIX/bin/python3.5
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR/nonpython, inifile: 
     collecting ... collected 2 items
     
-    test_simple.yml::ok PASSED
     test_simple.yml::hello FAILED
+    test_simple.yml::ok PASSED
     
     ======= FAILURES ========
     _______ usecase: hello ________
@@ -79,13 +79,13 @@ consulted when reporting in ``verbose`` mode::
 While developing your custom test collection and execution it's also
 interesting to just look at the collection tree::
 
-    nonpython $ py.test --collect-only
+    nonpython $ pytest --collect-only
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR/nonpython, inifile: 
     collected 2 items
     <YamlFile 'test_simple.yml'>
-      <YamlItem 'ok'>
       <YamlItem 'hello'>
+      <YamlItem 'ok'>
     
     ======= no tests ran in 0.12 seconds ========

doc/en/example/nonpython/conftest.py

@@ -10,7 +10,7 @@ class YamlFile(pytest.File):
     def collect(self):
         import yaml # we need a yaml parser, e.g. PyYAML
         raw = yaml.safe_load(self.fspath.open())
-        for name, spec in raw.items():
+        for name, spec in sorted(raw.items()):
             yield YamlItem(name, self, spec)
 
 class YamlItem(pytest.Item):
@@ -19,7 +19,7 @@ class YamlItem(pytest.Item):
         self.spec = spec
 
     def runtest(self):
-        for name, value in self.spec.items():
+        for name, value in sorted(self.spec.items()):
             # some custom test execution (dumb example follows)
             if name != value:
                 raise YamlException(self, name, value)

doc/en/example/parametrize.rst

@@ -44,14 +44,14 @@ Now we add a test configuration like this::
 
 This means that we only run 2 tests if we do not pass ``--all``::
 
-    $ py.test -q test_compute.py
+    $ pytest -q test_compute.py
     ..
     2 passed in 0.12 seconds
 
 We run only two computations, so we see two dots.
 let's run the full monty::
 
-    $ py.test -q --all
+    $ pytest -q --all
     ....F
     ======= FAILURES ========
     _______ test_compute[4] ________
@@ -128,9 +128,9 @@ label generated by ``idfn``, but because we didn't generate a label for ``timede
 objects, they are still using the default pytest representation::
 
 
-    $ py.test test_time.py --collect-only
+    $ pytest test_time.py --collect-only
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 6 items
     <Module 'test_time.py'>
@@ -179,9 +179,9 @@ only have to work a bit to construct the correct arguments for pytest's
 
 this is a fully self-contained example which you can run with::
 
-    $ py.test test_scenarios.py
+    $ pytest test_scenarios.py
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 4 items
     
@@ -192,9 +192,9 @@ this is a fully self-contained example which you can run with::
 If you just collect tests you'll also nicely see 'advanced' and 'basic' as variants for the test function::
 
 
-    $ py.test --collect-only test_scenarios.py
+    $ pytest --collect-only test_scenarios.py
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 4 items
     <Module 'test_scenarios.py'>
@@ -257,9 +257,9 @@ creates a database object for the actual test invocations::
 
 Let's first see how it looks like at collection time::
 
-    $ py.test test_backends.py --collect-only
+    $ pytest test_backends.py --collect-only
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     <Module 'test_backends.py'>
@@ -270,7 +270,7 @@ Let's first see how it looks like at collection time::
 
 And then when we run the test::
 
-    $ py.test -q test_backends.py
+    $ pytest -q test_backends.py
     .F
     ======= FAILURES ========
     _______ test_db_initialized[d2] ________
@@ -318,9 +318,9 @@ will be passed to respective fixture function::
 
 The result of this test will be successful::
 
-    $ py.test test_indirect_list.py --collect-only
+    $ pytest test_indirect_list.py --collect-only
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     <Module 'test_indirect_list.py'>
@@ -346,7 +346,7 @@ parametrizer`_ but in a lot less code::
     def pytest_generate_tests(metafunc):
         # called once per each test function
         funcarglist = metafunc.cls.params[metafunc.function.__name__]
-        argnames = list(funcarglist[0])
+        argnames = sorted(funcarglist[0])
         metafunc.parametrize(argnames, [[funcargs[name] for name in argnames]
                 for funcargs in funcarglist])
 
@@ -366,7 +366,7 @@ parametrizer`_ but in a lot less code::
 Our test generator looks up a class-level definition which specifies which
 argument sets to use for each test function.  Let's run it::
 
-    $ py.test -q
+    $ pytest -q
     F..
     ======= FAILURES ========
     _______ TestClass.test_equals[1-2] ________
@@ -396,9 +396,11 @@ is to be run with different sets of arguments for its three arguments:
 
 Running it results in some skips if we don't have all the python interpreters installed and otherwise runs all combinations (5 interpreters times 5 interpreters times 3 objects to serialize/deserialize)::
 
-   . $ py.test -rs -q multipython.py
-   ...........................
-   27 passed in 0.12 seconds
+   . $ pytest -rs -q multipython.py
+   sssssssssssssss.........sss.........sss.........
+   ======= short test summary info ========
+   SKIP [21] $REGENDOC_TMPDIR/CWD/multipython.py:23: 'python2.6' not found
+   27 passed, 21 skipped in 0.12 seconds
 
 Indirect parametrization of optional implementations/imports
 --------------------------------------------------------------------
@@ -443,9 +445,9 @@ And finally a little test module::
 
 If you run this with reporting for skips enabled::
 
-    $ py.test -rs test_module.py
+    $ pytest -rs test_module.py
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     

doc/en/example/pythoncollection.py

@@ -1,5 +1,5 @@
 
-# run this with $ py.test --collect-only test_collectonly.py
+# run this with $ pytest --collect-only test_collectonly.py
 #
 def test_function():
     pass

doc/en/example/pythoncollection.rst

@@ -40,12 +40,46 @@ you will see that ``pytest`` only collects test-modules, which do not match the
     ======= 5 passed in 0.02 seconds =======
 
 
+Keeping duplicate paths specified from command line
+----------------------------------------------------
+
+Default behavior of ``pytest`` is to ignore duplicate paths specified from the command line.
+Example::
+
+    py.test path_a path_a
+
+    ...
+    collected 1 item
+    ...
+
+Just collect tests once.
+
+To collect duplicate tests, use the ``--keep-duplicates`` option on the cli.
+Example::
+
+    py.test --keep-duplicates path_a path_a
+
+    ...
+    collected 2 items
+    ...
+
+As the collector just works on directories, if you specify twice a single test file, ``pytest`` will
+still collect it twice, no matter if the ``--keep-duplicates`` is not specified.
+Example::
+
+    py.test test_a.py test_a.py
+
+    ...
+    collected 2 items
+    ...
+
+
 Changing directory recursion
 -----------------------------------------------------
 
-You can set the :confval:`norecursedirs` option in an ini-file, for example your ``setup.cfg`` in the project root directory::
+You can set the :confval:`norecursedirs` option in an ini-file, for example your ``pytest.ini`` in the project root directory::
 
-    # content of setup.cfg
+    # content of pytest.ini
     [pytest]
     norecursedirs = .svn _build tmp*
 
@@ -60,8 +94,9 @@ You can configure different naming conventions by setting
 the :confval:`python_files`, :confval:`python_classes` and
 :confval:`python_functions` configuration options.  Example::
 
-    # content of setup.cfg
-    # can also be defined in in tox.ini or pytest.ini file
+    # content of pytest.ini
+    # can also be defined in in tox.ini or setup.cfg file, although the section
+    # name in setup.cfg files should be "tool:pytest"
     [pytest]
     python_files=check_*.py
     python_classes=Check
@@ -80,10 +115,10 @@ that match ``*_check``.  For example, if we have::
 
 then the test collection looks like this::
 
-    $ py.test --collect-only
+    $ pytest --collect-only
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
-    rootdir: $REGENDOC_TMPDIR, inifile: setup.cfg
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
+    rootdir: $REGENDOC_TMPDIR, inifile: pytest.ini
     collected 2 items
     <Module 'check_myapp.py'>
       <Class 'CheckMyApp'>
@@ -107,7 +142,7 @@ interpreting arguments as python package names, deriving
 their file system path and then running the test. For
 example if you have unittest2 installed you can type::
 
-    py.test --pyargs unittest2.test.test_skipping -q
+    pytest --pyargs unittest2.test.test_skipping -q
 
 which would run the respective test module.  Like with
 other options, through an ini-file and the :confval:`addopts` option you
@@ -117,7 +152,7 @@ can make this change more permanently::
     [pytest]
     addopts = --pyargs
 
-Now a simple invocation of ``py.test NAME`` will check
+Now a simple invocation of ``pytest NAME`` will check
 if NAME exists as an importable package/module and otherwise
 treat it as a filesystem path.
 
@@ -126,9 +161,9 @@ Finding out what is collected
 
 You can always peek at the collection tree without running tests like this::
 
-    . $ py.test --collect-only pythoncollection.py
+    . $ pytest --collect-only pythoncollection.py
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: pytest.ini
     collected 3 items
     <Module 'CWD/pythoncollection.py'>
@@ -180,7 +215,7 @@ and a setup.py dummy file like this::
 then a pytest run on Python2 will find the one test and will leave out the
 setup.py file::
 
-    #$ py.test --collect-only
+    #$ pytest --collect-only
     ====== test session starts ======
     platform linux2 -- Python 2.7.10, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: pytest.ini
@@ -193,9 +228,9 @@ setup.py file::
 If you run with a Python3 interpreter both the one test and the setup.py file
 will be left out::
 
-    $ py.test --collect-only
+    $ pytest --collect-only
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: pytest.ini
     collected 0 items
     

doc/en/example/reportingdemo.rst

@@ -7,13 +7,11 @@ Demo of Python failure reports with pytest
 Here is a nice run of several tens of failures
 and how ``pytest`` presents things (unfortunately
 not showing the nice colors here in the HTML that you
-get on the terminal - we are working on that):
+get on the terminal - we are working on that)::
 
-.. code-block:: python
-
-    assertion $ py.test failure_demo.py
+    assertion $ pytest failure_demo.py
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR/assertion, inifile: 
     collected 42 items
     
@@ -361,7 +359,7 @@ get on the terminal - we are working on that):
     >   int(s)
     E   ValueError: invalid literal for int() with base 10: 'qwe'
     
-    <0-codegen $PYTHON_PREFIX/lib/python3.5/site-packages/_pytest/python.py:1309>:1: ValueError
+    <0-codegen $PYTHON_PREFIX/lib/python3.5/site-packages/_pytest/python.py:1207>:1: ValueError
     _______ TestRaises.test_raises_doesnt ________
     
     self = <failure_demo.TestRaises object at 0xdeadbeef>
@@ -427,7 +425,7 @@ get on the terminal - we are working on that):
     
         def foo():
     >    assert 1 == 0
-    E    assert 1 == 0
+    E    AssertionError
     
     <2-codegen 'abc-123' $REGENDOC_TMPDIR/assertion/failure_demo.py:163>:2: AssertionError
     _______ TestMoreErrors.test_complex_error ________
@@ -482,8 +480,9 @@ get on the terminal - we are working on that):
             s = "123"
             g = "456"
     >       assert s.startswith(g)
-    E       assert <built-in method startswith of str object at 0xdeadbeef>('456')
-    E        +  where <built-in method startswith of str object at 0xdeadbeef> = '123'.startswith
+    E       assert False
+    E        +  where False = <built-in method startswith of str object at 0xdeadbeef>('456')
+    E        +    where <built-in method startswith of str object at 0xdeadbeef> = '123'.startswith
     
     failure_demo.py:189: AssertionError
     _______ TestMoreErrors.test_startswith_nested ________
@@ -496,10 +495,11 @@ get on the terminal - we are working on that):
             def g():
                 return "456"
     >       assert f().startswith(g())
-    E       assert <built-in method startswith of str object at 0xdeadbeef>('456')
-    E        +  where <built-in method startswith of str object at 0xdeadbeef> = '123'.startswith
-    E        +    where '123' = <function TestMoreErrors.test_startswith_nested.<locals>.f at 0xdeadbeef>()
-    E        +  and   '456' = <function TestMoreErrors.test_startswith_nested.<locals>.g at 0xdeadbeef>()
+    E       assert False
+    E        +  where False = <built-in method startswith of str object at 0xdeadbeef>('456')
+    E        +    where <built-in method startswith of str object at 0xdeadbeef> = '123'.startswith
+    E        +      where '123' = <function TestMoreErrors.test_startswith_nested.<locals>.f at 0xdeadbeef>()
+    E        +    and   '456' = <function TestMoreErrors.test_startswith_nested.<locals>.g at 0xdeadbeef>()
     
     failure_demo.py:196: AssertionError
     _______ TestMoreErrors.test_global_func ________
@@ -508,8 +508,9 @@ get on the terminal - we are working on that):
     
         def test_global_func(self):
     >       assert isinstance(globf(42), float)
-    E       assert isinstance(43, float)
-    E        +  where 43 = globf(42)
+    E       assert False
+    E        +  where False = isinstance(43, float)
+    E        +    where 43 = globf(42)
     
     failure_demo.py:199: AssertionError
     _______ TestMoreErrors.test_instance ________

doc/en/example/simple.rst

@@ -1,5 +1,4 @@
 
-.. highlightlang:: python
 
 Basic patterns and examples
 ==========================================================
@@ -10,7 +9,9 @@ Pass different values to a test function, depending on command line options
 .. regendoc:wipe
 
 Suppose we want to write a test that depends on a command line option.
-Here is a basic pattern to achieve this::
+Here is a basic pattern to achieve this:
+
+.. code-block:: python
 
     # content of test_sample.py
     def test_answer(cmdopt):
@@ -22,7 +23,9 @@ Here is a basic pattern to achieve this::
 
 
 For this to work we need to add a command line option and
-provide the ``cmdopt`` through a :ref:`fixture function <fixture function>`::
+provide the ``cmdopt`` through a :ref:`fixture function <fixture function>`:
+
+.. code-block:: python
 
     # content of conftest.py
     import pytest
@@ -37,7 +40,7 @@ provide the ``cmdopt`` through a :ref:`fixture function <fixture function>`::
 
 Let's run this without supplying our new option::
 
-    $ py.test -q test_sample.py
+    $ pytest -q test_sample.py
     F
     ======= FAILURES ========
     _______ test_answer ________
@@ -59,7 +62,7 @@ Let's run this without supplying our new option::
 
 And now with supplying a command line option::
 
-    $ py.test -q --cmdopt=type2
+    $ pytest -q --cmdopt=type2
     F
     ======= FAILURES ========
     _______ test_answer ________
@@ -91,7 +94,9 @@ Dynamically adding command line options
 
 Through :confval:`addopts` you can statically add command line
 options for your project.  You can also dynamically modify
-the command line arguments before they get processed::
+the command line arguments before they get processed:
+
+.. code-block:: python
 
     # content of conftest.py
     import sys
@@ -101,14 +106,14 @@ the command line arguments before they get processed::
             num = max(multiprocessing.cpu_count() / 2, 1)
             args[:] = ["-n", str(num)] + args
 
-If you have the :ref:`xdist plugin <xdist>` installed
+If you have the `xdist plugin <https://pypi.python.org/pypi/pytest-xdist>`_ installed
 you will now always perform test runs using a number
 of subprocesses close to your CPU. Running in an empty
 directory with the above conftest.py::
 
-    $ py.test
+    $ pytest
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 0 items
     
@@ -122,7 +127,9 @@ Control skipping of tests according to command line option
 .. regendoc:wipe
 
 Here is a ``conftest.py`` file adding a ``--runslow`` command
-line option to control skipping of ``slow`` marked tests::
+line option to control skipping of ``slow`` marked tests:
+
+.. code-block:: python
 
     # content of conftest.py
 
@@ -131,10 +138,11 @@ line option to control skipping of ``slow`` marked tests::
         parser.addoption("--runslow", action="store_true",
             help="run slow tests")
 
-We can now write a test module like this::
+We can now write a test module like this:
+
+.. code-block:: python
 
     # content of test_module.py
-
     import pytest
 
 
@@ -154,23 +162,23 @@ We can now write a test module like this::
 
 and when running it will see a skipped "slow" test::
 
-    $ py.test -rs    # "-rs" means report details on the little 's'
+    $ pytest -rs    # "-rs" means report details on the little 's'
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     
     test_module.py .s
     ======= short test summary info ========
-    SKIP [1] test_module.py:14: need --runslow option to run
+    SKIP [1] test_module.py:13: need --runslow option to run
     
     ======= 1 passed, 1 skipped in 0.12 seconds ========
 
 Or run it including the ``slow`` marked test::
 
-    $ py.test --runslow
+    $ pytest --runslow
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     
@@ -187,7 +195,9 @@ If you have a test helper function called from a test you can
 use the ``pytest.fail`` marker to fail a test with a certain message.
 The test support function will not show up in the traceback if you
 set the ``__tracebackhide__`` option somewhere in the helper function.
-Example::
+Example:
+
+.. code-block:: python
 
     # content of test_checkconfig.py
     import pytest
@@ -204,7 +214,7 @@ of tracebacks: the ``checkconfig`` function will not be shown
 unless the ``--full-trace`` command line option is specified.
 Let's run our little function::
 
-    $ py.test -q test_checkconfig.py
+    $ pytest -q test_checkconfig.py
     F
     ======= FAILURES ========
     _______ test_something ________
@@ -216,6 +226,30 @@ Let's run our little function::
     test_checkconfig.py:8: Failed
     1 failed in 0.12 seconds
 
+If you only want to hide certain exceptions, you can set ``__tracebackhide__``
+to a callable which gets the ``ExceptionInfo`` object. You can for example use
+this to make sure unexpected exception types aren't hidden:
+
+.. code-block:: python
+
+    import operator
+    import pytest
+
+    class ConfigException(Exception):
+        pass
+
+    def checkconfig(x):
+        __tracebackhide__ = operator.methodcaller('errisinstance', ConfigException)
+        if not hasattr(x, "config"):
+            raise ConfigException("not configured: %s" %(x,))
+
+    def test_something():
+        checkconfig(42)
+
+This will avoid hiding the exception traceback on unrelated exceptions (i.e.
+bugs in assertion helpers).
+
+
 Detect if running from within a pytest run
 --------------------------------------------------------------
 
@@ -224,7 +258,9 @@ Detect if running from within a pytest run
 Usually it is a bad idea to make application code
 behave differently if called from a test.  But if you
 absolutely must find out if your application code is
-running from a test you can do something like this::
+running from a test you can do something like this:
+
+.. code-block:: python
 
     # content of conftest.py
 
@@ -235,7 +271,9 @@ running from a test you can do something like this::
     def pytest_unconfigure(config):
         del sys._called_from_test
 
-and then check for the ``sys._called_from_test`` flag::
+and then check for the ``sys._called_from_test`` flag:
+
+.. code-block:: python
 
     if hasattr(sys, '_called_from_test'):
         # called from within a test run
@@ -251,7 +289,9 @@ Adding info to test report header
 
 .. regendoc:wipe
 
-It's easy to present extra information in a ``pytest`` run::
+It's easy to present extra information in a ``pytest`` run:
+
+.. code-block:: python
 
     # content of conftest.py
 
@@ -260,9 +300,9 @@ It's easy to present extra information in a ``pytest`` run::
 
 which will add the string to the test header accordingly::
 
-    $ py.test
+    $ pytest
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     project deps: mylib-1.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 0 items
@@ -271,22 +311,23 @@ which will add the string to the test header accordingly::
 
 .. regendoc:wipe
 
-You can also return a list of strings which will be considered as several
-lines of information.  You can of course also make the amount of reporting
-information on e.g. the value of ``config.option.verbose`` so that
-you present more information appropriately::
+It is also possible to return a list of strings which will be considered as several
+lines of information. You may consider ``config.getoption('verbose')`` in order to
+display more information if applicable:
+
+.. code-block:: python
 
     # content of conftest.py
 
     def pytest_report_header(config):
-        if config.option.verbose > 0:
+        if config.getoption('verbose') > 0:
             return ["info1: did you know that ...", "did you?"]
 
 which will add info only when run with "--v"::
 
-    $ py.test -v
+    $ pytest -v
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.5
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0 -- $PYTHON_PREFIX/bin/python3.5
     cachedir: .cache
     info1: did you know that ...
     did you?
@@ -297,9 +338,9 @@ which will add info only when run with "--v"::
 
 and nothing when run plainly::
 
-    $ py.test
+    $ pytest
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 0 items
     
@@ -313,10 +354,11 @@ profiling test duration
 .. versionadded: 2.2
 
 If you have a slow running large test suite you might want to find
-out which tests are the slowest. Let's make an artificial test suite::
+out which tests are the slowest. Let's make an artificial test suite:
+
+.. code-block:: python
 
     # content of test_some_are_slow.py
-
     import time
 
     def test_funcfast():
@@ -330,9 +372,9 @@ out which tests are the slowest. Let's make an artificial test suite::
 
 Now we can profile which test functions execute the slowest::
 
-    $ py.test --durations=3
+    $ pytest --durations=3
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 3 items
     
@@ -341,7 +383,7 @@ Now we can profile which test functions execute the slowest::
     ======= slowest 3 test durations ========
     0.20s call     test_some_are_slow.py::test_funcslow2
     0.10s call     test_some_are_slow.py::test_funcslow1
-    0.00s teardown test_some_are_slow.py::test_funcslow2
+    0.00s setup    test_some_are_slow.py::test_funcfast
     ======= 3 passed in 0.12 seconds ========
 
 incremental testing - test steps
@@ -353,7 +395,9 @@ Sometimes you may have a testing situation which consists of a series
 of test steps.  If one step fails it makes no sense to execute further
 steps as they are all expected to fail anyway and their tracebacks
 add no insight.  Here is a simple ``conftest.py`` file which introduces
-an ``incremental`` marker which is to be used on classes::
+an ``incremental`` marker which is to be used on classes:
+
+.. code-block:: python
 
     # content of conftest.py
 
@@ -372,7 +416,9 @@ an ``incremental`` marker which is to be used on classes::
                 pytest.xfail("previous test failed (%s)" %previousfailed.name)
 
 These two hook implementations work together to abort incremental-marked
-tests in a class.  Here is a test module example::
+tests in a class.  Here is a test module example:
+
+.. code-block:: python
 
     # content of test_step.py
 
@@ -392,9 +438,9 @@ tests in a class.  Here is a test module example::
 
 If we run this::
 
-    $ py.test -rx
+    $ pytest -rx
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 4 items
     
@@ -430,7 +476,9 @@ concept.  It's however recommended to have explicit fixture references in your
 tests or test classes rather than relying on implicitly executing
 setup/teardown functions, especially if they are far away from the actual tests.
 
-Here is a an example for making a ``db`` fixture available in a directory::
+Here is a an example for making a ``db`` fixture available in a directory:
+
+.. code-block:: python
 
     # content of a/conftest.py
     import pytest
@@ -442,20 +490,26 @@ Here is a an example for making a ``db`` fixture available in a directory::
     def db():
         return DB()
 
-and then a test module in that directory::
+and then a test module in that directory:
+
+.. code-block:: python
 
     # content of a/test_db.py
     def test_a1(db):
         assert 0, db  # to show value
 
-another test module::
+another test module:
+
+.. code-block:: python
 
     # content of a/test_db2.py
     def test_a2(db):
         assert 0, db  # to show value
 
 and then a module in a sister directory which will not see
-the ``db`` fixture::
+the ``db`` fixture:
+
+.. code-block:: python
 
     # content of b/test_error.py
     def test_root(db):  # no db here, will error out
@@ -463,9 +517,9 @@ the ``db`` fixture::
 
 We can run this::
 
-    $ py.test
+    $ pytest
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 7 items
     
@@ -478,9 +532,9 @@ We can run this::
     _______ ERROR at setup of test_root ________
     file $REGENDOC_TMPDIR/b/test_error.py, line 1
       def test_root(db):  # no db here, will error out
-            fixture 'db' not found
-            available fixtures: tmpdir_factory, cache, tmpdir, pytestconfig, recwarn, monkeypatch, capfd, record_xml_property, capsys
-            use 'py.test --fixtures [testpath]' for help on them.
+    E       fixture 'db' not found
+    >       available fixtures: cache, capfd, capsys, doctest_namespace, monkeypatch, pytestconfig, record_xml_property, recwarn, tmpdir, tmpdir_factory
+    >       use 'pytest --fixtures [testpath]' for help on them.
     
     $REGENDOC_TMPDIR/b/test_error.py:1
     ======= FAILURES ========
@@ -531,7 +585,9 @@ environment you can implement a hook that gets called when the test
 "report" object is about to be created.  Here we write out all failing
 test calls and also access a fixture (if it was used by the test) in
 case you want to query/look at it during your post processing.  In our
-case we just write some informations out to a ``failures`` file::
+case we just write some informations out to a ``failures`` file:
+
+.. code-block:: python
 
     # content of conftest.py
 
@@ -557,7 +613,9 @@ case we just write some informations out to a ``failures`` file::
                 f.write(rep.nodeid + extra + "\n")
 
 
-if you then have failing tests::
+if you then have failing tests:
+
+.. code-block:: python
 
     # content of test_module.py
     def test_fail1(tmpdir):
@@ -567,9 +625,9 @@ if you then have failing tests::
 
 and run them::
 
-    $ py.test test_module.py
+    $ pytest test_module.py
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     
@@ -606,7 +664,9 @@ Making test result information available in fixtures
 .. regendoc:wipe
 
 If you want to make test result reports available in fixture finalizers
-here is a little example implemented via a local plugin::
+here is a little example implemented via a local plugin:
+
+.. code-block:: python
 
     # content of conftest.py
 
@@ -626,18 +686,19 @@ here is a little example implemented via a local plugin::
 
     @pytest.fixture
     def something(request):
-        def fin():
-            # request.node is an "item" because we use the default
-            # "function" scope
-            if request.node.rep_setup.failed:
-                print ("setting up a test failed!", request.node.nodeid)
-            elif request.node.rep_setup.passed:
-                if request.node.rep_call.failed:
-                    print ("executing test failed", request.node.nodeid)
-        request.addfinalizer(fin)
+        yield
+        # request.node is an "item" because we use the default
+        # "function" scope
+        if request.node.rep_setup.failed:
+            print ("setting up a test failed!", request.node.nodeid)
+        elif request.node.rep_setup.passed:
+            if request.node.rep_call.failed:
+                print ("executing test failed", request.node.nodeid)
 
 
-if you then have failing tests::
+if you then have failing tests:
+
+.. code-block:: python
 
     # content of test_module.py
 
@@ -658,9 +719,9 @@ if you then have failing tests::
 
 and run it::
 
-    $ py.test -s test_module.py
+    $ pytest -s test_module.py
     ======= test session starts ========
-    platform linux -- Python 3.5.1, pytest-2.9.2, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.5.2, pytest-3.0.5, py-1.4.31, pluggy-0.4.0
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 3 items
     
@@ -699,40 +760,29 @@ and run it::
 You'll see that the fixture finalizers could use the precise reporting
 information.
 
-Integrating pytest runner and cx_freeze
------------------------------------------------------------
+Freezing pytest 
+---------------
 
 If you freeze your application using a tool like
-`cx_freeze <https://cx-freeze.readthedocs.io>`_ in order to distribute it
-to your end-users, it is a good idea to also package your test runner and run
-your tests using the frozen application.
+`PyInstaller <https://pyinstaller.readthedocs.io>`_
+in order to distribute it to your end-users, it is a good idea to also package
+your test runner and run your tests using the frozen application. This way packaging
+errors such as dependencies not being included into the executable can be detected early
+while also allowing you to send test files to users so they can run them in their
+machines, which can be useful to obtain more information about a hard to reproduce bug.
 
-This way packaging errors such as dependencies not being
-included into the executable can be detected early while also allowing you to
-send test files to users so they can run them in their machines, which can be
-invaluable to obtain more information about a hard to reproduce bug.
+Fortunately recent ``PyInstaller`` releases already have a custom hook
+for pytest, but if you are using another tool to freeze executables 
+such as ``cx_freeze`` or ``py2exe``, you can use ``pytest.freeze_includes()``
+to obtain the full list of internal pytest modules. How to configure the tools
+to find the internal modules varies from tool to tool, however.
 
-Unfortunately ``cx_freeze`` can't discover them
-automatically because of ``pytest``'s use of dynamic module loading, so you
-must declare them explicitly by using ``pytest.freeze_includes()``::
+Instead of freezing the pytest runner as a separate executable, you can make 
+your frozen program work as the pytest runner by some clever
+argument handling during program startup. This allows you to 
+have a single executable, which is usually more convenient.
 
-    # contents of setup.py
-    from cx_Freeze import setup, Executable
-    import pytest
-
-    setup(
-        name="app_main",
-        executables=[Executable("app_main.py")],
-        options={"build_exe":
-            {
-            'includes': pytest.freeze_includes()}
-            },
-        # ... other options
-    )
-
-If you don't want to ship a different executable just in order to run your tests,
-you can make your program check for a certain flag and pass control
-over to ``pytest`` instead. For example::
+.. code-block:: python
 
     # contents of app_main.py
     import sys
@@ -745,7 +795,8 @@ over to ``pytest`` instead. For example::
         # by your argument-parsing library of choice as usual
         ...
 
-This makes it convenient to execute your tests from within your frozen
-application, using standard ``py.test`` command-line options::
+
+This allows you to execute tests using the frozen
+application with standard ``pytest`` command-line options::
 
     ./app_main --pytest --verbose --tb=long --junitxml=results.xml test-suite/

doc/en/example/special.rst

@@ -59,7 +59,7 @@ will be called ahead of running any tests::
 
 If you run this without output capturing::
 
-    $ py.test -q -s test_module.py
+    $ pytest -q -s test_module.py
     callattr_ahead_of_alltests called
     callme called!
     callme other called