Preparing release version 3.2.4

Pin py<1.5 as 1.5 drops py26 and py33 support

.github/PULL_REQUEST_TEMPLATE.md

@@ -12,4 +12,4 @@ Here's a quick checklist that should be present in PRs:
 
 Unless your change is a trivial or a documentation fix (e.g.,  a typo or reword of a small section) please:
 
-- [ ] Add yourself to `AUTHORS`;
+- [ ] Add yourself to `AUTHORS`, in alphabetical order;

.travis.yml

@@ -1,9 +1,10 @@
 sudo: false
 language: python
 python:
-    - '3.5'
+  - '3.6'
 # command to install dependencies
-install: "pip install -U tox"
+install:
+  - pip install --upgrade --pre tox
 # # command to run tests
 env:
   matrix:
@@ -11,27 +12,33 @@ env:
     - 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=py36
     - TOXENV=py27-pexpect
     - TOXENV=py27-xdist
     - TOXENV=py27-trial
-    - TOXENV=py35-pexpect
-    - TOXENV=py35-xdist
-    - TOXENV=py35-trial
+    - TOXENV=py27-numpy
+    - TOXENV=py36-pexpect
+    - TOXENV=py36-xdist
+    - TOXENV=py36-trial
+    - TOXENV=py36-numpy
     - TOXENV=py27-nobyte
     - TOXENV=doctesting
-    - TOXENV=freeze
     - TOXENV=docs
 
 matrix:
   include:
-    - env: TOXENV=py36
-      python: '3.6'
+    - env: TOXENV=py26
+      python: '2.6'
+    - env: TOXENV=py33
+      python: '3.3'
+    - env: TOXENV=pypy
+      python: 'pypy-5.4'
+    - env: TOXENV=py35
+      python: '3.5'
+    - env: TOXENV=py35-freeze
+      python: '3.5'
     - env: TOXENV=py37
       python: 'nightly'
   allow_failures:

AUTHORS

@@ -9,6 +9,7 @@ Ahn Ki-Wook
 Alexander Johnson
 Alexei Kozlenok
 Anatoly Bubenkoff
+Andras Tim
 Andreas Zeidler
 Andrzej Ostrowski
 Andy Freeland
@@ -45,6 +46,7 @@ Dave Hunt
 David Díaz-Barquero
 David Mohr
 David Vierra
+Daw-Ran Liou
 Denis Kirisov
 Diego Russo
 Dmitry Dygalo
@@ -83,6 +85,7 @@ John Towler
 Jon Sonesen
 Jonas Obrist
 Jordan Guymon
+Jordan Moldow
 Joshua Bronson
 Jurko Gospodnetić
 Justyna Janczyszyn
@@ -90,13 +93,16 @@ Kale Kundert
 Katarzyna Jachim
 Kevin Cox
 Kodi B. Arfer
+Lawrence Mitchell
 Lee Kamentsky
 Lev Maximov
+Llandy Riveron Del Risco
 Loic Esteve
 Lukas Bednar
 Luke Murphy
 Maciek Fijalkowski
 Maho
+Maik Figura
 Mandeep Bhutani
 Manuel Krebber
 Marc Schlaich
@@ -104,6 +110,7 @@ Marcin Bachry
 Mark Abramowitz
 Markus Unterwaditzer
 Martijn Faassen
+Martin Altmayer
 Martin K. Scherer
 Martin Prusse
 Mathieu Clabaut
@@ -117,7 +124,9 @@ Michael Birtwell
 Michael Droettboom
 Michael Seifert
 Michal Wajszczuk
+Mihai Capotă
 Mike Lundy
+Nathaniel Waisbrot
 Ned Batchelder
 Neven Mundar
 Nicolas Delaby
@@ -147,6 +156,7 @@ Samuele Pedroni
 Segev Finer
 Simon Gomizelj
 Skylar Downes
+Srinivas Reddy Thatiparthy
 Stefan Farmbauer
 Stefan Zimmermann
 Stefano Taschini
@@ -155,6 +165,7 @@ Stephan Obermann
 Tareq Alayan
 Ted Xiao
 Thomas Grainger
+Tom Dalton
 Tom Viner
 Trevor Bekolay
 Tyler Goodlet
@@ -164,4 +175,6 @@ Vidar T. Fauske
 Vitaly Lashmanov
 Vlad Dragos
 Wouter van Ackooy
+Xuan Luong
 Xuecong Liao
+Zoltán Máté

CHANGELOG.rst

@@ -8,6 +8,382 @@
 
 .. towncrier release notes start
 
+Pytest 3.2.4 (2017-11-13)
+=========================
+
+Bug Fixes
+---------
+
+- Fix the bug where running pytest with "--pyargs" will result in Items with
+  empty "parent.nodeid" if run from a different root directory. (`#2775
+  <https://github.com/pytest-dev/pytest/issues/2775>`_)
+
+- Fix issue with @pytest.parametrize if argnames was specified as kwarg.
+  (`#2819 <https://github.com/pytest-dev/pytest/issues/2819>`_)
+
+- Strip whitespace from marker names when reading them from INI config. (`#2856
+  <https://github.com/pytest-dev/pytest/issues/2856>`_)
+
+- Show full context of doctest source in the pytest output, if the lineno of
+  failed example in the docstring is < 9. (`#2882
+  <https://github.com/pytest-dev/pytest/issues/2882>`_)
+
+
+Improved Documentation
+----------------------
+
+- Introduce a dedicated section about conftest.py. (`#1505
+  <https://github.com/pytest-dev/pytest/issues/1505>`_)
+
+- Explicitly mention ``xpass`` in the documentation of ``xfail``. (`#1997
+  <https://github.com/pytest-dev/pytest/issues/1997>`_)
+
+- Append example for pytest.param in the example/parametrize document. (`#2658
+  <https://github.com/pytest-dev/pytest/issues/2658>`_)
+
+- Clarify language of proposal for fixtures parameters (`#2893
+  <https://github.com/pytest-dev/pytest/issues/2893>`_)
+
+- List python 3.6 in the documented supported versions in the getting started
+  document. (`#2903 <https://github.com/pytest-dev/pytest/issues/2903>`_)
+
+- Clarify the documentation of available fixture scopes. (`#538
+  <https://github.com/pytest-dev/pytest/issues/538>`_)
+
+- Add documentation about the ``python -m pytest`` invocation adding the
+  current directory to sys.path. (`#911
+  <https://github.com/pytest-dev/pytest/issues/911>`_)
+
+
+Pytest 3.2.3 (2017-10-03)
+=========================
+
+Bug Fixes
+---------
+
+- Fix crash in tab completion when no prefix is given. (`#2748
+  <https://github.com/pytest-dev/pytest/issues/2748>`_)
+
+- The equality checking function (``__eq__``) of ``MarkDecorator`` returns
+  ``False`` if one object is not an instance of ``MarkDecorator``. (`#2758
+  <https://github.com/pytest-dev/pytest/issues/2758>`_)
+
+- When running ``pytest --fixtures-per-test``: don't crash if an item has no
+  _fixtureinfo attribute (e.g. doctests) (`#2788
+  <https://github.com/pytest-dev/pytest/issues/2788>`_)
+
+
+Improved Documentation
+----------------------
+
+- In help text of ``-k`` option, add example of using ``not`` to not select
+  certain tests whose names match the provided expression. (`#1442
+  <https://github.com/pytest-dev/pytest/issues/1442>`_)
+
+- Add note in ``parametrize.rst`` about calling ``metafunc.parametrize``
+  multiple times. (`#1548 <https://github.com/pytest-dev/pytest/issues/1548>`_)
+
+
+Trivial/Internal Changes
+------------------------
+
+- Set ``xfail_strict=True`` in pytest's own test suite to catch expected
+  failures as soon as they start to pass. (`#2722
+  <https://github.com/pytest-dev/pytest/issues/2722>`_)
+
+- Fix typo in example of passing a callable to markers (in example/markers.rst)
+  (`#2765 <https://github.com/pytest-dev/pytest/issues/2765>`_)
+
+
+Pytest 3.2.2 (2017-09-06)
+=========================
+
+Bug Fixes
+---------
+
+- Calling the deprecated `request.getfuncargvalue()` now shows the source of
+  the call. (`#2681 <https://github.com/pytest-dev/pytest/issues/2681>`_)
+
+- Allow tests declared as ``@staticmethod`` to use fixtures. (`#2699
+  <https://github.com/pytest-dev/pytest/issues/2699>`_)
+
+- Fixed edge-case during collection: attributes which raised ``pytest.fail``
+  when accessed would abort the entire collection. (`#2707
+  <https://github.com/pytest-dev/pytest/issues/2707>`_)
+
+- Fix ``ReprFuncArgs`` with mixed unicode and UTF-8 args. (`#2731
+  <https://github.com/pytest-dev/pytest/issues/2731>`_)
+
+
+Improved Documentation
+----------------------
+
+- In examples on working with custom markers, add examples demonstrating the
+  usage of ``pytest.mark.MARKER_NAME.with_args`` in comparison with
+  ``pytest.mark.MARKER_NAME.__call__`` (`#2604
+  <https://github.com/pytest-dev/pytest/issues/2604>`_)
+
+- In one of the simple examples, use `pytest_collection_modifyitems()` to skip
+  tests based on a command-line option, allowing its sharing while preventing a
+  user error when acessing `pytest.config` before the argument parsing. (`#2653
+  <https://github.com/pytest-dev/pytest/issues/2653>`_)
+
+
+Trivial/Internal Changes
+------------------------
+
+- Fixed minor error in 'Good Practices/Manual Integration' code snippet.
+  (`#2691 <https://github.com/pytest-dev/pytest/issues/2691>`_)
+
+- Fixed typo in goodpractices.rst. (`#2721
+  <https://github.com/pytest-dev/pytest/issues/2721>`_)
+
+- Improve user guidance regarding ``--resultlog`` deprecation. (`#2739
+  <https://github.com/pytest-dev/pytest/issues/2739>`_)
+
+
+Pytest 3.2.1 (2017-08-08)
+=========================
+
+Bug Fixes
+---------
+
+- Fixed small terminal glitch when collecting a single test item. (`#2579
+  <https://github.com/pytest-dev/pytest/issues/2579>`_)
+
+- Correctly consider ``/`` as the file separator to automatically mark plugin
+  files for rewrite on Windows. (`#2591 <https://github.com/pytest-
+  dev/pytest/issues/2591>`_)
+
+- Properly escape test names when setting ``PYTEST_CURRENT_TEST`` environment
+  variable. (`#2644 <https://github.com/pytest-dev/pytest/issues/2644>`_)
+
+- Fix error on Windows and Python 3.6+ when ``sys.stdout`` has been replaced
+  with a stream-like object which does not implement the full ``io`` module
+  buffer protocol. In particular this affects ``pytest-xdist`` users on the
+  aforementioned platform. (`#2666 <https://github.com/pytest-
+  dev/pytest/issues/2666>`_)
+
+
+Improved Documentation
+----------------------
+
+- Explicitly document which pytest features work with ``unittest``. (`#2626
+  <https://github.com/pytest-dev/pytest/issues/2626>`_)
+
+
+Pytest 3.2.0 (2017-07-30)
+=========================
+
+Deprecations and Removals
+-------------------------
+
+- ``pytest.approx`` no longer supports ``>``, ``>=``, ``<`` and ``<=``
+  operators to avoid surprising/inconsistent behavior. See `the docs
+  <https://docs.pytest.org/en/latest/builtin.html#pytest.approx>`_ for more
+  information. (`#2003 <https://github.com/pytest-dev/pytest/issues/2003>`_)
+
+- All old-style specific behavior in current classes in the pytest's API is
+  considered deprecated at this point and will be removed in a future release.
+  This affects Python 2 users only and in rare situations. (`#2147
+  <https://github.com/pytest-dev/pytest/issues/2147>`_)
+
+- A deprecation warning is now raised when using marks for parameters
+  in ``pytest.mark.parametrize``. Use ``pytest.param`` to apply marks to
+  parameters instead. (`#2427 <https://github.com/pytest-dev/pytest/issues/2427>`_)
+
+
+Features
+--------
+
+- Add support for numpy arrays (and dicts) to approx. (`#1994
+  <https://github.com/pytest-dev/pytest/issues/1994>`_)
+
+- Now test function objects have a ``pytestmark`` attribute containing a list
+  of marks applied directly to the test function, as opposed to marks inherited
+  from parent classes or modules. (`#2516 <https://github.com/pytest-
+  dev/pytest/issues/2516>`_)
+
+- Collection ignores local virtualenvs by default; `--collect-in-virtualenv`
+  overrides this behavior. (`#2518 <https://github.com/pytest-
+  dev/pytest/issues/2518>`_)
+
+- Allow class methods decorated as ``@staticmethod`` to be candidates for
+  collection as a test function. (Only for Python 2.7 and above. Python 2.6
+  will still ignore static methods.) (`#2528 <https://github.com/pytest-
+  dev/pytest/issues/2528>`_)
+
+- Introduce ``mark.with_args`` in order to allow passing functions/classes as
+  sole argument to marks. (`#2540 <https://github.com/pytest-
+  dev/pytest/issues/2540>`_)
+
+- New ``cache_dir`` ini option: sets the directory where the contents of the
+  cache plugin are stored. Directory may be relative or absolute path: if relative path, then
+  directory is created relative to ``rootdir``, otherwise it is used as is.
+  Additionally path may contain environment variables which are expanded during
+  runtime. (`#2543 <https://github.com/pytest-dev/pytest/issues/2543>`_)
+
+- Introduce the ``PYTEST_CURRENT_TEST`` environment variable that is set with
+  the ``nodeid`` and stage (``setup``, ``call`` and ``teardown``) of the test
+  being currently executed. See the `documentation
+  <https://docs.pytest.org/en/latest/example/simple.html#pytest-current-test-
+  environment-variable>`_ for more info. (`#2583 <https://github.com/pytest-
+  dev/pytest/issues/2583>`_)
+
+- Introduced ``@pytest.mark.filterwarnings`` mark which allows overwriting the
+  warnings filter on a per test, class or module level. See the `docs
+  <https://docs.pytest.org/en/latest/warnings.html#pytest-mark-
+  filterwarnings>`_ for more information. (`#2598 <https://github.com/pytest-
+  dev/pytest/issues/2598>`_)
+
+- ``--last-failed`` now remembers forever when a test has failed and only
+  forgets it if it passes again. This makes it easy to fix a test suite by
+  selectively running files and fixing tests incrementally. (`#2621
+  <https://github.com/pytest-dev/pytest/issues/2621>`_)
+
+- New ``pytest_report_collectionfinish`` hook which allows plugins to add
+  messages to the terminal reporting after collection has been finished
+  successfully. (`#2622 <https://github.com/pytest-dev/pytest/issues/2622>`_)
+
+- Added support for `PEP-415's <https://www.python.org/dev/peps/pep-0415/>`_
+  ``Exception.__suppress_context__``. Now if a ``raise exception from None`` is
+  caught by pytest, pytest will no longer chain the context in the test report.
+  The behavior now matches Python's traceback behavior. (`#2631
+  <https://github.com/pytest-dev/pytest/issues/2631>`_)
+
+- Exceptions raised by ``pytest.fail``, ``pytest.skip`` and ``pytest.xfail``
+  now subclass BaseException, making them harder to be caught unintentionally
+  by normal code. (`#580 <https://github.com/pytest-dev/pytest/issues/580>`_)
+
+
+Bug Fixes
+---------
+
+- Set ``stdin`` to a closed ``PIPE`` in ``pytester.py.Testdir.popen()`` for
+  avoid unwanted interactive ``pdb`` (`#2023 <https://github.com/pytest-
+  dev/pytest/issues/2023>`_)
+
+- Add missing ``encoding`` attribute to ``sys.std*`` streams when using
+  ``capsys`` capture mode. (`#2375 <https://github.com/pytest-
+  dev/pytest/issues/2375>`_)
+
+- Fix terminal color changing to black on Windows if ``colorama`` is imported
+  in a ``conftest.py`` file. (`#2510 <https://github.com/pytest-
+  dev/pytest/issues/2510>`_)
+
+- Fix line number when reporting summary of skipped tests. (`#2548
+  <https://github.com/pytest-dev/pytest/issues/2548>`_)
+
+- capture: ensure that EncodedFile.name is a string. (`#2555
+  <https://github.com/pytest-dev/pytest/issues/2555>`_)
+
+- The options ``--fixtures`` and ``--fixtures-per-test`` will now keep
+  indentation within docstrings. (`#2574 <https://github.com/pytest-
+  dev/pytest/issues/2574>`_)
+
+- doctests line numbers are now reported correctly, fixing `pytest-sugar#122
+  <https://github.com/Frozenball/pytest-sugar/issues/122>`_. (`#2610
+  <https://github.com/pytest-dev/pytest/issues/2610>`_)
+
+- Fix non-determinism in order of fixture collection. Adds new dependency
+  (ordereddict) for Python 2.6. (`#920 <https://github.com/pytest-
+  dev/pytest/issues/920>`_)
+
+
+Improved Documentation
+----------------------
+
+- Clarify ``pytest_configure`` hook call order. (`#2539
+  <https://github.com/pytest-dev/pytest/issues/2539>`_)
+
+- Extend documentation for testing plugin code with the ``pytester`` plugin.
+  (`#971 <https://github.com/pytest-dev/pytest/issues/971>`_)
+
+
+Trivial/Internal Changes
+------------------------
+
+- Update help message for ``--strict`` to make it clear it only deals with
+  unregistered markers, not warnings. (`#2444 <https://github.com/pytest-
+  dev/pytest/issues/2444>`_)
+
+- Internal code move: move code for pytest.approx/pytest.raises to own files in
+  order to cut down the size of python.py (`#2489 <https://github.com/pytest-
+  dev/pytest/issues/2489>`_)
+
+- Renamed the utility function ``_pytest.compat._escape_strings`` to
+  ``_ascii_escaped`` to better communicate the function's purpose. (`#2533
+  <https://github.com/pytest-dev/pytest/issues/2533>`_)
+
+- Improve error message for CollectError with skip/skipif. (`#2546
+  <https://github.com/pytest-dev/pytest/issues/2546>`_)
+
+- Emit warning about ``yield`` tests being deprecated only once per generator.
+  (`#2562 <https://github.com/pytest-dev/pytest/issues/2562>`_)
+
+- Ensure final collected line doesn't include artifacts of previous write.
+  (`#2571 <https://github.com/pytest-dev/pytest/issues/2571>`_)
+
+- Fixed all flake8 errors and warnings. (`#2581 <https://github.com/pytest-
+  dev/pytest/issues/2581>`_)
+
+- Added ``fix-lint`` tox environment to run automatic pep8 fixes on the code.
+  (`#2582 <https://github.com/pytest-dev/pytest/issues/2582>`_)
+
+- Turn warnings into errors in pytest's own test suite in order to catch
+  regressions due to deprecations more promptly. (`#2588
+  <https://github.com/pytest-dev/pytest/issues/2588>`_)
+
+- Show multiple issue links in CHANGELOG entries. (`#2620
+  <https://github.com/pytest-dev/pytest/issues/2620>`_)
+
+
+Pytest 3.1.3 (2017-07-03)
+=========================
+
+Bug Fixes
+---------
+
+- Fix decode error in Python 2 for doctests in docstrings. (`#2434
+  <https://github.com/pytest-dev/pytest/issues/2434>`_)
+
+- Exceptions raised during teardown by finalizers are now suppressed until all
+  finalizers are called, with the initial exception reraised. (`#2440
+  <https://github.com/pytest-dev/pytest/issues/2440>`_)
+
+- Fix incorrect "collected items" report when specifying tests on the command-
+  line. (`#2464 <https://github.com/pytest-dev/pytest/issues/2464>`_)
+
+- ``deprecated_call`` in context-manager form now captures deprecation warnings
+  even if the same warning has already been raised. Also, ``deprecated_call``
+  will always produce the same error message (previously it would produce
+  different messages in context-manager vs. function-call mode). (`#2469
+  <https://github.com/pytest-dev/pytest/issues/2469>`_)
+
+- Fix issue where paths collected by pytest could have triple leading ``/``
+  characters. (`#2475 <https://github.com/pytest-dev/pytest/issues/2475>`_)
+
+- Fix internal error when trying to detect the start of a recursive traceback.
+  (`#2486 <https://github.com/pytest-dev/pytest/issues/2486>`_)
+
+
+Improved Documentation
+----------------------
+
+- Explicitly state for which hooks the calls stop after the first non-None
+  result. (`#2493 <https://github.com/pytest-dev/pytest/issues/2493>`_)
+
+
+Trivial/Internal Changes
+------------------------
+
+- Create invoke tasks for updating the vendored packages. (`#2474
+  <https://github.com/pytest-dev/pytest/issues/2474>`_)
+
+- Update copyright dates in LICENSE, README.rst and in the documentation.
+  (`#2499 <https://github.com/pytest-dev/pytest/issues/2499>`_)
+
+
 Pytest 3.1.2 (2017-06-08)
 =========================
 
@@ -25,9 +401,9 @@ Bug Fixes
 - ``UnicodeWarning`` is issued from the internal pytest warnings plugin only
   when the message contains non-ascii unicode (Python 2 only). (#2463)
 
-- Added a workaround for Python 3.6 WindowsConsoleIO breaking due to Pytests's
-  FDCapture. Other code using console handles might still be affected by the
-  very same issue and might require further workarounds/fixes, i.e. colorama.
+- Added a workaround for Python 3.6 ``WindowsConsoleIO`` breaking due to Pytests's
+  ``FDCapture``. Other code using console handles might still be affected by the
+  very same issue and might require further workarounds/fixes, i.e. ``colorama``.
   (#2467)
 
 

CONTRIBUTING.rst

@@ -34,13 +34,13 @@ If you are reporting a bug, please include:
 
 * Your operating system name and version.
 * Any details about your local setup that might be helpful in troubleshooting,
-  specifically Python interpreter version,
-  installed libraries and pytest version.
+  specifically the Python interpreter version, installed libraries, and pytest
+  version.
 * Detailed steps to reproduce the bug.
 
-If you can write a demonstration test that currently fails but should pass (xfail),
-that is a very useful commit to make as well, even if you can't find how
-to fix the bug yet.
+If you can write a demonstration test that currently fails but should pass
+(xfail), that is a very useful commit to make as well, even if you cannot
+fix the bug itself.
 
 
 .. _fixbugs:
@@ -120,7 +120,7 @@ the following:
 - PyPI presence with a ``setup.py`` that contains a license, ``pytest-``
   prefixed name, version number, authors, short and long description.
 
-- a ``tox.ini`` for running tests using `tox <http://tox.testrun.org>`_.
+- a ``tox.ini`` for running tests using `tox <https://tox.readthedocs.io>`_.
 
 - a ``README.txt`` describing how to use the plugin and on which
   platforms it runs.
@@ -158,19 +158,41 @@ As stated, the objective is to share maintenance and avoid "plugin-abandon".
 .. _`pull requests`:
 .. _pull-requests:
 
-Preparing Pull Requests on GitHub
----------------------------------
+Preparing 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 a pull request, we can discuss its potential modifications and
-  even add more commits to it later on.
+Short version
+~~~~~~~~~~~~~
 
-There's an excellent tutorial on how Pull Requests work in the
-`GitHub Help Center <https://help.github.com/articles/using-pull-requests/>`_,
-but here is a simple overview:
+#. Fork the repository;
+#. Target ``master`` for bugfixes and doc changes;
+#. Target ``features`` for new features or functionality changes.
+#. Follow **PEP-8**. There's a ``tox`` command to help fixing it: ``tox -e fix-lint``.
+#. Tests are run using ``tox``::
+
+    tox -e linting,py27,py36
+
+   The test environments above are usually enough to cover most cases locally.
+
+#. Write a ``changelog`` entry: ``changelog/2574.bugfix``, use issue id number
+   and one of ``bugfix``, ``removal``, ``feature``, ``vendor``, ``doc`` or
+   ``trivial`` for the issue type.
+#. Unless your change is a trivial or a documentation fix (e.g., a typo or reword of a small section) please
+   add yourself to the ``AUTHORS`` file, in alphabetical order;
+
+
+Long version
+~~~~~~~~~~~~
+
+What is a "pull request"?  It informs the 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 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
+`GitHub Help Center <https://help.github.com/articles/using-pull-requests/>`_.
+
+Here is a simple overview, with pytest-specific bits:
 
 #. Fork the
    `pytest GitHub repository <https://github.com/pytest-dev/pytest>`__.  It's
@@ -214,12 +236,18 @@ but here is a simple overview:
    This command will run tests via the "tox" tool against Python 2.7 and 3.6
    and also perform "lint" coding-style checks.
 
-#. You can now edit your local working copy.
+#. You can now edit your local working copy. Please follow PEP-8.
 
    You can now make the changes you want and run the tests again as necessary.
 
-   To run tests on Python 2.7 and pass options to pytest (e.g. enter pdb on
-   failure) to pytest you can do::
+   If you have too much linting errors, try running::
+
+    $ tox -e fix-lint
+
+   To fix pep8 related errors.
+
+   You can pass different options to ``tox``. For example, to run tests on Python 2.7 and pass options to pytest
+   (e.g. enter pdb on failure) to pytest you can do::
 
     $ tox -e py27 -- --pdb
 
@@ -232,9 +260,11 @@ but here is a simple overview:
     $ git commit -a -m "<commit message>"
     $ git push -u
 
-   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.
+#. Create a new changelog entry in ``changelog``. The file should be named ``<issueid>.<type>``,
+   where *issueid* is the number of the issue related to the change and *type* is one of
+   ``bugfix``, ``removal``, ``feature``, ``vendor``, ``doc`` or ``trivial``.
+
+#. Add yourself to ``AUTHORS`` file if not there yet, in alphabetical order.
 
 #. Finally, submit a pull request through the GitHub website using this data::
 

HOWTORELEASE.rst

@@ -1,5 +1,9 @@
-How to release pytest
---------------------------------------------
+Release Procedure
+-----------------
+
+Our current policy for releasing is to aim for a bugfix every few weeks and a minor release every 2-3 months. The idea
+is to get fixes and new features out instead of trying to cram a ton of features into a release and by consequence
+taking a lot of time to make a new one.
 
 .. important::
 
@@ -21,7 +25,7 @@ How to release pytest
 #. Generate docs, changelog, announcements and upload a package to
    your ``devpi`` staging server::
 
-     invoke generate.pre_release <VERSION> <DEVPI USER> --password <DEVPI PASSWORD>
+     invoke generate.pre-release <VERSION> <DEVPI USER> --password <DEVPI PASSWORD>
 
    If ``--password`` is not given, it is assumed the user is already logged in ``devpi``.
    If you don't have an account, please ask for one.
@@ -49,12 +53,12 @@ How to release pytest
 
 #. Publish to PyPI::
 
-      invoke generate.publish_release <VERSION> <DEVPI USER> <PYPI_NAME>
+      invoke generate.publish-release <VERSION> <DEVPI USER> <PYPI_NAME>
 
    where PYPI_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>`_.
 
-#. After a minor/major release, merge ``features`` into ``master`` and push (or open a PR).
+#. After a minor/major release, merge ``release-X.Y.Z`` into ``master`` and push (or open a PR).
 
 .. _devpi-cloud-test: https://github.com/obestwalter/devpi-cloud-test
 .. _AppVeyor: https://www.appveyor.com/

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2004-2016 Holger Krekel and others
+Copyright (c) 2004-2017 Holger Krekel and others
 
 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

MANIFEST.in

@@ -1,39 +0,0 @@
-include CHANGELOG.rst
-include LICENSE
-include AUTHORS
-include pyproject.toml
-
-include README.rst
-include CONTRIBUTING.rst
-include HOWTORELEASE.rst
-
-include tox.ini
-include setup.py
-
-recursive-include changelog *
-recursive-include scripts *.py
-recursive-include scripts *.bat
-
-include .coveragerc
-
-recursive-include bench *.py
-recursive-include extra *.py
-
-graft testing
-graft doc
-prune doc/en/_build
-graft tasks
-
-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.yml
-exclude .travis.yml
-prune .github

README.rst

@@ -78,7 +78,7 @@ Features
 
 - Python2.6+, Python3.3+, PyPy-2.3, Jython-2.5 (untested);
 
-- Rich plugin architecture, with over 150+ `external plugins <http://docs.pytest.org/en/latest/plugins.html#installing-external-plugins-searching>`_ and thriving community;
+- Rich plugin architecture, with over 315+ `external plugins <http://plugincompat.herokuapp.com>`_ and thriving community;
 
 
 Documentation
@@ -102,7 +102,7 @@ Consult the `Changelog <http://docs.pytest.org/en/latest/changelog.html>`__ page
 License
 -------
 
-Copyright Holger Krekel and others, 2004-2016.
+Copyright Holger Krekel and others, 2004-2017.
 
 Distributed under the terms of the `MIT`_ license, pytest is free and open source software.
 

_pytest/_argcomplete.py

@@ -62,21 +62,24 @@ import sys
 import os
 from glob import glob
 
+
 class FastFilesCompleter:
     'Fast file completer class'
+
     def __init__(self, directories=True):
         self.directories = directories
 
     def __call__(self, prefix, **kwargs):
         """only called on non option completions"""
-        if os.path.sep in prefix[1:]: #
+        if os.path.sep in prefix[1:]:
             prefix_dir = len(os.path.dirname(prefix) + os.path.sep)
         else:
             prefix_dir = 0
         completion = []
         globbed = []
         if '*' not in prefix and '?' not in prefix:
-            if prefix[-1] == os.path.sep:  # we are on unix, otherwise no bash
+            # we are on unix, otherwise no bash
+            if not prefix or prefix[-1] == os.path.sep:
                 globbed.extend(glob(prefix + '.*'))
             prefix += '*'
         globbed.extend(glob(prefix))
@@ -96,7 +99,8 @@ if os.environ.get('_ARGCOMPLETE'):
     filescompleter = FastFilesCompleter()
 
     def try_argcomplete(parser):
-        argcomplete.autocomplete(parser)
+        argcomplete.autocomplete(parser, always_complete_options=False)
 else:
-    def try_argcomplete(parser): pass
+    def try_argcomplete(parser):
+        pass
     filescompleter = None

_pytest/_code/_py2traceback.py

@@ -5,6 +5,7 @@
 from __future__ import absolute_import, division, print_function
 import types
 
+
 def format_exception_only(etype, value):
     """Format the exception part of a traceback.
 
@@ -30,7 +31,7 @@ def format_exception_only(etype, value):
     # would throw another exception and mask the original problem.
     if (isinstance(etype, BaseException) or
         isinstance(etype, types.InstanceType) or
-        etype is None or type(etype) is str):
+            etype is None or type(etype) is str):
         return [_format_final_exc_line(etype, value)]
 
     stype = etype.__name__
@@ -62,6 +63,7 @@ def format_exception_only(etype, value):
     lines.append(_format_final_exc_line(stype, value))
     return lines
 
+
 def _format_final_exc_line(etype, value):
     """Return a list of a single line -- normal case for format_exception_only"""
     valuestr = _some_str(value)
@@ -71,6 +73,7 @@ def _format_final_exc_line(etype, value):
         line = "%s: %s\n" % (etype, valuestr)
     return line
 
+
 def _some_str(value):
     try:
         return unicode(value)

_pytest/_code/code.py

@@ -18,6 +18,7 @@ else:
 
 class Code(object):
     """ wrapper around Python code objects """
+
     def __init__(self, rawcode):
         if not hasattr(rawcode, "co_filename"):
             rawcode = getrawcode(rawcode)
@@ -26,7 +27,7 @@ class Code(object):
             self.firstlineno = rawcode.co_firstlineno - 1
             self.name = rawcode.co_name
         except AttributeError:
-            raise TypeError("not a code object: %r" %(rawcode,))
+            raise TypeError("not a code object: %r" % (rawcode,))
         self.raw = rawcode
 
     def __eq__(self, other):
@@ -82,6 +83,7 @@ class Code(object):
             argcount += raw.co_flags & CO_VARKEYWORDS
         return raw.co_varnames[:argcount]
 
+
 class Frame(object):
     """Wrapper around a Python frame holding f_locals and f_globals
     in which expressions can be evaluated."""
@@ -119,7 +121,7 @@ class Frame(object):
         """
         f_locals = self.f_locals.copy()
         f_locals.update(vars)
-        py.builtin.exec_(code, self.f_globals, f_locals )
+        py.builtin.exec_(code, self.f_globals, f_locals)
 
     def repr(self, object):
         """ return a 'safe' (non-recursive, one-line) string repr for 'object'
@@ -143,6 +145,7 @@ class Frame(object):
                 pass     # this can occur when using Psyco
         return retval
 
+
 class TracebackEntry(object):
     """ a single entry in a traceback """
 
@@ -168,7 +171,7 @@ class TracebackEntry(object):
         return self.lineno - self.frame.code.firstlineno
 
     def __repr__(self):
-        return "<TracebackEntry %s:%d>" %(self.frame.code.path, self.lineno+1)
+        return "<TracebackEntry %s:%d>" % (self.frame.code.path, self.lineno + 1)
 
     @property
     def statement(self):
@@ -247,19 +250,21 @@ class TracebackEntry(object):
             line = str(self.statement).lstrip()
         except KeyboardInterrupt:
             raise
-        except:
+        except:  # noqa
             line = "???"
-        return "  File %r:%d in %s\n  %s\n" %(fn, self.lineno+1, name, line)
+        return "  File %r:%d in %s\n  %s\n" % (fn, self.lineno + 1, name, line)
 
     def name(self):
         return self.frame.code.raw.co_name
     name = property(name, None, None, "co_name of underlaying code")
 
+
 class Traceback(list):
     """ Traceback objects encapsulate and offer higher level
         access to Traceback entries.
     """
     Entry = TracebackEntry
+
     def __init__(self, tb, excinfo=None):
         """ initialize from given python traceback object and ExceptionInfo """
         self._excinfo = excinfo
@@ -289,7 +294,7 @@ class Traceback(list):
                 (excludepath is None or not hasattr(codepath, 'relto') or
                  not codepath.relto(excludepath)) and
                 (lineno is None or x.lineno == lineno) and
-                (firstlineno is None or x.frame.code.firstlineno == firstlineno)):
+                    (firstlineno is None or x.frame.code.firstlineno == firstlineno)):
                 return Traceback(x._rawentry, self._excinfo)
         return self
 
@@ -315,7 +320,7 @@ class Traceback(list):
         """ return last non-hidden traceback entry that lead
         to the exception of a traceback.
         """
-        for i in range(-1, -len(self)-1, -1):
+        for i in range(-1, -len(self) - 1, -1):
             entry = self[i]
             if not entry.ishidden():
                 return entry
@@ -330,25 +335,26 @@ class Traceback(list):
             # id for the code.raw is needed to work around
             # the strange metaprogramming in the decorator lib from pypi
             # which generates code objects that have hash/value equality
-            #XXX needs a test
+            # XXX needs a test
             key = entry.frame.code.path, id(entry.frame.code.raw), entry.lineno
-            #print "checking for recursion at", key
-            l = cache.setdefault(key, [])
-            if l:
+            # print "checking for recursion at", key
+            values = cache.setdefault(key, [])
+            if values:
                 f = entry.frame
                 loc = f.f_locals
-                for otherloc in l:
+                for otherloc in values:
                     if f.is_true(f.eval(co_equal,
-                        __recursioncache_locals_1=loc,
-                        __recursioncache_locals_2=otherloc)):
+                                        __recursioncache_locals_1=loc,
+                                        __recursioncache_locals_2=otherloc)):
                         return i
-            l.append(entry.frame.f_locals)
+            values.append(entry.frame.f_locals)
         return None
 
 
 co_equal = compile('__recursioncache_locals_1 == __recursioncache_locals_2',
                    '?', 'eval')
 
+
 class ExceptionInfo(object):
     """ wraps sys.exc_info() objects and offers
         help for navigating the traceback.
@@ -405,10 +411,10 @@ class ExceptionInfo(object):
         exconly = self.exconly(tryshort=True)
         entry = self.traceback.getcrashentry()
         path, lineno = entry.frame.code.raw.co_filename, entry.lineno
-        return ReprFileLocation(path, lineno+1, exconly)
+        return ReprFileLocation(path, lineno + 1, exconly)
 
     def getrepr(self, showlocals=False, style="long",
-            abspath=False, tbfilter=True, funcargs=False):
+                abspath=False, tbfilter=True, funcargs=False):
         """ return str()able representation of this exception info.
             showlocals: show locals per traceback entry
             style: long|short|no|native traceback style
@@ -425,7 +431,7 @@ class ExceptionInfo(object):
                 )), self._getreprcrash())
 
         fmt = FormattedExcinfo(showlocals=showlocals, style=style,
-            abspath=abspath, tbfilter=tbfilter, funcargs=funcargs)
+                               abspath=abspath, tbfilter=tbfilter, funcargs=funcargs)
         return fmt.repr_excinfo(self)
 
     def __str__(self):
@@ -469,15 +475,15 @@ class FormattedExcinfo(object):
     def _getindent(self, source):
         # figure out indent for given source
         try:
-            s = str(source.getstatement(len(source)-1))
+            s = str(source.getstatement(len(source) - 1))
         except KeyboardInterrupt:
             raise
-        except:
+        except:  # noqa
             try:
                 s = str(source[-1])
             except KeyboardInterrupt:
                 raise
-            except:
+            except:  # noqa
                 return 0
         return 4 + (len(s) - len(s.lstrip()))
 
@@ -513,7 +519,7 @@ class FormattedExcinfo(object):
             for line in source.lines[:line_index]:
                 lines.append(space_prefix + line)
             lines.append(self.flow_marker + "   " + source.lines[line_index])
-            for line in source.lines[line_index+1:]:
+            for line in source.lines[line_index + 1:]:
                 lines.append(space_prefix + line)
         if excinfo is not None:
             indent = 4 if short else self._getindent(source)
@@ -546,10 +552,10 @@ class FormattedExcinfo(object):
                     # _repr() function, which is only reprlib.Repr in
                     # disguise, so is very configurable.
                     str_repr = self._saferepr(value)
-                    #if len(str_repr) < 70 or not isinstance(value,
+                    # if len(str_repr) < 70 or not isinstance(value,
                     #                            (list, tuple, dict)):
-                    lines.append("%-10s = %s" %(name, str_repr))
-                    #else:
+                    lines.append("%-10s = %s" % (name, str_repr))
+                    # else:
                     #    self._line("%-10s =\\" % (name,))
                     #    # XXX
                     #    py.std.pprint.pprint(value, stream=self.excinfowriter)
@@ -575,14 +581,14 @@ class FormattedExcinfo(object):
             s = self.get_source(source, line_index, excinfo, short=short)
             lines.extend(s)
             if short:
-                message = "in %s" %(entry.name)
+                message = "in %s" % (entry.name)
             else:
                 message = excinfo and excinfo.typename or ""
             path = self._makepath(entry.path)
-            filelocrepr = ReprFileLocation(path, entry.lineno+1, message)
+            filelocrepr = ReprFileLocation(path, entry.lineno + 1, message)
             localsrepr = None
             if not short:
-                localsrepr =  self.repr_locals(entry.locals)
+                localsrepr = self.repr_locals(entry.locals)
             return ReprEntry(lines, reprargs, localsrepr, filelocrepr, style)
         if excinfo:
             lines.extend(self.get_exconly(excinfo, indent=4))
@@ -640,9 +646,12 @@ class FormattedExcinfo(object):
             ).format(exc_type=type(e).__name__, exc_msg=safe_str(e), max_frames=max_frames, total=len(traceback))
             traceback = traceback[:max_frames] + traceback[-max_frames:]
         else:
-            extraline = "!!! Recursion detected (same locals & position)"
-            traceback = traceback[:recursionindex + 1]
-            
+            if recursionindex is not None:
+                extraline = "!!! Recursion detected (same locals & position)"
+                traceback = traceback[:recursionindex + 1]
+            else:
+                extraline = None
+
         return traceback, extraline
 
     def repr_excinfo(self, excinfo):
@@ -670,7 +679,7 @@ class FormattedExcinfo(object):
                     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:
+                elif (e.__context__ is not None and not e.__suppress_context__):
                     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:'
@@ -696,7 +705,7 @@ class TerminalRepr(object):
         return io.getvalue().strip()
 
     def __repr__(self):
-        return "<%s instance at %0x>" %(self.__class__, id(self))
+        return "<%s instance at %0x>" % (self.__class__, id(self))
 
 
 class ExceptionRepr(TerminalRepr):
@@ -740,6 +749,7 @@ class ReprExceptionInfo(ExceptionRepr):
         self.reprtraceback.toterminal(tw)
         super(ReprExceptionInfo, self).toterminal(tw)
 
+
 class ReprTraceback(TerminalRepr):
     entrysep = "_ "
 
@@ -755,7 +765,7 @@ class ReprTraceback(TerminalRepr):
                 tw.line("")
             entry.toterminal(tw)
             if i < len(self.reprentries) - 1:
-                next_entry = self.reprentries[i+1]
+                next_entry = self.reprentries[i + 1]
                 if entry.style == "long" or \
                    entry.style == "short" and next_entry.style == "long":
                     tw.sep(self.entrysep)
@@ -763,12 +773,14 @@ class ReprTraceback(TerminalRepr):
         if self.extraline:
             tw.line(self.extraline)
 
+
 class ReprTracebackNative(ReprTraceback):
     def __init__(self, tblines):
         self.style = "native"
         self.reprentries = [ReprEntryNative(tblines)]
         self.extraline = None
 
+
 class ReprEntryNative(TerminalRepr):
     style = "native"
 
@@ -778,6 +790,7 @@ class ReprEntryNative(TerminalRepr):
     def toterminal(self, tw):
         tw.write("".join(self.lines))
 
+
 class ReprEntry(TerminalRepr):
     localssep = "_ "
 
@@ -794,7 +807,7 @@ class ReprEntry(TerminalRepr):
             for line in self.lines:
                 red = line.startswith("E   ")
                 tw.line(line, bold=True, red=red)
-            #tw.line("")
+            # tw.line("")
             return
         if self.reprfuncargs:
             self.reprfuncargs.toterminal(tw)
@@ -802,7 +815,7 @@ class ReprEntry(TerminalRepr):
             red = line.startswith("E   ")
             tw.line(line, bold=True, red=red)
         if self.reprlocals:
-            #tw.sep(self.localssep, "Locals")
+            # tw.sep(self.localssep, "Locals")
             tw.line("")
             self.reprlocals.toterminal(tw)
         if self.reprfileloc:
@@ -815,6 +828,7 @@ class ReprEntry(TerminalRepr):
                                self.reprlocals,
                                self.reprfileloc)
 
+
 class ReprFileLocation(TerminalRepr):
     def __init__(self, path, lineno, message):
         self.path = str(path)
@@ -831,6 +845,7 @@ class ReprFileLocation(TerminalRepr):
         tw.write(self.path, bold=True, red=True)
         tw.line(":%s: %s" % (self.lineno, msg))
 
+
 class ReprLocals(TerminalRepr):
     def __init__(self, lines):
         self.lines = lines
@@ -839,6 +854,7 @@ class ReprLocals(TerminalRepr):
         for line in self.lines:
             tw.line(line)
 
+
 class ReprFuncArgs(TerminalRepr):
     def __init__(self, args):
         self.args = args
@@ -847,11 +863,11 @@ class ReprFuncArgs(TerminalRepr):
         if self.args:
             linesofar = ""
             for name, value in self.args:
-                ns = "%s = %s" %(name, value)
+                ns = "%s = %s" % (safe_str(name), safe_str(value))
                 if len(ns) + len(linesofar) + 2 > tw.fullwidth:
                     if linesofar:
                         tw.line(linesofar)
-                    linesofar =  ns
+                    linesofar = ns
                 else:
                     if linesofar:
                         linesofar += ", " + ns

_pytest/_code/source.py

@@ -2,7 +2,8 @@ from __future__ import absolute_import, division, generators, print_function
 
 from bisect import bisect_right
 import sys
-import inspect, tokenize
+import inspect
+import tokenize
 import py
 cpy_compile = compile
 
@@ -19,6 +20,7 @@ class Source(object):
         possibly deindenting it.
     """
     _compilecounter = 0
+
     def __init__(self, *parts, **kwargs):
         self.lines = lines = []
         de = kwargs.get('deindent', True)
@@ -73,7 +75,7 @@ class Source(object):
         start, end = 0, len(self)
         while start < end and not self.lines[start].strip():
             start += 1
-        while end > start and not self.lines[end-1].strip():
+        while end > start and not self.lines[end - 1].strip():
             end -= 1
         source = Source()
         source.lines[:] = self.lines[start:end]
@@ -86,8 +88,8 @@ class Source(object):
         before = Source(before)
         after = Source(after)
         newsource = Source()
-        lines = [ (indent + line) for line in self.lines]
-        newsource.lines = before.lines + lines +  after.lines
+        lines = [(indent + line) for line in self.lines]
+        newsource.lines = before.lines + lines + after.lines
         return newsource
 
     def indent(self, indent=' ' * 4):
@@ -95,7 +97,7 @@ class Source(object):
             all lines indented by the given indent-string.
         """
         newsource = Source()
-        newsource.lines = [(indent+line) for line in self.lines]
+        newsource.lines = [(indent + line) for line in self.lines]
         return newsource
 
     def getstatement(self, lineno, assertion=False):
@@ -134,7 +136,8 @@ class Source(object):
         try:
             import parser
         except ImportError:
-            syntax_checker = lambda x: compile(x, 'asd', 'exec')
+            def syntax_checker(x):
+                return compile(x, 'asd', 'exec')
         else:
             syntax_checker = parser.suite
 
@@ -143,8 +146,8 @@ class Source(object):
         else:
             source = str(self)
         try:
-            #compile(source+'\n', "x", "exec")
-            syntax_checker(source+'\n')
+            # compile(source+'\n', "x", "exec")
+            syntax_checker(source + '\n')
         except KeyboardInterrupt:
             raise
         except Exception:
@@ -164,8 +167,8 @@ class Source(object):
         """
         if not filename or py.path.local(filename).check(file=0):
             if _genframe is None:
-                _genframe = sys._getframe(1) # the caller
-            fn,lineno = _genframe.f_code.co_filename, _genframe.f_lineno
+                _genframe = sys._getframe(1)  # the caller
+            fn, lineno = _genframe.f_code.co_filename, _genframe.f_lineno
             base = "<%d-codegen " % self._compilecounter
             self.__class__._compilecounter += 1
             if not filename:
@@ -180,7 +183,7 @@ class Source(object):
             # re-represent syntax errors from parsing python strings
             msglines = self.lines[:ex.lineno]
             if ex.offset:
-                msglines.append(" "*ex.offset + '^')
+                msglines.append(" " * ex.offset + '^')
             msglines.append("(code was compiled probably from here: %s)" % filename)
             newex = SyntaxError('\n'.join(msglines))
             newex.offset = ex.offset
@@ -198,8 +201,8 @@ class Source(object):
 # public API shortcut functions
 #
 
-def compile_(source, filename=None, mode='exec', flags=
-            generators.compiler_flag, dont_inherit=0):
+
+def compile_(source, filename=None, mode='exec', flags=generators.compiler_flag, dont_inherit=0):
     """ compile the given source to a raw code object,
         and maintain an internal cache which allows later
         retrieval of the source code for the code object
@@ -208,7 +211,7 @@ def compile_(source, filename=None, mode='exec', flags=
     if _ast is not None and isinstance(source, _ast.AST):
         # XXX should Source support having AST?
         return cpy_compile(source, filename, mode, flags, dont_inherit)
-    _genframe = sys._getframe(1) # the caller
+    _genframe = sys._getframe(1)  # the caller
     s = Source(source)
     co = s.compile(filename, mode, flags, _genframe=_genframe)
     return co
@@ -245,12 +248,13 @@ def getfslineno(obj):
 # helper functions
 #
 
+
 def findsource(obj):
     try:
         sourcelines, lineno = py.std.inspect.findsource(obj)
     except py.builtin._sysex:
         raise
-    except:
+    except:  # noqa
         return None, -1
     source = Source()
     source.lines = [line.rstrip() for line in sourcelines]
@@ -274,7 +278,7 @@ def deindent(lines, offset=None):
             line = line.expandtabs()
             s = line.lstrip()
             if s:
-                offset = len(line)-len(s)
+                offset = len(line) - len(s)
                 break
         else:
             offset = 0
@@ -293,11 +297,11 @@ def deindent(lines, offset=None):
     try:
         for _, _, (sline, _), (eline, _), _ in tokenize.generate_tokens(lambda: next(it)):
             if sline > len(lines):
-                break # End of input reached
+                break  # End of input reached
             if sline > len(newlines):
                 line = lines[sline - 1].expandtabs()
                 if line.lstrip() and line[:offset].isspace():
-                    line = line[offset:] # Deindent
+                    line = line[offset:]  # Deindent
                 newlines.append(line)
 
             for i in range(sline, eline):
@@ -315,29 +319,29 @@ def get_statement_startend2(lineno, node):
     import ast
     # flatten all statements and except handlers into one lineno-list
     # AST's line numbers start indexing at 1
-    l = []
+    values = []
     for x in ast.walk(node):
         if isinstance(x, _ast.stmt) or isinstance(x, _ast.ExceptHandler):
-            l.append(x.lineno - 1)
+            values.append(x.lineno - 1)
             for name in "finalbody", "orelse":
                 val = getattr(x, name, None)
                 if val:
                     # treat the finally/orelse part as its own statement
-                    l.append(val[0].lineno - 1 - 1)
-    l.sort()
-    insert_index = bisect_right(l, lineno)
-    start = l[insert_index - 1]
-    if insert_index >= len(l):
+                    values.append(val[0].lineno - 1 - 1)
+    values.sort()
+    insert_index = bisect_right(values, lineno)
+    start = values[insert_index - 1]
+    if insert_index >= len(values):
         end = None
     else:
-        end = l[insert_index]
+        end = values[insert_index]
     return start, end
 
 
 def getstatementrange_ast(lineno, source, assertion=False, astnode=None):
     if astnode is None:
         content = str(source)
-        if sys.version_info < (2,7):
+        if sys.version_info < (2, 7):
             content += "\n"
         try:
             astnode = compile(content, "source", "exec", 1024)  # 1024 for AST
@@ -393,7 +397,7 @@ def getstatementrange_old(lineno, source, assertion=False):
                 raise IndexError("likely a subclass")
             if "assert" not in line and "raise" not in line:
                 continue
-        trylines = source.lines[start:lineno+1]
+        trylines = source.lines[start:lineno + 1]
         # quick hack to prepare parsing an indented line with
         # compile_command() (which errors on "return" outside defs)
         trylines.insert(0, 'def xxx():')
@@ -405,10 +409,8 @@ def getstatementrange_old(lineno, source, assertion=False):
             continue
 
         # 2. find the end of the statement
-        for end in range(lineno+1, len(source)+1):
+        for end in range(lineno + 1, len(source) + 1):
             trysource = source[start:end]
             if trysource.isparseable():
                 return start, end
     raise SyntaxError("no valid source range around line %d " % (lineno,))
-
-

_pytest/assertion/__init__.py

@@ -25,7 +25,6 @@ def pytest_addoption(parser):
                             expression information.""")
 
 
-
 def register_assert_rewrite(*names):
     """Register one or more module names to be rewritten on import.
 

_pytest/assertion/rewrite.py

@@ -36,10 +36,11 @@ PYC_TAIL = "." + PYTEST_TAG + PYC_EXT
 REWRITE_NEWLINES = sys.version_info[:2] != (2, 7) and sys.version_info < (3, 2)
 ASCII_IS_DEFAULT_ENCODING = sys.version_info[0] < 3
 
-if sys.version_info >= (3,5):
+if sys.version_info >= (3, 5):
     ast_Call = ast.Call
 else:
-    ast_Call = lambda a,b,c: ast.Call(a, b, c, None, None)
+    def ast_Call(a, b, c):
+        return ast.Call(a, b, c, None, None)
 
 
 class AssertionRewritingHook(object):
@@ -162,10 +163,6 @@ class AssertionRewritingHook(object):
         # 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 fn_pypath.fnmatch(pat):
                 state.trace("matched test file %r" % (fn,))
                 return True
@@ -213,14 +210,12 @@ class AssertionRewritingHook(object):
             mod.__cached__ = pyc
             mod.__loader__ = self
             py.builtin.exec_(co, mod.__dict__)
-        except:
+        except:  # noqa
             if name in sys.modules:
                 del sys.modules[name]
             raise
         return sys.modules[name]
 
-
-
     def is_package(self, name):
         try:
             fd, fn, desc = imp.find_module(name)
@@ -265,7 +260,7 @@ def _write_pyc(state, co, source_stat, pyc):
         fp = open(pyc, "wb")
     except IOError:
         err = sys.exc_info()[1].errno
-        state.trace("error writing pyc file at %s: errno=%s" %(pyc, err))
+        state.trace("error writing pyc file at %s: errno=%s" % (pyc, err))
         # we ignore any failure to write the cache file
         # there are many reasons, permission-denied, __pycache__ being a
         # file etc.
@@ -287,6 +282,7 @@ N = "\n".encode("utf-8")
 cookie_re = re.compile(r"^[ \t\f]*#.*coding[:=][ \t]*[-\w.]+")
 BOM_UTF8 = '\xef\xbb\xbf'
 
+
 def _rewrite_test(config, fn):
     """Try to read and rewrite *fn* and return the code object."""
     state = config._assertstate
@@ -311,7 +307,7 @@ def _rewrite_test(config, fn):
         end2 = source.find("\n", end1 + 1)
         if (not source.startswith(BOM_UTF8) and
             cookie_re.match(source[0:end1]) is None and
-            cookie_re.match(source[end1 + 1:end2]) is None):
+                cookie_re.match(source[end1 + 1:end2]) is None):
             if hasattr(state, "_indecode"):
                 # encodings imported us again, so don't rewrite.
                 return None, None
@@ -344,6 +340,7 @@ def _rewrite_test(config, fn):
         return None, None
     return stat, co
 
+
 def _make_rewritten_pyc(state, source_stat, pyc, co):
     """Try to dump rewritten code to *pyc*."""
     if sys.platform.startswith("win"):
@@ -357,6 +354,7 @@ def _make_rewritten_pyc(state, source_stat, pyc, co):
         if _write_pyc(state, co, source_stat, proc_pyc):
             os.rename(proc_pyc, pyc)
 
+
 def _read_pyc(source, pyc, trace=lambda x: None):
     """Possibly read a pytest pyc containing rewritten code.
 
@@ -414,7 +412,8 @@ def _saferepr(obj):
     return repr.replace(t("\n"), t("\\n"))
 
 
-from _pytest.assertion.util import format_explanation as _format_explanation # noqa
+from _pytest.assertion.util import format_explanation as _format_explanation  # noqa
+
 
 def _format_assertmsg(obj):
     """Format the custom assertion message given.
@@ -443,9 +442,11 @@ def _format_assertmsg(obj):
         s = s.replace(t("\\n"), t("\n~"))
     return s
 
+
 def _should_repr_global_name(obj):
     return not hasattr(obj, "__name__") and not py.builtin.callable(obj)
 
+
 def _format_boolop(explanations, is_or):
     explanation = "(" + (is_or and " or " or " and ").join(explanations) + ")"
     if py.builtin._istext(explanation):
@@ -454,6 +455,7 @@ def _format_boolop(explanations, is_or):
         t = py.builtin.bytes
     return explanation.replace(t('%'), t('%%'))
 
+
 def _call_reprcompare(ops, results, expls, each_obj):
     for i, res, expl in zip(range(len(ops)), results, expls):
         try:
@@ -487,7 +489,7 @@ binop_map = {
     ast.Mult: "*",
     ast.Div: "/",
     ast.FloorDiv: "//",
-    ast.Mod: "%%", # escaped for string formatting
+    ast.Mod: "%%",  # escaped for string formatting
     ast.Eq: "==",
     ast.NotEq: "!=",
     ast.Lt: "<",
@@ -593,23 +595,26 @@ class AssertionRewriter(ast.NodeVisitor):
         # docstrings and __future__ imports.
         aliases = [ast.alias(py.builtin.builtins.__name__, "@py_builtins"),
                    ast.alias("_pytest.assertion.rewrite", "@pytest_ar")]
-        expect_docstring = True
+        doc = getattr(mod, "docstring", None)
+        expect_docstring = doc is None
+        if doc is not None and self.is_rewrite_disabled(doc):
+            return
         pos = 0
-        lineno = 0
+        lineno = 1
         for item in mod.body:
             if (expect_docstring and isinstance(item, ast.Expr) and
                     isinstance(item.value, ast.Str)):
                 doc = item.value.s
-                if "PYTEST_DONT_REWRITE" in doc:
-                    # The module has disabled assertion rewriting.
+                if self.is_rewrite_disabled(doc):
                     return
-                lineno += len(doc) - 1
                 expect_docstring = False
             elif (not isinstance(item, ast.ImportFrom) or item.level > 0 or
                   item.module != "__future__"):
                 lineno = item.lineno
                 break
             pos += 1
+        else:
+            lineno = item.lineno
         imports = [ast.Import([alias], lineno=lineno, col_offset=0)
                    for alias in aliases]
         mod.body[pos:pos] = imports
@@ -635,6 +640,9 @@ class AssertionRewriter(ast.NodeVisitor):
                       not isinstance(field, ast.expr)):
                     nodes.append(field)
 
+    def is_rewrite_disabled(self, docstring):
+        return "PYTEST_DONT_REWRITE" in docstring
+
     def variable(self):
         """Get a new variable."""
         # Use a character invalid in python identifiers to avoid clashing.
@@ -727,7 +735,7 @@ class AssertionRewriter(ast.NodeVisitor):
         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)
+                             'remove parentheses?', fslocation=fslocation)
         self.statements = []
         self.variables = []
         self.variable_counter = itertools.count()
@@ -791,7 +799,7 @@ class AssertionRewriter(ast.NodeVisitor):
             if i:
                 fail_inner = []
                 # cond is set in a prior loop iteration below
-                self.on_failure.append(ast.If(cond, fail_inner, [])) # noqa
+                self.on_failure.append(ast.If(cond, fail_inner, []))  # noqa
                 self.on_failure = fail_inner
             self.push_format_context()
             res, expl = self.visit(v)
@@ -843,7 +851,7 @@ class AssertionRewriter(ast.NodeVisitor):
             new_kwargs.append(ast.keyword(keyword.arg, res))
             if keyword.arg:
                 arg_expls.append(keyword.arg + "=" + expl)
-            else: ## **args have `arg` keywords with an .arg of None
+            else:  # **args have `arg` keywords with an .arg of None
                 arg_expls.append("**" + expl)
 
         expl = "%s(%s)" % (func_expl, ', '.join(arg_expls))
@@ -897,7 +905,6 @@ class AssertionRewriter(ast.NodeVisitor):
     else:
         visit_Call = visit_Call_legacy
 
-
     def visit_Attribute(self, attr):
         if not isinstance(attr.ctx, ast.Load):
             return self.generic_visit(attr)

_pytest/assertion/util.py

@@ -53,11 +53,11 @@ def _split_explanation(explanation):
     """
     raw_lines = (explanation or u('')).split('\n')
     lines = [raw_lines[0]]
-    for l in raw_lines[1:]:
-        if l and l[0] in ['{', '}', '~', '>']:
-            lines.append(l)
+    for values in raw_lines[1:]:
+        if values and values[0] in ['{', '}', '~', '>']:
+            lines.append(values)
         else:
-            lines[-1] += '\\n' + l
+            lines[-1] += '\\n' + values
     return lines
 
 
@@ -82,7 +82,7 @@ def _format_lines(lines):
             stack.append(len(result))
             stackcnt[-1] += 1
             stackcnt.append(0)
-            result.append(u(' +') + u('  ')*(len(stack)-1) + s + line[1:])
+            result.append(u(' +') + u('  ') * (len(stack) - 1) + s + line[1:])
         elif line.startswith('}'):
             stack.pop()
             stackcnt.pop()
@@ -91,7 +91,7 @@ def _format_lines(lines):
             assert line[0] in ['~', '>']
             stack[-1] += 1
             indent = len(stack) if line.startswith('~') else len(stack) - 1
-            result.append(u('  ')*indent + line[1:])
+            result.append(u('  ') * indent + line[1:])
     assert len(stack) == 1
     return result
 
@@ -106,16 +106,22 @@ 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))
-    right_repr = py.io.saferepr(right, maxsize=width-len(left_repr))
+    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))
 
-    issequence = lambda x: (isinstance(x, (list, tuple, Sequence)) and
-                            not isinstance(x, basestring))
-    istext = lambda x: isinstance(x, basestring)
-    isdict = lambda x: isinstance(x, dict)
-    isset = lambda x: isinstance(x, (set, frozenset))
+    def issequence(x):
+        return (isinstance(x, (list, tuple, Sequence)) and not isinstance(x, basestring))
+
+    def istext(x):
+        return isinstance(x, basestring)
+
+    def isdict(x):
+        return isinstance(x, dict)
+
+    def isset(x):
+        return isinstance(x, (set, frozenset))
 
     def isiterable(obj):
         try:
@@ -285,7 +291,7 @@ def _compare_eq_dict(left, right, verbose=False):
 def _notin_text(term, text, verbose=False):
     index = text.find(term)
     head = text[:index]
-    tail = text[index+len(term):]
+    tail = text[index + len(term):]
     correct_text = head + tail
     diff = _diff_text(correct_text, text, verbose)
     newdiff = [u('%s is contained here:') % py.io.saferepr(term, maxsize=42)]

_pytest/cacheprovider.py

@@ -8,13 +8,14 @@ from __future__ import absolute_import, division, print_function
 import py
 import pytest
 import json
+import os
 from os.path import sep as _sep, altsep as _altsep
 
 
 class Cache(object):
     def __init__(self, config):
         self.config = config
-        self._cachedir = config.rootdir.join(".cache")
+        self._cachedir = Cache.cache_dir_from_config(config)
         self.trace = config.trace.root.get("cache")
         if config.getvalue("cacheclear"):
             self.trace("clearing cachedir")
@@ -22,6 +23,16 @@ class Cache(object):
                 self._cachedir.remove()
             self._cachedir.mkdir()
 
+    @staticmethod
+    def cache_dir_from_config(config):
+        cache_dir = config.getini("cache_dir")
+        cache_dir = os.path.expanduser(cache_dir)
+        cache_dir = os.path.expandvars(cache_dir)
+        if os.path.isabs(cache_dir):
+            return py.path.local(cache_dir)
+        else:
+            return config.rootdir.join(cache_dir)
+
     def makedir(self, name):
         """ return a directory path object with the given name.  If the
         directory does not yet exist, it will be created.  You can use it
@@ -89,31 +100,31 @@ class Cache(object):
 
 class LFPlugin:
     """ Plugin which implements the --lf (run last-failing) option """
+
     def __init__(self, config):
         self.config = config
         active_keys = 'lf', 'failedfirst'
         self.active = any(config.getvalue(key) for key in active_keys)
-        if self.active:
-            self.lastfailed = config.cache.get("cache/lastfailed", {})
-        else:
-            self.lastfailed = {}
+        self.lastfailed = config.cache.get("cache/lastfailed", {})
+        self._previously_failed_count = None
 
-    def pytest_report_header(self):
+    def pytest_report_collectionfinish(self):
         if self.active:
-            if not self.lastfailed:
+            if not self._previously_failed_count:
                 mode = "run all (no recorded failures)"
             else:
-                mode = "rerun last %d failures%s" % (
-                    len(self.lastfailed),
-                    " first" if self.config.getvalue("failedfirst") else "")
+                noun = 'failure' if self._previously_failed_count == 1 else 'failures'
+                suffix = " first" if self.config.getvalue("failedfirst") else ""
+                mode = "rerun previous {count} {noun}{suffix}".format(
+                    count=self._previously_failed_count, suffix=suffix, noun=noun
+                )
             return "run-last-failure: %s" % mode
 
     def pytest_runtest_logreport(self, report):
-        if report.failed and "xfail" not in report.keywords:
+        if (report.when == 'call' and report.passed) or report.skipped:
+            self.lastfailed.pop(report.nodeid, None)
+        elif report.failed:
             self.lastfailed[report.nodeid] = True
-        elif not report.failed:
-            if report.when == "call":
-                self.lastfailed.pop(report.nodeid, None)
 
     def pytest_collectreport(self, report):
         passed = report.outcome in ('passed', 'skipped')
@@ -135,11 +146,12 @@ class LFPlugin:
                     previously_failed.append(item)
                 else:
                     previously_passed.append(item)
-            if not previously_failed and previously_passed:
+            self._previously_failed_count = len(previously_failed)
+            if not previously_failed:
                 # running a subset of all tests with recorded failures outside
                 # of the set of tests currently executing
-                pass
-            elif self.config.getvalue("lf"):
+                return
+            if self.config.getvalue("lf"):
                 items[:] = previously_failed
                 config.hook.pytest_deselected(items=previously_passed)
             else:
@@ -149,8 +161,9 @@ class LFPlugin:
         config = self.config
         if config.getvalue("cacheshow") or hasattr(config, "slaveinput"):
             return
-        prev_failed = config.cache.get("cache/lastfailed", None) is not None
-        if (session.testscollected and prev_failed) or self.lastfailed:
+
+        saved_lastfailed = config.cache.get("cache/lastfailed", {})
+        if saved_lastfailed != self.lastfailed:
             config.cache.set("cache/lastfailed", self.lastfailed)
 
 
@@ -171,6 +184,9 @@ def pytest_addoption(parser):
     group.addoption(
         '--cache-clear', action='store_true', dest="cacheclear",
         help="remove all cache contents at start of test run.")
+    parser.addini(
+        "cache_dir", default='.cache',
+        help="cache directory path.")
 
 
 def pytest_cmdline_main(config):
@@ -179,7 +195,6 @@ def pytest_cmdline_main(config):
         return wrap_session(config, cacheshow)
 
 
-
 @pytest.hookimpl(tryfirst=True)
 def pytest_configure(config):
     config.cache = Cache(config)
@@ -224,7 +239,7 @@ def cacheshow(config, session):
         val = config.cache.get(key, dummy)
         if val is dummy:
             tw.line("%s contains unreadable content, "
-                  "will be ignored" % key)
+                    "will be ignored" % key)
         else:
             tw.line("%s contains:" % key)
             stream = py.io.TextIO()
@@ -236,7 +251,7 @@ def cacheshow(config, session):
     if ddir.isdir() and ddir.listdir():
         tw.sep("-", "cache directories")
         for p in sorted(basedir.join("d").visit()):
-            #if p.check(dir=1):
+            # if p.check(dir=1):
             #    print("%s/" % p.relto(basedir))
             if p.isfile():
                 key = p.relto(basedir)

_pytest/capture.py

@@ -36,7 +36,8 @@ def pytest_addoption(parser):
 def pytest_load_initial_conftests(early_config, parser, args):
     ns = early_config.known_args_namespace
     if ns.capture == "fd":
-        _py36_windowsconsoleio_workaround()
+        _py36_windowsconsoleio_workaround(sys.stdout)
+    _colorama_workaround()
     _readline_workaround()
     pluginmanager = early_config.pluginmanager
     capman = CaptureManager(ns.capture)
@@ -134,7 +135,7 @@ class CaptureManager:
         self.resumecapture()
         self.activate_funcargs(item)
         yield
-        #self.deactivate_funcargs() called from suspendcapture()
+        # self.deactivate_funcargs() called from suspendcapture()
         self.suspendcapture_item(item, "call")
 
     @pytest.hookimpl(hookwrapper=True)
@@ -171,6 +172,7 @@ def capsys(request):
     request.node._capfuncarg = c = CaptureFixture(SysCapture, request)
     return c
 
+
 @pytest.fixture
 def capfd(request):
     """Enable capturing of writes to file descriptors 1 and 2 and make
@@ -238,6 +240,7 @@ def safe_text_dupfile(f, mode, default_encoding="UTF8"):
 
 class EncodedFile(object):
     errors = "strict"  # possibly needed by py3 code (issue555)
+
     def __init__(self, buffer, encoding):
         self.buffer = buffer
         self.encoding = encoding
@@ -251,6 +254,11 @@ class EncodedFile(object):
         data = ''.join(linelist)
         self.write(data)
 
+    @property
+    def name(self):
+        """Ensure that file.name is a string."""
+        return repr(self.buffer)
+
     def __getattr__(self, name):
         return getattr(object.__getattribute__(self, "buffer"), name)
 
@@ -318,9 +326,11 @@ class MultiCapture(object):
         return (self.out.snap() if self.out is not None else "",
                 self.err.snap() if self.err is not None else "")
 
+
 class NoCapture:
     __init__ = start = done = suspend = resume = lambda *args: None
 
+
 class FDCapture:
     """ Capture IO to/from a given os-level filedescriptor. """
 
@@ -393,7 +403,7 @@ class FDCapture:
     def writeorg(self, data):
         """ write to original file descriptor. """
         if py.builtin._istext(data):
-            data = data.encode("utf8") # XXX use encoding of original stream
+            data = data.encode("utf8")  # XXX use encoding of original stream
         os.write(self.targetfd_save, data)
 
 
@@ -463,12 +473,30 @@ class DontReadFromInput:
 
     @property
     def buffer(self):
-        if sys.version_info >= (3,0):
+        if sys.version_info >= (3, 0):
             return self
         else:
             raise AttributeError('redirected stdin has no attribute buffer')
 
 
+def _colorama_workaround():
+    """
+    Ensure colorama is imported so that it attaches to the correct stdio
+    handles on Windows.
+
+    colorama uses the terminal on import time. So if something does the
+    first import of colorama while I/O capture is active, colorama will
+    fail in various ways.
+    """
+
+    if not sys.platform.startswith('win32'):
+        return
+    try:
+        import colorama  # noqa
+    except ImportError:
+        pass
+
+
 def _readline_workaround():
     """
     Ensure readline is imported so that it attaches to the correct stdio
@@ -496,7 +524,7 @@ def _readline_workaround():
         pass
 
 
-def _py36_windowsconsoleio_workaround():
+def _py36_windowsconsoleio_workaround(stream):
     """
     Python 3.6 implemented unicode console handling for Windows. This works
     by reading/writing to the raw console handle using
@@ -513,13 +541,20 @@ def _py36_windowsconsoleio_workaround():
     also means a different handle by replicating the logic in
     "Py_lifecycle.c:initstdio/create_stdio".
 
+    :param stream: in practice ``sys.stdout`` or ``sys.stderr``, but given
+        here as parameter for unittesting purposes.
+
     See https://github.com/pytest-dev/py/issues/103
     """
     if not sys.platform.startswith('win32') or sys.version_info[:2] < (3, 6):
         return
 
-    buffered = hasattr(sys.stdout.buffer, 'raw')
-    raw_stdout = sys.stdout.buffer.raw if buffered else sys.stdout.buffer
+    # bail out if ``stream`` doesn't seem like a proper ``io`` stream (#2666)
+    if not hasattr(stream, 'buffer'):
+        return
+
+    buffered = hasattr(stream.buffer, 'raw')
+    raw_stdout = stream.buffer.raw if buffered else stream.buffer
 
     if not isinstance(raw_stdout, io._WindowsConsoleIO):
         return

_pytest/compat.py

@@ -10,8 +10,8 @@ import functools
 
 import py
 
-import  _pytest
-
+import _pytest
+from _pytest.outcomes import TEST_OUTCOME
 
 
 try:
@@ -59,7 +59,7 @@ def iscoroutinefunction(func):
     which in turns also initializes the "logging" module as side-effect (see issue #8).
     """
     return (getattr(func, '_is_coroutine', False) or
-           (hasattr(inspect, 'iscoroutinefunction') and inspect.iscoroutinefunction(func)))
+            (hasattr(inspect, 'iscoroutinefunction') and inspect.iscoroutinefunction(func)))
 
 
 def getlocation(function, curdir):
@@ -68,7 +68,7 @@ def getlocation(function, curdir):
     lineno = py.builtin._getcode(function).co_firstlineno
     if fn.relto(curdir):
         fn = fn.relto(curdir)
-    return "%s:%d" %(fn, lineno+1)
+    return "%s:%d" % (fn, lineno + 1)
 
 
 def num_mock_patch_args(function):
@@ -79,13 +79,21 @@ def num_mock_patch_args(function):
     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])
+                    if not p.attribute_name and p.new is mock.DEFAULT])
     return len(patchings)
 
 
-def getfuncargnames(function, startindex=None):
+def getfuncargnames(function, startindex=None, cls=None):
+    """
+    @RonnyPfannschmidt: This function should be refactored when we revisit fixtures. The
+    fixture mechanism should ask the node for the fixture names, and not try to obtain
+    directly from the function object well after collection has occurred.
+    """
+    if startindex is None and cls is not None:
+        is_staticmethod = isinstance(cls.__dict__.get(function.__name__, None), staticmethod)
+        startindex = 0 if is_staticmethod else 1
     # XXX merge with main.py's varnames
-    #assert not isclass(function)
+    # assert not isclass(function)
     realfunction = function
     while hasattr(realfunction, "__wrapped__"):
         realfunction = realfunction.__wrapped__
@@ -111,8 +119,7 @@ def getfuncargnames(function, startindex=None):
     return tuple(argnames[startindex:])
 
 
-
-if  sys.version_info[:2] == (2, 6):
+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
@@ -125,10 +132,11 @@ if  sys.version_info[:2] == (2, 6):
 if _PY3:
     import codecs
     imap = map
+    izip = zip
     STRING_TYPES = bytes, str
     UNICODE_TYPES = str,
 
-    def _escape_strings(val):
+    def _ascii_escaped(val):
         """If val is pure ascii, returns it as a str().  Otherwise, escapes
         bytes objects into a sequence of escaped bytes:
 
@@ -160,9 +168,9 @@ else:
     STRING_TYPES = bytes, str, unicode
     UNICODE_TYPES = unicode,
 
-    from itertools import imap  # NOQA
+    from itertools import imap, izip  # NOQA
 
-    def _escape_strings(val):
+    def _ascii_escaped(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.
@@ -222,14 +230,16 @@ def getimfunc(func):
 
 
 def safe_getattr(object, name, default):
-    """ Like getattr but return default upon any Exception.
+    """ Like getattr but return default upon any Exception or any OutcomeException.
 
     Attribute access can potentially fail for 'evil' Python objects.
     See issue #214.
+    It catches OutcomeException because of #2490 (issue #580), new outcomes are derived from BaseException
+    instead of Exception (for more details check #2707)
     """
     try:
         return getattr(object, name, default)
-    except Exception:
+    except TEST_OUTCOME:
         return default
 
 
@@ -283,7 +293,15 @@ def _setup_collect_fakemodule():
 
 
 if _PY2:
-    from py.io import TextIO as CaptureIO
+    # Without this the test_dupfile_on_textio will fail, otherwise CaptureIO could directly inherit from StringIO.
+    from py.io import TextIO
+
+    class CaptureIO(TextIO):
+
+        @property
+        def encoding(self):
+            return getattr(self, '_encoding', 'UTF-8')
+
 else:
     import io
 
@@ -297,6 +315,7 @@ else:
         def getvalue(self):
             return self.buffer.getvalue().decode('UTF-8')
 
+
 class FuncargnamesCompatAttr(object):
     """ helper class so that Metafunc, Function and FixtureRequest
     don't need to each define the "funcargnames" compatibility attribute.

_pytest/config.py

@@ -60,9 +60,10 @@ def main(args=None, plugins=None):
                 config._ensure_unconfigure()
     except UsageError as e:
         for msg in e.args:
-            sys.stderr.write("ERROR: %s\n" %(msg,))
+            sys.stderr.write("ERROR: %s\n" % (msg,))
         return 4
 
+
 class cmdline:  # compatibility namespace
     main = staticmethod(main)
 
@@ -102,10 +103,10 @@ def directory_arg(path, optname):
 _preinit = []
 
 default_plugins = (
-     "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 warnings").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 warnings").split()
 
 
 builtin_plugins = set(default_plugins)
@@ -116,6 +117,7 @@ def _preloadplugins():
     assert not _preinit
     _preinit.append(get_config())
 
+
 def get_config():
     if _preinit:
         return _preinit.pop(0)
@@ -126,6 +128,7 @@ def get_config():
         pluginmanager.import_plugin(spec)
     return config
 
+
 def get_plugin_manager():
     """
     Obtain a new instance of the
@@ -137,6 +140,7 @@ def get_plugin_manager():
     """
     return get_config().pluginmanager
 
+
 def _prepareconfig(args=None, plugins=None):
     warning = None
     if args is None:
@@ -161,7 +165,7 @@ def _prepareconfig(args=None, plugins=None):
         if warning:
             config.warn('C1', warning)
         return pluginmanager.hook.pytest_cmdline_parse(
-                pluginmanager=pluginmanager, args=args)
+            pluginmanager=pluginmanager, args=args)
     except BaseException:
         config._ensure_unconfigure()
         raise
@@ -176,6 +180,7 @@ class PytestPluginManager(PluginManager):
       ``pytest_plugins`` global variables found in plugins being loaded;
     * ``conftest.py`` loading during start-up;
     """
+
     def __init__(self):
         super(PytestPluginManager, self).__init__("pytest", implprefix="pytest_")
         self._conftest_plugins = set()
@@ -206,7 +211,8 @@ class PytestPluginManager(PluginManager):
         """
         .. deprecated:: 2.8
 
-        Use :py:meth:`pluggy.PluginManager.add_hookspecs <_pytest.vendored_packages.pluggy.PluginManager.add_hookspecs>` instead.
+        Use :py:meth:`pluggy.PluginManager.add_hookspecs <_pytest.vendored_packages.pluggy.PluginManager.add_hookspecs>`
+        instead.
         """
         warning = dict(code="I2",
                        fslocation=_pytest._code.getfslineno(sys._getframe(1)),
@@ -235,7 +241,7 @@ class PytestPluginManager(PluginManager):
 
     def parse_hookspec_opts(self, module_or_class, name):
         opts = super(PytestPluginManager, self).parse_hookspec_opts(
-                                                module_or_class, name)
+            module_or_class, name)
         if opts is None:
             method = getattr(module_or_class, name)
             if name.startswith("pytest_"):
@@ -258,7 +264,7 @@ class PytestPluginManager(PluginManager):
         ret = super(PytestPluginManager, self).register(plugin, name)
         if ret:
             self.hook.pytest_plugin_registered.call_historic(
-                      kwargs=dict(plugin=plugin, manager=self))
+                kwargs=dict(plugin=plugin, manager=self))
 
             if isinstance(plugin, types.ModuleType):
                 self.consider_module(plugin)
@@ -276,11 +282,11 @@ class PytestPluginManager(PluginManager):
         # XXX now that the pluginmanager exposes hookimpl(tryfirst...)
         # we should remove tryfirst/trylast as markers
         config.addinivalue_line("markers",
-            "tryfirst: mark a hook implementation function such that the "
-            "plugin machinery will try to call it first/as early as possible.")
+                                "tryfirst: mark a hook implementation function such that the "
+                                "plugin machinery will try to call it first/as early as possible.")
         config.addinivalue_line("markers",
-            "trylast: mark a hook implementation function such that the "
-            "plugin machinery will try to call it last/as late as possible.")
+                                "trylast: mark a hook implementation function such that the "
+                                "plugin machinery will try to call it last/as late as possible.")
 
     def _warn(self, message):
         kwargs = message if isinstance(message, dict) else {
@@ -304,7 +310,7 @@ class PytestPluginManager(PluginManager):
         """
         current = py.path.local()
         self._confcutdir = current.join(namespace.confcutdir, abs=True) \
-                                if namespace.confcutdir else None
+            if namespace.confcutdir else None
         self._noconftest = namespace.noconftest
         testpaths = namespace.file_or_dir
         foundanchor = False
@@ -315,7 +321,7 @@ class PytestPluginManager(PluginManager):
             if i != -1:
                 path = path[:i]
             anchor = current.join(path, abs=1)
-            if exists(anchor): # we found some file object
+            if exists(anchor):  # we found some file object
                 self._try_load_conftest(anchor)
                 foundanchor = True
         if not foundanchor:
@@ -382,7 +388,7 @@ class PytestPluginManager(PluginManager):
                     if path and path.relto(dirpath) or path == dirpath:
                         assert mod not in mods
                         mods.append(mod)
-            self.trace("loaded conftestmodule %r" %(mod))
+            self.trace("loaded conftestmodule %r" % (mod))
             self.consider_conftest(mod)
             return mod
 
@@ -392,7 +398,7 @@ class PytestPluginManager(PluginManager):
     #
 
     def consider_preparse(self, args):
-        for opt1,opt2 in zip(args, args[1:]):
+        for opt1, opt2 in zip(args, args[1:]):
             if opt1 == "-p":
                 self.consider_pluginarg(opt2)
 
@@ -446,7 +452,7 @@ class PytestPluginManager(PluginManager):
             import pytest
             if not hasattr(pytest, 'skip') or not isinstance(e, pytest.skip.Exception):
                 raise
-            self._warn("skipped plugin %r: %s" %((modname, e.msg)))
+            self._warn("skipped plugin %r: %s" % ((modname, e.msg)))
         else:
             mod = sys.modules[importspec]
             self.register(mod, modname)
@@ -511,7 +517,7 @@ class Parser:
         for i, grp in enumerate(self._groups):
             if grp.name == after:
                 break
-        self._groups.insert(i+1, group)
+        self._groups.insert(i + 1, group)
         return group
 
     def addoption(self, *opts, **attrs):
@@ -549,7 +555,7 @@ class Parser:
                     a = option.attrs()
                     arggroup.add_argument(*n, **a)
         # bash like autocompletion for dirs (appending '/')
-        optparser.add_argument(FILE_OR_DIR, nargs='*').completer=filescompleter
+        optparser.add_argument(FILE_OR_DIR, nargs='*').completer = filescompleter
         return optparser
 
     def parse_setoption(self, args, option, namespace=None):
@@ -693,7 +699,7 @@ class Argument:
         if self._attrs.get('help'):
             a = self._attrs['help']
             a = a.replace('%default', '%(default)s')
-            #a = a.replace('%prog', '%(prog)s')
+            # a = a.replace('%prog', '%(prog)s')
             self._attrs['help'] = a
         return self._attrs
 
@@ -777,7 +783,7 @@ class MyOptionParser(argparse.ArgumentParser):
             extra_info = {}
         self._parser = parser
         argparse.ArgumentParser.__init__(self, usage=parser._usage,
-            add_help=False, formatter_class=DropShorterLongHelpFormatter)
+                                         add_help=False, formatter_class=DropShorterLongHelpFormatter)
         # extra_info is a dict of (param -> value) to display if there's
         # an usage error to provide more contextual information to the user
         self.extra_info = extra_info
@@ -805,9 +811,10 @@ class DropShorterLongHelpFormatter(argparse.HelpFormatter):
     - shortcut if there are only two options and one of them is a short one
     - cache result on action object as this is called at least 2 times
     """
+
     def _format_action_invocation(self, action):
         orgstr = argparse.HelpFormatter._format_action_invocation(self, action)
-        if orgstr and orgstr[0] != '-': # only optional arguments
+        if orgstr and orgstr[0] != '-':  # only optional arguments
             return orgstr
         res = getattr(action, '_formatted_action_invocation', None)
         if res:
@@ -818,7 +825,7 @@ class DropShorterLongHelpFormatter(argparse.HelpFormatter):
             action._formatted_action_invocation = orgstr
             return orgstr
         return_list = []
-        option_map =  getattr(action, 'map_long_option', {})
+        option_map = getattr(action, 'map_long_option', {})
         if option_map is None:
             option_map = {}
         short_long = {}
@@ -836,7 +843,7 @@ class DropShorterLongHelpFormatter(argparse.HelpFormatter):
                     short_long[shortened] = xxoption
         # now short_long has been filled out to the longest with dashes
         # **and** we keep the right option ordering from add_argument
-        for option in options: #
+        for option in options:
             if len(option) == 2 or option[2] == ' ':
                 return_list.append(option)
             if option[2:] == short_long.get(option.replace('-', '')):
@@ -845,22 +852,26 @@ class DropShorterLongHelpFormatter(argparse.HelpFormatter):
         return action._formatted_action_invocation
 
 
-
 def _ensure_removed_sysmodule(modname):
     try:
         del sys.modules[modname]
     except KeyError:
         pass
 
+
 class CmdOptions(object):
     """ holds cmdline options as attributes."""
+
     def __init__(self, values=()):
         self.__dict__.update(values)
+
     def __repr__(self):
-        return "<CmdOptions %r>" %(self.__dict__,)
+        return "<CmdOptions %r>" % (self.__dict__,)
+
     def copy(self):
         return CmdOptions(self.__dict__)
 
+
 class Notset:
     def __repr__(self):
         return "<NOTSET>"
@@ -870,6 +881,18 @@ notset = Notset()
 FILE_OR_DIR = 'file_or_dir'
 
 
+def _iter_rewritable_modules(package_files):
+    for fn in package_files:
+        is_simple_module = '/' not in fn and fn.endswith('.py')
+        is_package = fn.count('/') == 1 and fn.endswith('__init__.py')
+        if is_simple_module:
+            module_name, _ = os.path.splitext(fn)
+            yield module_name
+        elif is_package:
+            package_name = os.path.dirname(fn)
+            yield package_name
+
+
 class Config(object):
     """ access to configuration values, pluginmanager and plugin hooks.  """
 
@@ -940,14 +963,14 @@ class Config(object):
         else:
             style = "native"
         excrepr = excinfo.getrepr(funcargs=True,
-            showlocals=getattr(option, 'showlocals', False),
-            style=style,
-        )
+                                  showlocals=getattr(option, 'showlocals', False),
+                                  style=style,
+                                  )
         res = self.hook.pytest_internalerror(excrepr=excrepr,
                                              excinfo=excinfo)
         if not py.builtin.any(res):
             for line in str(excrepr).split("\n"):
-                sys.stderr.write("INTERNALERROR> %s\n" %line)
+                sys.stderr.write("INTERNALERROR> %s\n" % line)
                 sys.stderr.flush()
 
     def cwd_relative_nodeid(self, nodeid):
@@ -1030,15 +1053,8 @@ class Config(object):
             for entry in entrypoint.dist._get_metadata(metadata)
         )
 
-        for fn in package_files:
-            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)
+        for name in _iter_rewritable_modules(package_files):
+            hook.mark_rewrite(name)
 
     def _warn_about_missing_assertion(self, mode):
         try:
@@ -1068,13 +1084,12 @@ class Config(object):
         self.pluginmanager.load_setuptools_entrypoints('pytest11')
         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
         try:
             self.hook.pytest_load_initial_conftests(early_config=self,
-                    args=args, parser=self._parser)
+                                                    args=args, parser=self._parser)
         except ConftestImportFailure:
             e = sys.exc_info()[1]
             if ns.help or ns.version:
@@ -1092,17 +1107,17 @@ class Config(object):
             myver = pytest.__version__.split(".")
             if myver < ver:
                 raise pytest.UsageError(
-                    "%s:%d: requires pytest-%s, actual pytest-%s'" %(
-                    self.inicfg.config.path, self.inicfg.lineof('minversion'),
-                    minver, pytest.__version__))
+                    "%s:%d: requires pytest-%s, actual pytest-%s'" % (
+                        self.inicfg.config.path, self.inicfg.lineof('minversion'),
+                        minver, pytest.__version__))
 
     def parse(self, args, addopts=True):
         # parse given cmdline arguments into this config object.
         assert not hasattr(self, 'args'), (
-                "can only parse cmdline args at most once per Config object")
+            "can only parse cmdline args at most once per Config object")
         self._origargs = args
         self.hook.pytest_addhooks.call_historic(
-                                  kwargs=dict(pluginmanager=self.pluginmanager))
+            kwargs=dict(pluginmanager=self.pluginmanager))
         self._preparse(args, addopts=addopts)
         # XXX deprecated hook:
         self.hook.pytest_cmdline_preparse(config=self, args=args)
@@ -1125,7 +1140,7 @@ class Config(object):
         the first line in its value. """
         x = self.getini(name)
         assert isinstance(x, list)
-        x.append(line) # modifies the cached list inline
+        x.append(line)  # modifies the cached list inline
 
     def getini(self, name):
         """ return configuration value from an :ref:`ini file <inifiles>`. If the
@@ -1142,7 +1157,7 @@ class Config(object):
         try:
             description, type, default = self._parser._inidict[name]
         except KeyError:
-            raise ValueError("unknown configuration value: %r" %(name,))
+            raise ValueError("unknown configuration value: %r" % (name,))
         value = self._get_override_ini_value(name)
         if value is None:
             try:
@@ -1155,10 +1170,10 @@ class Config(object):
                 return []
         if type == "pathlist":
             dp = py.path.local(self.inicfg.config.path).dirpath()
-            l = []
+            values = []
             for relpath in shlex.split(value):
-                l.append(dp.join(relpath, abs=True))
-            return l
+                values.append(dp.join(relpath, abs=True))
+            return values
         elif type == "args":
             return shlex.split(value)
         elif type == "linelist":
@@ -1175,13 +1190,13 @@ class Config(object):
         except KeyError:
             return None
         modpath = py.path.local(mod.__file__).dirpath()
-        l = []
+        values = []
         for relroot in relroots:
             if not isinstance(relroot, py.path.local):
                 relroot = relroot.replace("/", py.path.local.sep)
                 relroot = modpath.join(relroot, abs=True)
-            l.append(relroot)
-        return l
+            values.append(relroot)
+        return values
 
     def _get_override_ini_value(self, name):
         value = None
@@ -1219,7 +1234,7 @@ class Config(object):
                 return default
             if skip:
                 import pytest
-                pytest.skip("no %r option found" %(name,))
+                pytest.skip("no %r option found" % (name,))
             raise ValueError("no option named %r" % (name,))
 
     def getvalue(self, name, path=None):
@@ -1230,12 +1245,14 @@ class Config(object):
         """ (deprecated, use getoption(skip=True)) """
         return self.getoption(name, skip=True)
 
+
 def exists(path, ignore=EnvironmentError):
     try:
         return path.check()
     except ignore:
         return False
 
+
 def getcfg(args, warnfunc=None):
     """
     Search the list of arguments for a valid ini-file for pytest,
@@ -1339,7 +1356,7 @@ def determine_setup(inifile, args, warnfunc=None):
                 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
+                    is_fs_root = os.path.splitdrive(str(rootdir))[1] == '/'
                     if is_fs_root:
                         rootdir = ancestor
     return rootdir, inifile, inicfg or {}
@@ -1361,7 +1378,7 @@ def setns(obj, dic):
         else:
             setattr(obj, name, value)
             obj.__all__.append(name)
-            #if obj != pytest:
+            # if obj != pytest:
             #    pytest.__all__.append(name)
             setattr(pytest, name, value)
 

_pytest/debugging.py

@@ -4,7 +4,6 @@ import pdb
 import sys
 
 
-
 def pytest_addoption(parser):
     group = parser.getgroup("general")
     group._addoption(
@@ -40,6 +39,7 @@ def pytest_configure(config):
     pytestPDB._pdb_cls = pdb_cls
     config._cleanup.append(fin)
 
+
 class pytestPDB:
     """ Pseudo PDB that defers to the real pdb. """
     _pluginmanager = None

_pytest/deprecated.py

@@ -7,8 +7,13 @@ be removed when the time comes.
 """
 from __future__ import absolute_import, division, print_function
 
+
+class RemovedInPytest4Warning(DeprecationWarning):
+    """warning class for features removed in pytest 4.0"""
+
+
 MAIN_STR_ARGS = 'passing a string to pytest.main() is deprecated, ' \
-                      'pass a list of arguments instead.'
+    'pass a list of arguments instead.'
 
 YIELD_TESTS = 'yield tests are deprecated, and scheduled to be removed in pytest 4.0'
 
@@ -21,4 +26,17 @@ SETUP_CFG_PYTEST = '[pytest] section in setup.cfg files is deprecated, use [tool
 
 GETFUNCARGVALUE = "use of getfuncargvalue is deprecated, use getfixturevalue"
 
-RESULT_LOG = '--result-log is deprecated and scheduled for removal in pytest 4.0'
+RESULT_LOG = (
+    '--result-log is deprecated and scheduled for removal in pytest 4.0.\n'
+    'See https://docs.pytest.org/en/latest/usage.html#creating-resultlog-format-files for more information.'
+)
+
+MARK_INFO_ATTRIBUTE = RemovedInPytest4Warning(
+    "MarkInfo objects are deprecated as they contain the merged marks"
+)
+
+MARK_PARAMETERSET_UNPACKING = RemovedInPytest4Warning(
+    "Applying marks directly to parameters is deprecated,"
+    " please use pytest.param(..., marks=...) instead.\n"
+    "For more details, see: https://docs.pytest.org/en/latest/parametrize.html"
+)

_pytest/doctest.py

@@ -22,28 +22,29 @@ DOCTEST_REPORT_CHOICES = (
     DOCTEST_REPORT_CHOICE_ONLY_FIRST_FAILURE,
 )
 
+
 def pytest_addoption(parser):
     parser.addini('doctest_optionflags', 'option flags for doctests',
-        type="args", default=["ELLIPSIS"])
+                  type="args", default=["ELLIPSIS"])
     parser.addini("doctest_encoding", 'encoding used for doctest files', default="utf-8")
     group = parser.getgroup("collect")
     group.addoption("--doctest-modules",
-        action="store_true", default=False,
-        help="run doctests in all .py modules",
-        dest="doctestmodules")
+                    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")
+                    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",
-        dest="doctestglob")
+                    action="append", default=[], metavar="pat",
+                    help="doctests file matching pattern, default: test*.txt",
+                    dest="doctestglob")
     group.addoption("--doctest-ignore-import-errors",
-        action="store_true", default=False,
-        help="ignore doctest ImportErrors",
-        dest="doctest_ignore_import_errors")
+                    action="store_true", default=False,
+                    help="ignore doctest ImportErrors",
+                    dest="doctest_ignore_import_errors")
 
 
 def pytest_collect_file(path, parent):
@@ -119,7 +120,7 @@ class DoctestItem(pytest.Item):
                 lines = ["%03d %s" % (i + test.lineno + 1, x)
                          for (i, x) in enumerate(lines)]
                 # trim docstring error lines to 10
-                lines = lines[example.lineno - 9:example.lineno + 1]
+                lines = lines[max(example.lineno - 9, 0):example.lineno + 1]
             else:
                 lines = ['EXAMPLE LOCATION UNKNOWN, not showing all tests of that example']
                 indent = '>>>'
@@ -128,18 +129,18 @@ class DoctestItem(pytest.Item):
                     indent = '...'
             if excinfo.errisinstance(doctest.DocTestFailure):
                 lines += checker.output_difference(example,
-                        doctestfailure.got, report_choice).split("\n")
+                                                   doctestfailure.got, report_choice).split("\n")
             else:
                 inner_excinfo = ExceptionInfo(excinfo.value.exc_info)
                 lines += ["UNEXPECTED EXCEPTION: %s" %
-                            repr(inner_excinfo.value)]
+                          repr(inner_excinfo.value)]
                 lines += traceback.format_exception(*excinfo.value.exc_info)
             return ReprFailDoctest(reprlocation, lines)
         else:
             return super(DoctestItem, self).repr_failure(excinfo)
 
     def reportinfo(self):
-        return self.fspath, None, "[doctest] %s" % self.name
+        return self.fspath, self.dtest.lineno, "[doctest] %s" % self.name
 
 
 def _get_flag_lookup():
@@ -163,6 +164,7 @@ def get_optionflags(parent):
         flag_acc |= flag_lookup_table[flag]
     return flag_acc
 
+
 class DoctestTextfile(pytest.Module):
     obj = None
 
@@ -177,7 +179,6 @@ class DoctestTextfile(pytest.Module):
         name = self.fspath.basename
         globs = {'__name__': '__main__'}
 
-
         optionflags = get_optionflags(self)
         runner = doctest.DebugRunner(verbose=0, optionflags=optionflags,
                                      checker=_get_checker())
@@ -218,9 +219,6 @@ class DoctestModule(pytest.Module):
         runner = doctest.DebugRunner(verbose=0, optionflags=optionflags,
                                      checker=_get_checker())
 
-        encoding = self.config.getini("doctest_encoding")
-        _fix_spoof_python2(runner, encoding)
-        
         for test in finder.find(module, module.__name__):
             if test.examples:  # skip empty doctests
                 yield DoctestItem(test.name, self, runner, test)
@@ -332,8 +330,11 @@ def _get_report_choice(key):
 
 def _fix_spoof_python2(runner, encoding):
     """
-    Installs a "SpoofOut" into the given DebugRunner so it properly deals with unicode output.
-    
+    Installs a "SpoofOut" into the given DebugRunner so it properly deals with unicode output. This
+    should patch only doctests for text files because they don't have a way to declare their
+    encoding. Doctests in docstrings from Python modules don't have the same problem given that
+    Python already decoded the strings.
+
     This fixes the problem related in issue #2434.
     """
     from _pytest.compat import _PY2

_pytest/fixtures.py

@@ -1,13 +1,14 @@
 from __future__ import absolute_import, division, print_function
-import sys
-
-from py._code.code import FormattedExcinfo
-
-import py
-import warnings
 
 import inspect
+import sys
+import warnings
+
+import py
+from py._code.code import FormattedExcinfo
+
 import _pytest
+from _pytest import nodes
 from _pytest._code.code import TerminalRepr
 from _pytest.compat import (
     NOTSET, exc_clear, _format_args,
@@ -15,9 +16,16 @@ from _pytest.compat import (
     is_generator, isclass, getimfunc,
     getlocation, getfuncargnames,
     safe_getattr,
+    FuncargnamesCompatAttr,
 )
-from _pytest.runner import fail
-from _pytest.compat import FuncargnamesCompatAttr
+from _pytest.outcomes import fail, TEST_OUTCOME
+
+
+if sys.version_info[:2] == (2, 6):
+    from ordereddict import OrderedDict
+else:
+    from collections import OrderedDict
+
 
 def pytest_sessionstart(session):
     import _pytest.python
@@ -38,6 +46,7 @@ scope2props["class"] = scope2props["module"] + ("cls",)
 scope2props["instance"] = scope2props["class"] + ("instance", )
 scope2props["function"] = scope2props["instance"] + ("function", "keywords")
 
+
 def scopeproperty(name=None, doc=None):
     def decoratescope(func):
         scopename = name or func.__name__
@@ -69,7 +78,7 @@ def add_funcarg_pseudo_fixture_def(collector, metafunc, fixturemanager):
     # XXX we can probably avoid this algorithm  if we modify CallSpec2
     # to directly care for creating the fixturedefs within its methods.
     if not metafunc._calls[0].funcargs:
-        return # this function call does not have direct parametrization
+        return  # this function call does not have direct parametrization
     # collect funcargs of all callspecs into a list of values
     arg2params = {}
     arg2scope = {}
@@ -105,28 +114,26 @@ def add_funcarg_pseudo_fixture_def(collector, metafunc, fixturemanager):
         if node and argname in node._name2pseudofixturedef:
             arg2fixturedefs[argname] = [node._name2pseudofixturedef[argname]]
         else:
-            fixturedef =  FixtureDef(fixturemanager, '', argname,
-                           get_direct_param_fixture_func,
-                           arg2scope[argname],
-                           valuelist, False, False)
+            fixturedef = FixtureDef(fixturemanager, '', argname,
+                                    get_direct_param_fixture_func,
+                                    arg2scope[argname],
+                                    valuelist, False, False)
             arg2fixturedefs[argname] = [fixturedef]
             if node is not None:
                 node._name2pseudofixturedef[argname] = fixturedef
 
 
-
 def getfixturemarker(obj):
     """ return fixturemarker or None if it doesn't exist or raised
     exceptions."""
     try:
         return getattr(obj, "_pytestfixturefunction", None)
-    except Exception:
+    except TEST_OUTCOME:
         # some objects raise errors like request (from flask import request)
         # we don't expect them to be fixture functions
         return None
 
 
-
 def get_parametrized_fixture_keys(item, scopenum):
     """ return list of keys for all parametrized arguments which match
     the specified scope. """
@@ -136,10 +143,10 @@ def get_parametrized_fixture_keys(item, scopenum):
     except AttributeError:
         pass
     else:
-        # cs.indictes.items() is random order of argnames but
-        # then again different functions (items) can change order of
-        # arguments so it doesn't matter much probably
-        for argname, param_index in cs.indices.items():
+        # cs.indices.items() is random order of argnames.  Need to
+        # sort this so that different calls to
+        # get_parametrized_fixture_keys will be deterministic.
+        for argname, param_index in sorted(cs.indices.items()):
             if cs._arg2scopenum[argname] != scopenum:
                 continue
             if scopenum == 0:    # session
@@ -161,20 +168,21 @@ def reorder_items(items):
     for scopenum in range(0, scopenum_function):
         argkeys_cache[scopenum] = d = {}
         for item in items:
-            keys = set(get_parametrized_fixture_keys(item, scopenum))
+            keys = OrderedDict.fromkeys(get_parametrized_fixture_keys(item, scopenum))
             if keys:
                 d[item] = keys
     return reorder_items_atscope(items, set(), argkeys_cache, 0)
 
+
 def reorder_items_atscope(items, ignore, argkeys_cache, scopenum):
     if scopenum >= scopenum_function or len(items) < 3:
         return items
     items_done = []
     while 1:
         items_before, items_same, items_other, newignore = \
-                slice_items(items, ignore, argkeys_cache[scopenum])
+            slice_items(items, ignore, argkeys_cache[scopenum])
         items_before = reorder_items_atscope(
-                            items_before, ignore, argkeys_cache,scopenum+1)
+            items_before, ignore, argkeys_cache, scopenum + 1)
         if items_same is None:
             # nothing to reorder in this scope
             assert items_other is None
@@ -195,9 +203,9 @@ def slice_items(items, ignore, scoped_argkeys_cache):
         for i, item in enumerate(it):
             argkeys = scoped_argkeys_cache.get(item)
             if argkeys is not None:
-                argkeys = argkeys.difference(ignore)
-                if argkeys:  # found a slicing key
-                    slicing_argkey = argkeys.pop()
+                newargkeys = OrderedDict.fromkeys(k for k in argkeys if k not in ignore)
+                if newargkeys:  # found a slicing key
+                    slicing_argkey, _ = newargkeys.popitem()
                     items_before = items[:i]
                     items_same = [item]
                     items_other = []
@@ -205,7 +213,7 @@ def slice_items(items, ignore, scoped_argkeys_cache):
                     for item in it:
                         argkeys = scoped_argkeys_cache.get(item)
                         if argkeys and slicing_argkey in argkeys and \
-                            slicing_argkey not in ignore:
+                                slicing_argkey not in ignore:
                             items_same.append(item)
                         else:
                             items_other.append(item)
@@ -237,10 +245,10 @@ def fillfixtures(function):
         request._fillfixtures()
 
 
-
 def get_direct_param_fixture_func(request):
     return request.param
 
+
 class FuncFixtureInfo:
     def __init__(self, argnames, names_closure, name2fixturedefs):
         self.argnames = argnames
@@ -279,7 +287,6 @@ class FixtureRequest(FuncargnamesCompatAttr):
         """ underlying collection node (depends on current request scope)"""
         return self._getscopeitem(self.scope)
 
-
     def _getnextfixturedef(self, argname):
         fixturedefs = self._arg2fixturedefs.get(argname, None)
         if fixturedefs is None:
@@ -301,7 +308,6 @@ class FixtureRequest(FuncargnamesCompatAttr):
         """ the pytest config object associated with this request. """
         return self._pyfuncitem.config
 
-
     @scopeproperty()
     def function(self):
         """ test function object if the request has a per-function scope. """
@@ -397,7 +403,7 @@ class FixtureRequest(FuncargnamesCompatAttr):
         :arg extrakey: added to internal caching key of (funcargname, scope).
         """
         if not hasattr(self.config, '_setupcache'):
-            self.config._setupcache = {} # XXX weakref?
+            self.config._setupcache = {}  # XXX weakref?
         cachekey = (self.fixturename, self._getscopeitem(scope), extrakey)
         cache = self.config._setupcache
         try:
@@ -428,7 +434,8 @@ class FixtureRequest(FuncargnamesCompatAttr):
         from _pytest import deprecated
         warnings.warn(
             deprecated.GETFUNCARGVALUE,
-            DeprecationWarning)
+            DeprecationWarning,
+            stacklevel=2)
         return self.getfixturevalue(argname)
 
     def _get_active_fixturedef(self, argname):
@@ -453,13 +460,13 @@ class FixtureRequest(FuncargnamesCompatAttr):
 
     def _get_fixturestack(self):
         current = self
-        l = []
+        values = []
         while 1:
             fixturedef = getattr(current, "_fixturedef", None)
             if fixturedef is None:
-                l.reverse()
-                return l
-            l.append(fixturedef)
+                values.reverse()
+                return values
+            values.append(fixturedef)
             current = current._parent_request
 
     def _getfixturevalue(self, fixturedef):
@@ -527,8 +534,8 @@ class FixtureRequest(FuncargnamesCompatAttr):
             fail("ScopeMismatch: You tried to access the %r scoped "
                  "fixture %r with a %r scoped request object, "
                  "involved factories\n%s" % (
-                    (requested_scope, argname, invoking_scope, "\n".join(lines))),
-                pytrace=False)
+                     (requested_scope, argname, invoking_scope, "\n".join(lines))),
+                 pytrace=False)
 
     def _factorytraceback(self):
         lines = []
@@ -553,12 +560,13 @@ class FixtureRequest(FuncargnamesCompatAttr):
         return node
 
     def __repr__(self):
-        return "<FixtureRequest for %r>" %(self.node)
+        return "<FixtureRequest for %r>" % (self.node)
 
 
 class SubRequest(FixtureRequest):
     """ a sub request for handling getting a fixture from a
     test function/fixture. """
+
     def __init__(self, request, scope, param, param_index, fixturedef):
         self._parent_request = request
         self.fixturename = fixturedef.argname
@@ -567,9 +575,8 @@ class SubRequest(FixtureRequest):
         self.param_index = param_index
         self.scope = scope
         self._fixturedef = fixturedef
-        self.addfinalizer = fixturedef.addfinalizer
         self._pyfuncitem = request._pyfuncitem
-        self._fixture_values  = request._fixture_values
+        self._fixture_values = request._fixture_values
         self._fixture_defs = request._fixture_defs
         self._arg2fixturedefs = request._arg2fixturedefs
         self._arg2index = request._arg2index
@@ -578,6 +585,9 @@ class SubRequest(FixtureRequest):
     def __repr__(self):
         return "<SubRequest %r for %r>" % (self.fixturename, self._pyfuncitem)
 
+    def addfinalizer(self, finalizer):
+        self._fixturedef.addfinalizer(finalizer)
+
 
 class ScopeMismatchError(Exception):
     """ A fixture function tries to use a different fixture function which
@@ -609,6 +619,7 @@ def scope2index(scope, descr, where=None):
 
 class FixtureLookupError(LookupError):
     """ could not return a requested Fixture (missing or invalid). """
+
     def __init__(self, argname, request, msg=None):
         self.argname = argname
         self.request = request
@@ -631,9 +642,9 @@ class FixtureLookupError(LookupError):
                 lines, _ = inspect.getsourcelines(get_real_func(function))
             except (IOError, IndexError, TypeError):
                 error_msg = "file %s, line %s: source code not available"
-                addline(error_msg % (fspath, lineno+1))
+                addline(error_msg % (fspath, lineno + 1))
             else:
-                addline("file %s, line %s" % (fspath, lineno+1))
+                addline("file %s, line %s" % (fspath, lineno + 1))
                 for i, line in enumerate(lines):
                     line = line.rstrip()
                     addline("  " + line)
@@ -649,7 +660,7 @@ class FixtureLookupError(LookupError):
                 if faclist and name not in available:
                     available.append(name)
             msg = "fixture %r not found" % (self.argname,)
-            msg += "\n available fixtures: %s" %(", ".join(sorted(available)),)
+            msg += "\n available fixtures: %s" % (", ".join(sorted(available)),)
             msg += "\n use 'pytest --fixtures [testpath]' for help on them."
 
         return FixtureLookupErrorRepr(fspath, lineno, tblines, msg, self.argname)
@@ -675,12 +686,12 @@ class FixtureLookupErrorRepr(TerminalRepr):
                 tw.line('{0}       {1}'.format(FormattedExcinfo.flow_marker,
                                                line.strip()), red=True)
         tw.line()
-        tw.line("%s:%d" % (self.filename, self.firstlineno+1))
+        tw.line("%s:%d" % (self.filename, self.firstlineno + 1))
 
 
 def fail_fixturefunc(fixturefunc, msg):
     fs, lineno = getfslineno(fixturefunc)
-    location = "%s:%s" % (fs, lineno+1)
+    location = "%s:%s" % (fs, lineno + 1)
     source = _pytest._code.Source(fixturefunc)
     fail(msg + ":\n\n" + str(source.indent()) + "\n" + location,
          pytrace=False)
@@ -699,7 +710,7 @@ def call_fixture_func(fixturefunc, request, kwargs):
                 pass
             else:
                 fail_fixturefunc(fixturefunc,
-                    "yield_fixture function has more than one 'yield'")
+                                 "yield_fixture function has more than one 'yield'")
 
         request.addfinalizer(teardown)
     else:
@@ -709,6 +720,7 @@ def call_fixture_func(fixturefunc, request, kwargs):
 
 class FixtureDef:
     """ A container for a factory definition. """
+
     def __init__(self, fixturemanager, baseid, argname, func, scope, params,
                  unittest=False, ids=None):
         self._fixturemanager = fixturemanager
@@ -733,10 +745,19 @@ class FixtureDef:
         self._finalizer.append(finalizer)
 
     def finish(self):
+        exceptions = []
         try:
             while self._finalizer:
-                func = self._finalizer.pop()
-                func()
+                try:
+                    func = self._finalizer.pop()
+                    func()
+                except:  # noqa
+                    exceptions.append(sys.exc_info())
+            if exceptions:
+                e = exceptions[0]
+                del exceptions  # ensure we don't keep all frames alive because of the traceback
+                py.builtin._reraise(*e)
+
         finally:
             ihook = self._fixturemanager.session.ihook
             ihook.pytest_fixture_post_finalizer(fixturedef=self)
@@ -774,6 +795,7 @@ class FixtureDef:
         return ("<FixtureDef name=%r scope=%r baseid=%r >" %
                 (self.argname, self.scope, self.baseid))
 
+
 def pytest_fixture_setup(fixturedef, request):
     """ Execution of fixture setup. """
     kwargs = {}
@@ -799,7 +821,7 @@ def pytest_fixture_setup(fixturedef, request):
     my_cache_key = request.param_index
     try:
         result = call_fixture_func(fixturefunc, request, kwargs)
-    except Exception:
+    except TEST_OUTCOME:
         fixturedef.cached_result = (None, my_cache_key, sys.exc_info())
         raise
     fixturedef.cached_result = (result, my_cache_key, None)
@@ -817,12 +839,11 @@ class FixtureFunctionMarker:
     def __call__(self, function):
         if isclass(function):
             raise ValueError(
-                    "class fixtures not supported (may be in the future)")
+                "class fixtures not supported (may be in the future)")
         function._pytestfixturefunction = self
         return function
 
 
-
 def fixture(scope="function", params=None, autouse=False, ids=None, name=None):
     """ (return a) decorator to mark a fixture factory function.
 
@@ -861,10 +882,10 @@ def fixture(scope="function", params=None, autouse=False, ids=None, name=None):
     instead of ``return``. In this case, the code block after the ``yield`` statement is executed
     as teardown code regardless of the test outcome. A fixture function must yield exactly once.
     """
-    if callable(scope) and params is None and autouse == False:
+    if callable(scope) and params is None and autouse is False:
         # direct decoration
         return FixtureFunctionMarker(
-                "function", params, autouse, name=name)(scope)
+            "function", params, autouse, name=name)(scope)
     if params is not None and not isinstance(params, (list, tuple)):
         params = list(params)
     return FixtureFunctionMarker(scope, params, autouse, ids=ids, name=name)
@@ -879,7 +900,7 @@ def yield_fixture(scope="function", params=None, autouse=False, ids=None, name=N
     if callable(scope) and params is None and not autouse:
         # direct decoration
         return FixtureFunctionMarker(
-                "function", params, autouse, ids=ids, name=name)(scope)
+            "function", params, autouse, ids=ids, name=name)(scope)
     else:
         return FixtureFunctionMarker(scope, params, autouse, ids=ids, name=name)
 
@@ -938,14 +959,9 @@ class FixtureManager:
         self._nodeid_and_autousenames = [("", self.config.getini("usefixtures"))]
         session.config.pluginmanager.register(self, "funcmanage")
 
-
     def getfixtureinfo(self, node, func, cls, funcargs=True):
         if funcargs and not hasattr(node, "nofuncargs"):
-            if cls is not None:
-                startindex = 1
-            else:
-                startindex = None
-            argnames = getfuncargnames(func, startindex)
+            argnames = getfuncargnames(func, cls=cls)
         else:
             argnames = ()
         usefixtures = getattr(func, "usefixtures", None)
@@ -969,8 +985,8 @@ class FixtureManager:
             # by their test id)
             if p.basename.startswith("conftest.py"):
                 nodeid = p.dirpath().relto(self.config.rootdir)
-                if p.sep != "/":
-                    nodeid = nodeid.replace(p.sep, "/")
+                if p.sep != nodes.SEP:
+                    nodeid = nodeid.replace(p.sep, nodes.SEP)
         self.parsefactories(plugin, nodeid)
 
     def _getautousenames(self, nodeid):
@@ -980,7 +996,7 @@ class FixtureManager:
             if nodeid.startswith(baseid):
                 if baseid:
                     i = len(baseid)
-                    nextchar = nodeid[i:i+1]
+                    nextchar = nodeid[i:i + 1]
                     if nextchar and nextchar not in ":/":
                         continue
                 autousenames.extend(basenames)
@@ -1025,9 +1041,14 @@ class FixtureManager:
             if faclist:
                 fixturedef = faclist[-1]
                 if fixturedef.params is not None:
-                    func_params = getattr(getattr(metafunc.function, 'parametrize', None), 'args', [[None]])
+                    parametrize_func = getattr(metafunc.function, 'parametrize', None)
+                    func_params = getattr(parametrize_func, 'args', [[None]])
+                    func_kwargs = getattr(parametrize_func, 'kwargs', {})
                     # skip directly parametrized arguments
-                    argnames = func_params[0]
+                    if "argnames" in func_kwargs:
+                        argnames = parametrize_func.kwargs["argnames"]
+                    else:
+                        argnames = func_params[0]
                     if not isinstance(argnames, (tuple, list)):
                         argnames = [x.strip() for x in argnames.split(",") if x.strip()]
                     if argname not in func_params and argname not in argnames:
@@ -1115,6 +1136,5 @@ class FixtureManager:
 
     def _matchfactories(self, fixturedefs, nodeid):
         for fixturedef in fixturedefs:
-            if nodeid.startswith(fixturedef.baseid):
+            if nodes.ischildnode(fixturedef.baseid, nodeid):
                 yield fixturedef
-

_pytest/freeze_support.py

@@ -5,7 +5,6 @@ pytest
 from __future__ import absolute_import, division, print_function
 
 
-
 def freeze_includes():
     """
     Returns a list of module names used by py.test that should be

_pytest/helpconfig.py

@@ -4,7 +4,8 @@ from __future__ import absolute_import, division, print_function
 import py
 import pytest
 from _pytest.config import PrintHelp
-import os, sys
+import os
+import sys
 from argparse import Action
 
 
@@ -41,20 +42,20 @@ class HelpAction(Action):
 def pytest_addoption(parser):
     group = parser.getgroup('debugconfig')
     group.addoption('--version', action="store_true",
-            help="display pytest lib version and import information.")
+                    help="display pytest lib version and import information.")
     group._addoption("-h", "--help", action=HelpAction, dest="help",
-            help="show help message and configuration info")
-    group._addoption('-p', action="append", dest="plugins", default = [],
-               metavar="name",
-               help="early-load given plugin (multi-allowed). "
-                    "To avoid loading of plugins, use the `no:` prefix, e.g. "
-                    "`no:doctest`.")
+                     help="show help message and configuration info")
+    group._addoption('-p', action="append", dest="plugins", default=[],
+                     metavar="name",
+                     help="early-load given plugin (multi-allowed). "
+                     "To avoid loading of plugins, use the `no:` prefix, e.g. "
+                     "`no:doctest`.")
     group.addoption('--traceconfig', '--trace-config',
-               action="store_true", default=False,
-               help="trace considerations of conftest.py files."),
+                    action="store_true", default=False,
+                    help="trace considerations of conftest.py files."),
     group.addoption('--debug',
-               action="store_true", dest="debug", default=False,
-               help="store internal tracing debug information in 'pytestdebug.log'.")
+                    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",
@@ -69,10 +70,10 @@ def pytest_cmdline_parse():
         path = os.path.abspath("pytestdebug.log")
         debugfile = open(path, 'w')
         debugfile.write("versions pytest-%s, py-%s, "
-                "python-%s\ncwd=%s\nargs=%s\n\n" %(
-            pytest.__version__, py.__version__,
-            ".".join(map(str, sys.version_info)),
-            os.getcwd(), config._origargs))
+                        "python-%s\ncwd=%s\nargs=%s\n\n" % (
+                            pytest.__version__, py.__version__,
+                            ".".join(map(str, sys.version_info)),
+                            os.getcwd(), config._origargs))
         config.trace.root.setwriter(debugfile.write)
         undo_tracing = config.pluginmanager.enable_tracing()
         sys.stderr.write("writing pytestdebug information to %s\n" % path)
@@ -86,11 +87,12 @@ def pytest_cmdline_parse():
 
         config.add_cleanup(unset_tracing)
 
+
 def pytest_cmdline_main(config):
     if config.option.version:
         p = py.path.local(pytest.__file__)
         sys.stderr.write("This is pytest version %s, imported from %s\n" %
-            (pytest.__version__, p))
+                         (pytest.__version__, p))
         plugininfo = getpluginversioninfo(config)
         if plugininfo:
             for line in plugininfo:
@@ -102,6 +104,7 @@ def pytest_cmdline_main(config):
         config._ensure_unconfigure()
         return 0
 
+
 def showhelp(config):
     reporter = config.pluginmanager.get_plugin('terminalreporter')
     tw = reporter._tw
@@ -117,7 +120,7 @@ def showhelp(config):
         if type is None:
             type = "string"
         spec = "%s (%s)" % (name, type)
-        line = "  %-24s %s" %(spec, help)
+        line = "  %-24s %s" % (spec, help)
         tw.line(line[:tw.fullwidth])
 
     tw.line()
@@ -146,6 +149,7 @@ conftest_options = [
     ('pytest_plugins', 'list of plugin names to load'),
 ]
 
+
 def getpluginversioninfo(config):
     lines = []
     plugininfo = config.pluginmanager.list_plugin_distinfo()
@@ -157,11 +161,12 @@ def getpluginversioninfo(config):
             lines.append("  " + content)
     return lines
 
+
 def pytest_report_header(config):
     lines = []
     if config.option.debug or config.option.traceconfig:
         lines.append("using: pytest-%s pylib-%s" %
-            (pytest.__version__,py.__version__))
+                     (pytest.__version__, py.__version__))
 
         verinfo = getpluginversioninfo(config)
         if verinfo:
@@ -175,5 +180,5 @@ def pytest_report_header(config):
                 r = plugin.__file__
             else:
                 r = repr(plugin)
-            lines.append("    %-20s: %s" %(name, r))
+            lines.append("    %-20s: %s" % (name, r))
     return lines

_pytest/hookspec.py

@@ -8,6 +8,7 @@ hookspec = HookspecMarker("pytest")
 # Initialization hooks called for every plugin
 # -------------------------------------------------------------------------
 
+
 @hookspec(historic=True)
 def pytest_addhooks(pluginmanager):
     """called at plugin registration time to allow adding new hooks via a call to
@@ -23,6 +24,7 @@ def pytest_namespace():
     time.
     """
 
+
 @hookspec(historic=True)
 def pytest_plugin_registered(plugin, manager):
     """ a new pytest plugin got registered. """
@@ -58,11 +60,20 @@ def pytest_addoption(parser):
     via (deprecated) ``pytest.config``.
     """
 
+
 @hookspec(historic=True)
 def pytest_configure(config):
-    """ called after command line options have been parsed
-    and all plugins and initial conftest files been loaded.
-    This hook is called for every plugin.
+    """
+    Allows plugins and conftest files to perform initial configuration.
+
+    This hook is called for every plugin and initial conftest file
+    after command line options have been parsed.
+
+    After that, the hook is called for other conftest files as they are
+    imported.
+
+    :arg config: pytest config object
+    :type config: _pytest.config.Config
     """
 
 # -------------------------------------------------------------------------
@@ -71,17 +82,25 @@ def pytest_configure(config):
 # discoverable conftest.py local plugins.
 # -------------------------------------------------------------------------
 
+
 @hookspec(firstresult=True)
 def pytest_cmdline_parse(pluginmanager, args):
-    """return initialized config object, parsing the specified args. """
+    """return initialized config object, parsing the specified args.
+
+    Stops at first non-None result, see :ref:`firstresult` """
+
 
 def pytest_cmdline_preparse(config, args):
     """(deprecated) modify command line arguments before option parsing. """
 
+
 @hookspec(firstresult=True)
 def pytest_cmdline_main(config):
     """ called for performing the main command line action. The default
-    implementation will invoke the configure hooks and runtest_mainloop. """
+    implementation will invoke the configure hooks and runtest_mainloop.
+
+    Stops at first non-None result, see :ref:`firstresult` """
+
 
 def pytest_load_initial_conftests(early_config, parser, args):
     """ implements the loading of initial conftest files ahead
@@ -94,89 +113,124 @@ def pytest_load_initial_conftests(early_config, parser, args):
 
 @hookspec(firstresult=True)
 def pytest_collection(session):
-    """ perform the collection protocol for the given session. """
+    """ perform the collection protocol for the given session.
+
+    Stops at first non-None result, see :ref:`firstresult` """
+
 
 def pytest_collection_modifyitems(session, config, items):
     """ called after collection has been performed, may filter or re-order
     the items in-place."""
 
+
 def pytest_collection_finish(session):
     """ called after collection has been performed and modified. """
 
+
 @hookspec(firstresult=True)
 def pytest_ignore_collect(path, config):
     """ return True to prevent considering this path for collection.
     This hook is consulted for all files and directories prior to calling
     more specific hooks.
+
+    Stops at first non-None result, see :ref:`firstresult`
     """
 
+
 @hookspec(firstresult=True)
 def pytest_collect_directory(path, parent):
-    """ called before traversing a directory for collection files. """
+    """ called before traversing a directory for collection files.
+
+    Stops at first non-None result, see :ref:`firstresult` """
+
 
 def pytest_collect_file(path, parent):
     """ return collection Node or None for the given path. Any new node
     needs to have the specified ``parent`` as a parent."""
 
 # logging hooks for collection
+
+
 def pytest_collectstart(collector):
     """ collector starts collecting. """
 
+
 def pytest_itemcollected(item):
     """ we just collected a test item. """
 
+
 def pytest_collectreport(report):
     """ collector finished collecting. """
 
+
 def pytest_deselected(items):
     """ called for test items deselected by keyword. """
 
+
 @hookspec(firstresult=True)
 def pytest_make_collect_report(collector):
-    """ perform ``collector.collect()`` and return a CollectReport. """
+    """ perform ``collector.collect()`` and return a CollectReport.
+
+    Stops at first non-None result, see :ref:`firstresult` """
 
 # -------------------------------------------------------------------------
 # Python test function related hooks
 # -------------------------------------------------------------------------
 
+
 @hookspec(firstresult=True)
 def pytest_pycollect_makemodule(path, parent):
     """ return a Module collector or None for the given path.
     This hook will be called for each matching test module path.
     The pytest_collect_file hook needs to be used if you want to
     create test modules for files that do not match as a test module.
-    """
+
+    Stops at first non-None result, see :ref:`firstresult` """
+
 
 @hookspec(firstresult=True)
 def pytest_pycollect_makeitem(collector, name, obj):
-    """ return custom item/collector for a python object in a module, or None.  """
+    """ return custom item/collector for a python object in a module, or None.
+
+    Stops at first non-None result, see :ref:`firstresult` """
+
 
 @hookspec(firstresult=True)
 def pytest_pyfunc_call(pyfuncitem):
-    """ call underlying test function. """
+    """ call underlying test function.
+
+    Stops at first non-None result, see :ref:`firstresult` """
+
 
 def pytest_generate_tests(metafunc):
     """ generate (multiple) parametrized calls to a test function."""
 
+
 @hookspec(firstresult=True)
 def pytest_make_parametrize_id(config, val, argname):
     """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``.
     The parameter name is available as ``argname``, if required.
-    """
+
+    Stops at first non-None result, see :ref:`firstresult` """
 
 # -------------------------------------------------------------------------
 # generic runtest related hooks
 # -------------------------------------------------------------------------
 
+
 @hookspec(firstresult=True)
 def pytest_runtestloop(session):
     """ called for performing the main runtest loop
-    (after collection finished). """
+    (after collection finished).
+
+    Stops at first non-None result, see :ref:`firstresult` """
+
 
 def pytest_itemstart(item, node):
     """ (deprecated, use pytest_runtest_logstart). """
 
+
 @hookspec(firstresult=True)
 def pytest_runtest_protocol(item, nextitem):
     """ implements the runtest_setup/call/teardown protocol for
@@ -190,17 +244,23 @@ def pytest_runtest_protocol(item, nextitem):
                    :py:func:`pytest_runtest_teardown`.
 
     :return boolean: True if no further hook implementations should be invoked.
-    """
+
+
+    Stops at first non-None result, see :ref:`firstresult` """
+
 
 def pytest_runtest_logstart(nodeid, location):
     """ signal the start of running a single test item. """
 
+
 def pytest_runtest_setup(item):
     """ called before ``pytest_runtest_call(item)``. """
 
+
 def pytest_runtest_call(item):
     """ called to execute the test ``item``. """
 
+
 def pytest_runtest_teardown(item, nextitem):
     """ called after ``pytest_runtest_call``.
 
@@ -210,12 +270,15 @@ def pytest_runtest_teardown(item, nextitem):
                    so that nextitem only needs to call setup-functions.
     """
 
+
 @hookspec(firstresult=True)
 def pytest_runtest_makereport(item, call):
     """ return a :py:class:`_pytest.runner.TestReport` object
     for the given :py:class:`pytest.Item <_pytest.main.Item>` and
     :py:class:`_pytest.runner.CallInfo`.
-    """
+
+    Stops at first non-None result, see :ref:`firstresult` """
+
 
 def pytest_runtest_logreport(report):
     """ process a test setup/call/teardown report relating to
@@ -225,9 +288,13 @@ def pytest_runtest_logreport(report):
 # Fixture related hooks
 # -------------------------------------------------------------------------
 
+
 @hookspec(firstresult=True)
 def pytest_fixture_setup(fixturedef, request):
-    """ performs fixture setup execution. """
+    """ performs fixture setup execution.
+
+    Stops at first non-None result, see :ref:`firstresult` """
+
 
 def pytest_fixture_post_finalizer(fixturedef):
     """ called after fixture teardown, but before the cache is cleared so
@@ -238,12 +305,15 @@ def pytest_fixture_post_finalizer(fixturedef):
 # test session related hooks
 # -------------------------------------------------------------------------
 
+
 def pytest_sessionstart(session):
     """ before session.main() is called. """
 
+
 def pytest_sessionfinish(session, exitstatus):
     """ whole test run finishes. """
 
+
 def pytest_unconfigure(config):
     """ called before test process is exited.  """
 
@@ -265,8 +335,12 @@ def pytest_assertrepr_compare(config, op, left, right):
 # hooks for influencing reporting (invoked from _pytest_terminal)
 # -------------------------------------------------------------------------
 
+
 def pytest_report_header(config, startdir):
-    """ return a string to be displayed as header info for terminal reporting.
+    """ return a string or list of strings to be displayed as header info for terminal reporting.
+
+    :param config: the pytest config object.
+    :param startdir: py.path object with the starting dir
 
     .. note::
 
@@ -275,9 +349,27 @@ def pytest_report_header(config, startdir):
         :ref:`discovers plugins during startup <pluginorder>`.
     """
 
+
+def pytest_report_collectionfinish(config, startdir, items):
+    """
+    .. versionadded:: 3.2
+
+    return a string or list of strings to be displayed after collection has finished successfully.
+
+    This strings will be displayed after the standard "collected X items" message.
+
+    :param config: the pytest config object.
+    :param startdir: py.path object with the starting dir
+    :param items: list of pytest items that are going to be executed; this list should not be modified.
+    """
+
+
 @hookspec(firstresult=True)
 def pytest_report_teststatus(report):
-    """ return result-category, shortletter and verbose word for reporting."""
+    """ return result-category, shortletter and verbose word for reporting.
+
+    Stops at first non-None result, see :ref:`firstresult` """
+
 
 def pytest_terminal_summary(terminalreporter, exitstatus):
     """ add additional section in terminal summary reporting.  """
@@ -293,20 +385,26 @@ def pytest_logwarning(message, code, nodeid, fslocation):
 # doctest hooks
 # -------------------------------------------------------------------------
 
+
 @hookspec(firstresult=True)
 def pytest_doctest_prepare_content(content):
-    """ return processed content for a given doctest"""
+    """ return processed content for a given doctest
+
+    Stops at first non-None result, see :ref:`firstresult` """
 
 # -------------------------------------------------------------------------
 # error handling and internal debugging hooks
 # -------------------------------------------------------------------------
 
+
 def pytest_internalerror(excrepr, excinfo):
     """ called for internal errors. """
 
+
 def pytest_keyboard_interrupt(excinfo):
     """ called for keyboard interrupt. """
 
+
 def pytest_exception_interact(node, call, report):
     """called when an exception was raised which can potentially be
     interactively handled.
@@ -315,6 +413,7 @@ def pytest_exception_interact(node, call, report):
     that is not an internal exception like ``skip.Exception``.
     """
 
+
 def pytest_enter_pdb(config):
     """ called upon pdb.set_trace(), can be used by plugins to take special
     action just before the python debugger enters in interactive mode.

_pytest/impl

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

_pytest/junitxml.py

@@ -17,6 +17,7 @@ import re
 import sys
 import time
 import pytest
+from _pytest import nodes
 from _pytest.config import filename_arg
 
 # Python 2.X and 3.X compatibility
@@ -252,7 +253,7 @@ def mangle_test_address(address):
     except ValueError:
         pass
     # convert file path to dotted path
-    names[0] = names[0].replace("/", '.')
+    names[0] = names[0].replace(nodes.SEP, '.')
     names[0] = _py_ext_re.sub("", names[0])
     # put any params back
     names[-1] += possible_open_bracket + params
@@ -378,8 +379,8 @@ class LogXML(object):
             close_report = next(
                 (rep for rep in self.open_reports
                  if (rep.nodeid == report.nodeid and
-                      getattr(rep, "item_index", None) == report_ii and
-                      getattr(rep, "worker_id", None) == report_wid
+                     getattr(rep, "item_index", None) == report_ii and
+                     getattr(rep, "worker_id", None) == report_wid
                      )
                  ), None)
             if close_report:
@@ -444,9 +445,9 @@ class LogXML(object):
         """
         if self.global_properties:
             return Junit.properties(
-                    [
-                        Junit.property(name=name, value=value)
-                        for name, value in self.global_properties
-                    ]
+                [
+                    Junit.property(name=name, value=value)
+                    for name, value in self.global_properties
+                ]
             )
         return ''

_pytest/main.py

@@ -6,6 +6,7 @@ import os
 import sys
 
 import _pytest
+from _pytest import nodes
 import _pytest._code
 import py
 try:
@@ -14,7 +15,8 @@ except ImportError:
     from UserDict import DictMixin as MappingMixin
 
 from _pytest.config import directory_arg, UsageError, hookimpl
-from _pytest.runner import collect_one_node, exit
+from _pytest.outcomes import exit
+from _pytest.runner import collect_one_node
 
 tracebackcutdir = py.path.local(_pytest.__file__).dirpath()
 
@@ -29,53 +31,57 @@ EXIT_NOTESTSCOLLECTED = 5
 
 def pytest_addoption(parser):
     parser.addini("norecursedirs", "directory patterns to avoid for recursion",
-        type="args", default=['.*', 'build', 'dist', 'CVS', '_darcs', '{arch}', '*.egg', 'venv'])
-    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",
+                  type="args", default=['.*', 'build', 'dist', 'CVS', '_darcs', '{arch}', '*.egg', 'venv'])
+    parser.addini("testpaths", "directories to search for tests when no files or directories are given in the "
+                               "command line.",
+                  type="args", default=[])
+    # parser.addini("dirpatterns",
     #    "patterns specifying possible locations of test files",
     #    type="linelist", default=["**/test_*.txt",
     #            "**/test_*.py", "**/*_test.py"]
-    #)
+    # )
     group = parser.getgroup("general", "running and selection options")
     group._addoption('-x', '--exitfirst', action="store_const",
-               dest="maxfail", const=1,
-               help="exit instantly on first error or failed test."),
+                     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,
-               help="exit after first num failures or errors.")
+                     action="store", type=int, dest="maxfail", default=0,
+                     help="exit after first num failures or errors.")
     group._addoption('--strict', action="store_true",
-               help="run pytest in strict mode, warnings become errors.")
+                     help="marks not registered in configuration file raise 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.")
+                     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.")
+                     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",
-        help="only collect tests, don't execute them."),
+                    help="only collect tests, don't execute them."),
     group.addoption('--pyargs', action="store_true",
-        help="try to interpret all arguments as python packages.")
+                    help="try to interpret all arguments as python packages.")
     group.addoption("--ignore", action="append", metavar="path",
-        help="ignore path during collection (multi-allowed).")
+                    help="ignore path during collection (multi-allowed).")
     # when changing this to --conf-cut-dir, config.py Conftest.setinitial
     # needs upgrading as well
     group.addoption('--confcutdir', dest="confcutdir", default=None,
-        metavar="dir", type=functools.partial(directory_arg, optname="--confcutdir"),
-        help="only load conftest.py's relative to specified 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.")
+                    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.")
+                    dest="keepduplicates", default=False,
+                    help="Keep duplicate tests.")
+    group.addoption('--collect-in-virtualenv', action='store_true',
+                    dest='collect_in_virtualenv', default=False,
+                    help="Don't ignore tests in a local virtualenv directory")
 
     group = parser.getgroup("debugconfig",
-        "test session debugging and configuration")
+                            "test session debugging and configuration")
     group.addoption('--basetemp', dest="basetemp", default=None, metavar="dir",
-               help="base temporary directory for this test run.")
-
+                    help="base temporary directory for this test run.")
 
 
 def pytest_namespace():
@@ -88,7 +94,7 @@ def pytest_namespace():
 
 
 def pytest_configure(config):
-    __import__('pytest').config = config # compatibiltiy
+    __import__('pytest').config = config  # compatibiltiy
 
 
 def wrap_session(config, doit):
@@ -112,7 +118,7 @@ def wrap_session(config, doit):
                     excinfo.typename, excinfo.value.msg))
             config.hook.pytest_keyboard_interrupt(excinfo=excinfo)
             session.exitstatus = EXIT_INTERRUPTED
-        except:
+        except:  # noqa
             excinfo = _pytest._code.ExceptionInfo()
             config.notify_exception(excinfo, config.option)
             session.exitstatus = EXIT_INTERNALERROR
@@ -160,22 +166,36 @@ def pytest_runtestloop(session):
         return True
 
     for i, item in enumerate(session.items):
-        nextitem = session.items[i+1] if i+1 < len(session.items) else None
+        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)
     return True
 
 
+def _in_venv(path):
+    """Attempts to detect if ``path`` is the root of a Virtual Environment by
+    checking for the existence of the appropriate activate script"""
+    bindir = path.join('Scripts' if sys.platform.startswith('win') else 'bin')
+    if not bindir.exists():
+        return False
+    activates = ('activate', 'activate.csh', 'activate.fish',
+                 'Activate', 'Activate.bat', 'Activate.ps1')
+    return any([fname.basename in activates for fname in bindir.listdir()])
+
+
 def pytest_ignore_collect(path, config):
-    p = path.dirpath()
-    ignore_paths = config._getconftest_pathlist("collect_ignore", path=p)
+    ignore_paths = config._getconftest_pathlist("collect_ignore", path=path.dirpath())
     ignore_paths = ignore_paths or []
     excludeopt = config.getoption("ignore")
     if excludeopt:
         ignore_paths.extend([py.path.local(x) for x in excludeopt])
 
-    if path in ignore_paths:
+    if py.path.local(path) in ignore_paths:
+        return True
+
+    allow_in_venv = config.getoption("collect_in_virtualenv")
+    if _in_venv(path) and not allow_in_venv:
         return True
 
     # Skip duplicate paths.
@@ -201,6 +221,7 @@ class FSHookProxy:
         self.__dict__[name] = x
         return x
 
+
 class _CompatProperty(object):
     def __init__(self, name):
         self.name = name
@@ -217,7 +238,6 @@ class _CompatProperty(object):
         return getattr(__import__('pytest'), self.name)
 
 
-
 class NodeKeywords(MappingMixin):
     def __init__(self, node):
         self.node = node
@@ -308,8 +328,8 @@ class Node(object):
         return cls
 
     def __repr__(self):
-        return "<%s %r>" %(self.__class__.__name__,
-                           getattr(self, 'name', None))
+        return "<%s %r>" % (self.__class__.__name__,
+                            getattr(self, 'name', None))
 
     def warn(self, code, message):
         """ generate a warning with the given code and message for this
@@ -355,7 +375,7 @@ class Node(object):
             res = function()
         except py.builtin._sysex:
             raise
-        except:
+        except:  # noqa
             failure = sys.exc_info()
             setattr(self, exattrname, failure)
             raise
@@ -430,7 +450,7 @@ class Node(object):
             return excinfo.value.formatrepr()
         tbfilter = True
         if self.config.option.fulltrace:
-            style="long"
+            style = "long"
         else:
             tb = _pytest._code.Traceback([excinfo.traceback[-1]])
             self._prunetraceback(excinfo)
@@ -458,6 +478,7 @@ class Node(object):
 
     repr_failure = _repr_failure_py
 
+
 class Collector(Node):
     """ Collector instances create children through collect()
         and thus iteratively build a tree.
@@ -487,27 +508,38 @@ class Collector(Node):
                 ntraceback = ntraceback.cut(excludepath=tracebackcutdir)
             excinfo.traceback = ntraceback.filter()
 
+
 class FSCollector(Collector):
     def __init__(self, fspath, parent=None, config=None, session=None):
-        fspath = py.path.local(fspath) # xxx only for test_resultlog.py?
+        fspath = py.path.local(fspath)  # xxx only for test_resultlog.py?
         name = fspath.basename
         if parent is not None:
             rel = fspath.relto(parent.fspath)
             if rel:
                 name = rel
-            name = name.replace(os.sep, "/")
+            name = name.replace(os.sep, nodes.SEP)
         super(FSCollector, self).__init__(name, parent, config, session)
         self.fspath = fspath
 
+    def _check_initialpaths_for_relpath(self):
+        for initialpath in self.session._initialpaths:
+            if self.fspath.common(initialpath) == initialpath:
+                return self.fspath.relto(initialpath.dirname)
+
     def _makeid(self):
         relpath = self.fspath.relto(self.config.rootdir)
-        if os.sep != "/":
-            relpath = relpath.replace(os.sep, "/")
+
+        if not relpath:
+            relpath = self._check_initialpaths_for_relpath()
+        if os.sep != nodes.SEP:
+            relpath = relpath.replace(os.sep, nodes.SEP)
         return relpath
 
+
 class File(FSCollector):
     """ base class for collecting tests from a file. """
 
+
 class Item(Node):
     """ a basic test invocation item. Note that for a single function
     there might be multiple test invocation items.
@@ -519,6 +551,21 @@ class Item(Node):
         self._report_sections = []
 
     def add_report_section(self, when, key, content):
+        """
+        Adds a new report section, similar to what's done internally to add stdout and
+        stderr captured output::
+
+            item.add_report_section("call", "stdout", "report section contents")
+
+        :param str when:
+            One of the possible capture states, ``"setup"``, ``"call"``, ``"teardown"``.
+        :param str key:
+            Name of the section, can be customized at will. Pytest uses ``"stdout"`` and
+            ``"stderr"`` internally.
+
+        :param str content:
+            The full contents as a string.
+        """
         if content:
             self._report_sections.append((when, key, content))
 
@@ -542,12 +589,15 @@ class Item(Node):
             self._location = location
             return location
 
+
 class NoMatch(Exception):
     """ raised if matching cannot locate a matching names. """
 
+
 class Interrupted(KeyboardInterrupt):
     """ signals an interrupted test run. """
-    __module__ = 'builtins' # for py3
+    __module__ = 'builtins'  # for py3
+
 
 class Session(FSCollector):
     Interrupted = Interrupted
@@ -604,7 +654,7 @@ class Session(FSCollector):
             items = self._perform_collect(args, genitems)
             self.config.pluginmanager.check_pending()
             hook.pytest_collection_modifyitems(session=self,
-                config=self.config, items=items)
+                                               config=self.config, items=items)
         finally:
             hook.pytest_collection_finish(session=self)
         self.testscollected = len(items)
@@ -763,7 +813,11 @@ class Session(FSCollector):
                 if not has_matched and len(rep.result) == 1 and x.name == "()":
                     nextnames.insert(0, name)
                     resultnodes.extend(self.matchnodes([x], nextnames))
-            node.ihook.pytest_collectreport(report=rep)
+            else:
+                # report collection failures here to avoid failing to run some test
+                # specified in the command line because the module could not be
+                # imported (#134)
+                node.ihook.pytest_collectreport(report=rep)
         return resultnodes
 
     def genitems(self, node):

_pytest/mark.py

@@ -2,13 +2,21 @@
 from __future__ import absolute_import, division, print_function
 
 import inspect
+import warnings
 from collections import namedtuple
 from operator import attrgetter
 from .compat import imap
+from .deprecated import MARK_PARAMETERSET_UNPACKING
 
 
-def alias(name):
-    return property(attrgetter(name), doc='alias for ' + name)
+def alias(name, warning=None):
+    getter = attrgetter(name)
+
+    def warned(self):
+        warnings.warn(warning, stacklevel=2)
+        return getter(self)
+
+    return property(getter if warning is None else warned, doc='alias for ' + name)
 
 
 class ParameterSet(namedtuple('ParameterSet', 'values, marks, id')):
@@ -54,6 +62,9 @@ class ParameterSet(namedtuple('ParameterSet', 'values, marks, id')):
         if legacy_force_tuple:
             argval = argval,
 
+        if newmarks:
+            warnings.warn(MARK_PARAMETERSET_UNPACKING)
+
         return cls(argval, marks=newmarks, id=None)
 
     @property
@@ -80,7 +91,8 @@ def pytest_addoption(parser):
              "where all names are substring-matched against test names "
              "and their parent classes. Example: -k 'test_method or test_"
              "other' matches all test functions and classes whose name "
-             "contains 'test_method' or 'test_other'. "
+             "contains 'test_method' or 'test_other', while -k 'not test_method' "
+             "matches those that don't contain 'test_method' in their names. "
              "Additionally keywords are matched to classes and functions "
              "containing extra names in their 'extra_keyword_matches' set, "
              "as well as functions which have names assigned directly to them."
@@ -155,6 +167,7 @@ def pytest_collection_modifyitems(items, config):
 class MarkMapping:
     """Provides a local mapping for markers where item access
     resolves to True if the marker is present. """
+
     def __init__(self, keywords):
         mymarks = set()
         for key, value in keywords.items():
@@ -170,6 +183,7 @@ class KeywordMapping:
     """Provides a local mapping for keywords.
     Given a list of names, map any substring of one of these names to True.
     """
+
     def __init__(self, names):
         self._names = names
 
@@ -243,7 +257,6 @@ class MarkGenerator:
     on the ``test_function`` object. """
     _config = None
 
-
     def __getattr__(self, name):
         if name[0] == "_":
             raise AttributeError("Marker name must NOT start with underscore")
@@ -257,11 +270,12 @@ class MarkGenerator:
                 return
         except AttributeError:
             pass
-        self._markers = l = set()
+        self._markers = values = set()
         for line in self._config.getini("markers"):
-            beginning = line.split(":", 1)
-            x = beginning[0].split("(", 1)[0]
-            l.add(x)
+            marker, _ = line.split(":", 1)
+            marker = marker.rstrip()
+            x = marker.split("(", 1)[0]
+            values.add(x)
         if name not in self._markers:
             raise AttributeError("%r not a registered marker" % (name,))
 
@@ -270,6 +284,7 @@ def istestfunc(func):
     return hasattr(func, "__call__") and \
         getattr(func, "__name__", "<lambda>") != "<lambda>"
 
+
 class MarkDecorator:
     """ A decorator for test functions and test classes.  When applied
     it will create :class:`MarkInfo` objects which may be
@@ -303,6 +318,7 @@ class MarkDecorator:
     additional keyword or positional arguments.
 
     """
+
     def __init__(self, mark):
         assert isinstance(mark, Mark), repr(mark)
         self.mark = mark
@@ -313,14 +329,25 @@ class MarkDecorator:
 
     @property
     def markname(self):
-        return self.name # for backward-compat (2.4.1 had this attr)
+        return self.name  # for backward-compat (2.4.1 had this attr)
 
     def __eq__(self, other):
-        return self.mark == other.mark
+        return self.mark == other.mark if isinstance(other, MarkDecorator) else False
 
     def __repr__(self):
         return "<MarkDecorator %r>" % (self.mark,)
 
+    def with_args(self, *args, **kwargs):
+        """ return a MarkDecorator with extra arguments added
+
+        unlike call this can be used even if the sole argument is a callable/class
+
+        :return: MarkDecorator
+        """
+
+        mark = Mark(self.name, args, kwargs)
+        return self.__class__(self.mark.combined_with(mark))
+
     def __call__(self, *args, **kwargs):
         """ if passed a single callable argument: decorate it with mark info.
             otherwise add *args/**kwargs in-place to mark information. """
@@ -329,30 +356,49 @@ class MarkDecorator:
             is_class = inspect.isclass(func)
             if len(args) == 1 and (istestfunc(func) or is_class):
                 if is_class:
-                    if hasattr(func, 'pytestmark'):
-                        mark_list = func.pytestmark
-                        if not isinstance(mark_list, list):
-                            mark_list = [mark_list]
-                        # always work on a copy to avoid updating pytestmark
-                        # from a superclass by accident
-                        mark_list = mark_list + [self]
-                        func.pytestmark = mark_list
-                    else:
-                        func.pytestmark = [self]
+                    store_mark(func, self.mark)
                 else:
-                    holder = getattr(func, self.name, None)
-                    if holder is None:
-                        holder = MarkInfo(self.mark)
-                        setattr(func, self.name, holder)
-                    else:
-                        holder.add_mark(self.mark)
+                    store_legacy_markinfo(func, self.mark)
+                    store_mark(func, self.mark)
                 return func
-
-        mark = Mark(self.name, args, kwargs)
-        return self.__class__(self.mark.combined_with(mark))
+        return self.with_args(*args, **kwargs)
 
 
+def get_unpacked_marks(obj):
+    """
+    obtain the unpacked marks that are stored on a object
+    """
+    mark_list = getattr(obj, 'pytestmark', [])
 
+    if not isinstance(mark_list, list):
+        mark_list = [mark_list]
+    return [
+        getattr(mark, 'mark', mark)  # unpack MarkDecorator
+        for mark in mark_list
+    ]
+
+
+def store_mark(obj, mark):
+    """store a Mark on a object
+    this is used to implement the Mark declarations/decorators correctly
+    """
+    assert isinstance(mark, Mark), mark
+    # always reassign name to avoid updating pytestmark
+    # in a reference that was only borrowed
+    obj.pytestmark = get_unpacked_marks(obj) + [mark]
+
+
+def store_legacy_markinfo(func, mark):
+    """create the legacy MarkInfo objects and put them onto the function
+    """
+    if not isinstance(mark, Mark):
+        raise TypeError("got {mark!r} instead of a Mark".format(mark=mark))
+    holder = getattr(func, mark.name, None)
+    if holder is None:
+        holder = MarkInfo(mark)
+        setattr(func, mark.name, holder)
+    else:
+        holder.add_mark(mark)
 
 
 class Mark(namedtuple('Mark', 'name, args, kwargs')):
@@ -366,6 +412,7 @@ class Mark(namedtuple('Mark', 'name, args, kwargs')):
 
 class MarkInfo(object):
     """ Marking object created by :class:`MarkDecorator` instances. """
+
     def __init__(self, mark):
         assert isinstance(mark, Mark), repr(mark)
         self.combined = mark
@@ -389,3 +436,30 @@ class MarkInfo(object):
 
 
 MARK_GEN = MarkGenerator()
+
+
+def _marked(func, mark):
+    """ Returns True if :func: is already marked with :mark:, False otherwise.
+    This can happen if marker is applied to class and the test file is
+    invoked more than once.
+    """
+    try:
+        func_mark = getattr(func, mark.name)
+    except AttributeError:
+        return False
+    return mark.args == func_mark.args and mark.kwargs == func_mark.kwargs
+
+
+def transfer_markers(funcobj, cls, mod):
+    """
+    this function transfers class level markers and module level markers
+    into function level markinfo objects
+
+    this is the main reason why marks are so broken
+    the resolution will involve phasing out function level MarkInfo objects
+
+    """
+    for obj in (cls, mod):
+        for mark in get_unpacked_marks(obj):
+            if not _marked(funcobj, mark):
+                store_legacy_markinfo(funcobj, mark)

_pytest/monkeypatch.py

@@ -71,9 +71,9 @@ def annotated_getattr(obj, name, ann):
         obj = getattr(obj, name)
     except AttributeError:
         raise AttributeError(
-                '%r object at %s has no attribute %r' % (
-                    type(obj).__name__, ann, name
-                )
+            '%r object at %s has no attribute %r' % (
+                type(obj).__name__, ann, name
+            )
         )
     return obj
 

_pytest/nodes.py

@@ -0,0 +1,37 @@
+SEP = "/"
+
+
+def _splitnode(nodeid):
+    """Split a nodeid into constituent 'parts'.
+
+    Node IDs are strings, and can be things like:
+        ''
+        'testing/code'
+        'testing/code/test_excinfo.py'
+        'testing/code/test_excinfo.py::TestFormattedExcinfo::()'
+
+    Return values are lists e.g.
+        []
+        ['testing', 'code']
+        ['testing', 'code', 'test_excinfo.py']
+        ['testing', 'code', 'test_excinfo.py', 'TestFormattedExcinfo', '()']
+    """
+    if nodeid == '':
+        # If there is no root node at all, return an empty list so the caller's logic can remain sane
+        return []
+    parts = nodeid.split(SEP)
+    # Replace single last element 'test_foo.py::Bar::()' with multiple elements 'test_foo.py', 'Bar', '()'
+    parts[-1:] = parts[-1].split("::")
+    return parts
+
+
+def ischildnode(baseid, nodeid):
+    """Return True if the nodeid is a child node of the baseid.
+
+    E.g. 'foo/bar::Baz::()' is a child of 'foo', 'foo/bar' and 'foo/bar::Baz', but not of 'foo/blorp'
+    """
+    base_parts = _splitnode(baseid)
+    node_parts = _splitnode(nodeid)
+    if len(node_parts) < len(base_parts):
+        return False
+    return node_parts[:len(base_parts)] == base_parts

_pytest/nose.py

@@ -38,14 +38,15 @@ def pytest_runtest_setup(item):
         if not call_optional(item.obj, 'setup'):
             # call module level setup if there is no object level one
             call_optional(item.parent.obj, 'setup')
-        #XXX this implies we only call teardown when setup worked
+        # XXX this implies we only call teardown when setup worked
         item.session._setupstate.addfinalizer((lambda: teardown_nose(item)), item)
 
+
 def teardown_nose(item):
     if is_potential_nosetest(item):
         if not call_optional(item.obj, 'teardown'):
             call_optional(item.parent.obj, 'teardown')
-        #if hasattr(item.parent, '_nosegensetup'):
+        # if hasattr(item.parent, '_nosegensetup'):
         #    #call_optional(item._nosegensetup, 'teardown')
         #    del item.parent._nosegensetup
 

_pytest/outcomes.py

@@ -0,0 +1,140 @@
+"""
+exception classes and constants handling test outcomes
+as well as functions creating them
+"""
+from __future__ import absolute_import, division, print_function
+import py
+import sys
+
+
+class OutcomeException(BaseException):
+    """ OutcomeException and its subclass instances indicate and
+        contain info about test and collection outcomes.
+    """
+    def __init__(self, msg=None, pytrace=True):
+        BaseException.__init__(self, msg)
+        self.msg = msg
+        self.pytrace = pytrace
+
+    def __repr__(self):
+        if self.msg:
+            val = self.msg
+            if isinstance(val, bytes):
+                val = py._builtin._totext(val, errors='replace')
+            return val
+        return "<%s instance>" % (self.__class__.__name__,)
+    __str__ = __repr__
+
+
+TEST_OUTCOME = (OutcomeException, Exception)
+
+
+class Skipped(OutcomeException):
+    # XXX hackish: on 3k we fake to live in the builtins
+    # in order to have Skipped exception printing shorter/nicer
+    __module__ = 'builtins'
+
+    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"):
+        self.msg = msg
+        KeyboardInterrupt.__init__(self, msg)
+
+# exposed helper methods
+
+
+def exit(msg):
+    """ exit testing process as if KeyboardInterrupt was triggered. """
+    __tracebackhide__ = True
+    raise Exit(msg)
+
+
+exit.Exception = Exit
+
+
+def skip(msg=""):
+    """ skip an executing test with the given message.  Note: it's usually
+    better to use the pytest.mark.skipif marker to declare a test to be
+    skipped under certain conditions like mismatching platforms or
+    dependencies.  See the pytest_skipping plugin for details.
+    """
+    __tracebackhide__ = True
+    raise Skipped(msg=msg)
+
+
+skip.Exception = Skipped
+
+
+def fail(msg="", pytrace=True):
+    """ explicitly fail an currently-executing test with the given Message.
+
+    :arg pytrace: if false the msg represents the full failure information
+                  and no python traceback will be reported.
+    """
+    __tracebackhide__ = True
+    raise Failed(msg=msg, pytrace=pytrace)
+
+
+fail.Exception = Failed
+
+
+class XFailed(fail.Exception):
+    """ raised from an explicit call to pytest.xfail() """
+
+
+def xfail(reason=""):
+    """ xfail an executing test or setup functions with the given reason."""
+    __tracebackhide__ = True
+    raise XFailed(reason)
+
+
+xfail.Exception = XFailed
+
+
+def importorskip(modname, minversion=None):
+    """ return imported module if it has at least "minversion" as its
+    __version__ attribute.  If no minversion is specified the a skip
+    is only triggered if the module can not be imported.
+    """
+    import warnings
+    __tracebackhide__ = True
+    compile(modname, '', 'eval')  # to catch syntaxerrors
+    should_skip = False
+
+    with warnings.catch_warnings():
+        # make sure to ignore ImportWarnings that might happen because
+        # of existing directories with the same name we're trying to
+        # import but without a __init__.py file
+        warnings.simplefilter('ignore')
+        try:
+            __import__(modname)
+        except ImportError:
+            # 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
+    verattr = getattr(mod, '__version__', None)
+    if minversion is not None:
+        try:
+            from pkg_resources import parse_version as pv
+        except ImportError:
+            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):
+            raise Skipped("module %r has __version__ %r, required is: %r" % (
+                          modname, verattr, minversion), allow_module_level=True)
+    return mod

_pytest/pastebin.py

@@ -9,9 +9,9 @@ import tempfile
 def pytest_addoption(parser):
     group = parser.getgroup("terminal reporting")
     group._addoption('--pastebin', metavar="mode",
-        action='store', dest="pastebin", default=None,
-        choices=['failed', 'all'],
-        help="send failed|all info to bpaste.net pastebin service.")
+                     action='store', dest="pastebin", default=None,
+                     choices=['failed', 'all'],
+                     help="send failed|all info to bpaste.net pastebin service.")
 
 
 @pytest.hookimpl(trylast=True)
@@ -97,4 +97,4 @@ def pytest_terminal_summary(terminalreporter):
             s = tw.stringio.getvalue()
             assert len(s)
             pastebinurl = create_new_paste(s)
-            tr.write_line("%s --> %s" %(msg, pastebinurl))
+            tr.write_line("%s --> %s" % (msg, pastebinurl))

_pytest/pytester.py

@@ -25,13 +25,13 @@ from _pytest.assertion.rewrite import AssertionRewritingHook
 def pytest_addoption(parser):
     # group = parser.getgroup("pytester", "pytester (self-tests) options")
     parser.addoption('--lsof',
-           action="store_true", dest="lsof", default=False,
-           help=("run FD checks if lsof is available"))
+                     action="store_true", dest="lsof", default=False,
+                     help=("run FD checks if lsof is available"))
 
     parser.addoption('--runpytest', default="inprocess", dest="runpytest",
-           choices=("inprocess", "subprocess", ),
-           help=("run pytest sub runs in tests using an 'inprocess' "
-                 "or 'subprocess' (python -m main) method"))
+                     choices=("inprocess", "subprocess", ),
+                     help=("run pytest sub runs in tests using an 'inprocess' "
+                           "or 'subprocess' (python -m main) method"))
 
 
 def pytest_configure(config):
@@ -62,7 +62,7 @@ class LsofFdLeakChecker(object):
     def _parse_lsof_output(self, out):
         def isopen(line):
             return line.startswith('f') and ("deleted" not in line and
-                'mem' not in line and "txt" not in line and 'cwd' not in line)
+                                             'mem' not in line and "txt" not in line and 'cwd' not in line)
 
         open_files = []
 
@@ -122,6 +122,7 @@ winpymap = {
     'python3.5': r'C:\Python35\python.exe',
 }
 
+
 def getexecutable(name, cache={}):
     try:
         return cache[name]
@@ -130,19 +131,20 @@ def getexecutable(name, cache={}):
         if executable:
             import subprocess
             popen = subprocess.Popen([str(executable), "--version"],
-                universal_newlines=True, stderr=subprocess.PIPE)
+                                     universal_newlines=True, stderr=subprocess.PIPE)
             out, err = popen.communicate()
             if name == "jython":
                 if not err or "2.5" not in err:
                     executable = None
                 if "2.5.2" in err:
-                    executable = None # http://bugs.jython.org/issue1790
+                    executable = None  # http://bugs.jython.org/issue1790
             elif popen.returncode != 0:
                 # Handle pyenv's 127.
                 executable = None
         cache[name] = executable
         return executable
 
+
 @pytest.fixture(params=['python2.6', 'python2.7', 'python3.3', "python3.4",
                         'pypy', 'pypy3'])
 def anypython(request):
@@ -159,6 +161,8 @@ def anypython(request):
     return executable
 
 # used at least by pytest-xdist plugin
+
+
 @pytest.fixture
 def _pytest(request):
     """ Return a helper which offers a gethookrecorder(hook)
@@ -167,6 +171,7 @@ def _pytest(request):
     """
     return PytestArg(request)
 
+
 class PytestArg:
     def __init__(self, request):
         self.request = request
@@ -177,9 +182,9 @@ class PytestArg:
         return hookrecorder
 
 
-def get_public_names(l):
-    """Only return names from iterator l without a leading underscore."""
-    return [x for x in l if x[0] != "_"]
+def get_public_names(values):
+    """Only return names from iterator values without a leading underscore."""
+    return [x for x in values if x[0] != "_"]
 
 
 class ParsedCall:
@@ -190,7 +195,7 @@ class ParsedCall:
     def __repr__(self):
         d = self.__dict__.copy()
         del d['_name']
-        return "<ParsedCall %r(**%r)>" %(self._name, d)
+        return "<ParsedCall %r(**%r)>" % (self._name, d)
 
 
 class HookRecorder:
@@ -253,9 +258,9 @@ class HookRecorder:
         pytest.fail("\n".join(lines))
 
     def getcall(self, name):
-        l = self.getcalls(name)
-        assert len(l) == 1, (name, l)
-        return l[0]
+        values = self.getcalls(name)
+        assert len(values) == 1, (name, values)
+        return values[0]
 
     # functionality for test reports
 
@@ -264,9 +269,9 @@ class HookRecorder:
         return [x.report for x in self.getcalls(names)]
 
     def matchreport(self, inamepart="",
-        names="pytest_runtest_logreport pytest_collectreport", when=None):
+                    names="pytest_runtest_logreport pytest_collectreport", when=None):
         """ return a testreport whose dotted import path matches """
-        l = []
+        values = []
         for rep in self.getreports(names=names):
             try:
                 if not when and rep.when != "call" and rep.passed:
@@ -277,14 +282,14 @@ class HookRecorder:
             if when and getattr(rep, 'when', None) != when:
                 continue
             if not inamepart or inamepart in rep.nodeid.split("::"):
-                l.append(rep)
-        if not l:
+                values.append(rep)
+        if not values:
             raise ValueError("could not find test report matching %r: "
                              "no test reports at all!" % (inamepart,))
-        if len(l) > 1:
+        if len(values) > 1:
             raise ValueError(
-                "found 2 or more testreports matching %r: %s" %(inamepart, l))
-        return l[0]
+                "found 2 or more testreports matching %r: %s" % (inamepart, values))
+        return values[0]
 
     def getfailures(self,
                     names='pytest_runtest_logreport pytest_collectreport'):
@@ -298,7 +303,7 @@ class HookRecorder:
         skipped = []
         failed = []
         for rep in self.getreports(
-            "pytest_collectreport pytest_runtest_logreport"):
+                "pytest_collectreport pytest_runtest_logreport"):
             if rep.passed:
                 if getattr(rep, "when", None) == "call":
                     passed.append(rep)
@@ -337,6 +342,8 @@ def testdir(request, tmpdir_factory):
 
 
 rex_outcome = re.compile(r"(\d+) ([\w-]+)")
+
+
 class RunResult:
     """The result of running a command.
 
@@ -352,6 +359,7 @@ class RunResult:
     :duration: Duration in seconds.
 
     """
+
     def __init__(self, ret, outlines, errlines, duration):
         self.ret = ret
         self.outlines = outlines
@@ -373,14 +381,17 @@ class RunResult:
                     return d
         raise ValueError("Pytest terminal report not found")
 
-    def assert_outcomes(self, passed=0, skipped=0, failed=0):
+    def assert_outcomes(self, passed=0, skipped=0, failed=0, error=0):
         """ assert that the specified outcomes appear with the respective
         numbers (0 means it didn't occur) in the text output from a test run."""
         d = self.parseoutcomes()
-        assert passed == d.get("passed", 0)
-        assert skipped == d.get("skipped", 0)
-        assert failed == d.get("failed", 0)
-
+        obtained = {
+            'passed': d.get('passed', 0),
+            'skipped': d.get('skipped', 0),
+            'failed': d.get('failed', 0),
+            'error': d.get('error', 0),
+        }
+        assert obtained == dict(passed=passed, skipped=skipped, failed=failed, error=error)
 
 
 class Testdir:
@@ -406,7 +417,7 @@ class Testdir:
 
     def __init__(self, request, tmpdir_factory):
         self.request = request
-        self._mod_collections  = WeakKeyDictionary()
+        self._mod_collections = WeakKeyDictionary()
         # XXX remove duplication with tmpdir plugin
         basetmp = tmpdir_factory.ensuretemp("testdir")
         name = request.function.__name__
@@ -420,7 +431,7 @@ class Testdir:
         self.plugins = []
         self._savesyspath = (list(sys.path), list(sys.meta_path))
         self._savemodulekeys = set(sys.modules)
-        self.chdir() # always chdir
+        self.chdir()  # always chdir
         self.request.addfinalizer(self.finalize)
         method = self.request.config.getoption("--runpytest")
         if method == "inprocess":
@@ -495,8 +506,8 @@ class Testdir:
 
             source_unicode = "\n".join([my_totext(line) for line in source.lines])
             source = py.builtin._totext(source_unicode)
-            content = source.strip().encode(encoding) # + "\n"
-            #content = content.rstrip() + "\n"
+            content = source.strip().encode(encoding)  # + "\n"
+            # content = content.rstrip() + "\n"
             p.write(content, "wb")
             if ret is None:
                 ret = p
@@ -581,6 +592,7 @@ class Testdir:
         return p
 
     Session = Session
+
     def getnode(self, config, arg):
         """Return the collection node of a file.
 
@@ -661,8 +673,8 @@ class Testdir:
 
         """
         p = self.makepyfile(source)
-        l = list(cmdlineargs) + [p]
-        return self.inline_run(*l)
+        values = list(cmdlineargs) + [p]
+        return self.inline_run(*values)
 
     def inline_genitems(self, *args):
         """Run ``pytest.main(['--collectonly'])`` in-process.
@@ -763,7 +775,7 @@ class Testdir:
 
         res = RunResult(reprec.ret,
                         out.split("\n"), err.split("\n"),
-                        time.time()-now)
+                        time.time() - now)
         res.reprec = reprec
         return res
 
@@ -779,11 +791,11 @@ class Testdir:
         args = [str(x) for x in args]
         for x in args:
             if str(x).startswith('--basetemp'):
-                #print ("basedtemp exists: %s" %(args,))
+                # print("basedtemp exists: %s" %(args,))
                 break
         else:
             args.append("--basetemp=%s" % self.tmpdir.dirpath('basetemp'))
-            #print ("added basetemp: %s" %(args,))
+            # print("added basetemp: %s" %(args,))
         return args
 
     def parseconfig(self, *args):
@@ -821,7 +833,7 @@ class Testdir:
         self.request.addfinalizer(config._ensure_unconfigure)
         return config
 
-    def getitem(self,  source, funcname="test_func"):
+    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 pytest's
@@ -838,10 +850,10 @@ class Testdir:
         for item in items:
             if item.name == funcname:
                 return item
-        assert 0, "%r item not found in module:\n%s\nitems: %s" %(
+        assert 0, "%r item not found in module:\n%s\nitems: %s" % (
                   funcname, source, items)
 
-    def getitems(self,  source):
+    def getitems(self, source):
         """Return all test items collected from the module.
 
         This writes the source to a python file and runs pytest's
@@ -852,7 +864,7 @@ class Testdir:
         modcol = self.getmodulecol(source)
         return self.genitems([modcol])
 
-    def getmodulecol(self,  source, configargs=(), withinit=False):
+    def getmodulecol(self, source, configargs=(), withinit=False):
         """Return the module collection node for ``source``.
 
         This writes ``source`` to a file using :py:meth:`makepyfile`
@@ -871,7 +883,7 @@ class Testdir:
         kw = {self.request.function.__name__: Source(source).strip()}
         path = self.makepyfile(**kw)
         if withinit:
-            self.makepyfile(__init__ = "#")
+            self.makepyfile(__init__="#")
         self.config = config = self.parseconfigure(path, *configargs)
         node = self.getnode(config, path)
 
@@ -908,8 +920,11 @@ class Testdir:
         env['PYTHONPATH'] = os.pathsep.join(filter(None, [
             str(os.getcwd()), env.get('PYTHONPATH', '')]))
         kw['env'] = env
-        return subprocess.Popen(cmdargs,
-                                stdout=stdout, stderr=stderr, **kw)
+
+        popen = subprocess.Popen(cmdargs, stdin=subprocess.PIPE, stdout=stdout, stderr=stderr, **kw)
+        popen.stdin.close()
+
+        return popen
 
     def run(self, *cmdargs):
         """Run a command with arguments.
@@ -933,7 +948,7 @@ class Testdir:
         try:
             now = time.time()
             popen = self.popen(cmdargs, stdout=f1, stderr=f2,
-                close_fds=(sys.platform != "win32"))
+                               close_fds=(sys.platform != "win32"))
             ret = popen.wait()
         finally:
             f1.close()
@@ -948,7 +963,7 @@ class Testdir:
             f2.close()
         self._dump_lines(out, sys.stdout)
         self._dump_lines(err, sys.stderr)
-        return RunResult(ret, out, err, time.time()-now)
+        return RunResult(ret, out, err, time.time() - now)
 
     def _dump_lines(self, lines, fp):
         try:
@@ -960,7 +975,7 @@ class Testdir:
     def _getpytestargs(self):
         # we cannot use "(sys.executable,script)"
         # because on windows the script is e.g. a pytest.exe
-        return (sys.executable, _pytest_fullpath,) # noqa
+        return (sys.executable, _pytest_fullpath,)  # noqa
 
     def runpython(self, script):
         """Run a python script using sys.executable as interpreter.
@@ -987,12 +1002,12 @@ class Testdir:
 
         """
         p = py.path.local.make_numbered_dir(prefix="runpytest-",
-            keep=None, rootdir=self.tmpdir)
+                                            keep=None, rootdir=self.tmpdir)
         args = ('--basetemp=%s' % p, ) + args
-        #for x in args:
+        # for x in args:
         #    if '--confcutdir' in str(x):
         #        break
-        #else:
+        # else:
         #    pass
         #    args = ('--confcutdir=.',) + args
         plugins = [x for x in self.plugins if isinstance(x, str)]
@@ -1031,12 +1046,13 @@ class Testdir:
         child.timeout = expect_timeout
         return child
 
+
 def getdecoded(out):
-        try:
-            return out.decode("utf-8")
-        except UnicodeDecodeError:
-            return "INTERNAL not-utf8-decodeable, truncated string:\n%s" % (
-                    py.io.saferepr(out),)
+    try:
+        return out.decode("utf-8")
+    except UnicodeDecodeError:
+        return "INTERNAL not-utf8-decodeable, truncated string:\n%s" % (
+            py.io.saferepr(out),)
 
 
 class LineComp:
@@ -1066,7 +1082,7 @@ class LineMatcher:
 
     """
 
-    def __init__(self,  lines):
+    def __init__(self, lines):
         self.lines = lines
         self._log_output = []
 
@@ -1105,7 +1121,7 @@ class LineMatcher:
         """
         for i, line in enumerate(self.lines):
             if fnline == line or fnmatch(line, fnline):
-                return self.lines[i+1:]
+                return self.lines[i + 1:]
         raise ValueError("line %r not found in output" % fnline)
 
     def _log(self, *args):

_pytest/python.py

@@ -6,7 +6,7 @@ import inspect
 import sys
 import os
 import collections
-import math
+from textwrap import dedent
 from itertools import count
 
 import py
@@ -18,12 +18,13 @@ import _pytest._pluggy as pluggy
 from _pytest import fixtures
 from _pytest import main
 from _pytest.compat import (
-    isclass, isfunction, is_generator, _escape_strings,
+    isclass, isfunction, is_generator, _ascii_escaped,
     REGEX_TYPE, STRING_TYPES, NoneType, NOTSET,
     get_real_func, getfslineno, safe_getattr,
     safe_str, getlocation, enum,
 )
-from _pytest.runner import fail
+from _pytest.outcomes import fail
+from _pytest.mark import transfer_markers
 
 cutdir1 = py.path.local(pluggy.__file__.rstrip("oc"))
 cutdir2 = py.path.local(_pytest.__file__).dirpath()
@@ -48,7 +49,6 @@ def filter_traceback(entry):
     return p != cutdir1 and not p.relto(cutdir2) and not p.relto(cutdir3)
 
 
-
 def pyobj_property(name):
     def get(self):
         node = self.getparent(getattr(__import__('pytest'), name))
@@ -62,8 +62,8 @@ def pyobj_property(name):
 def pytest_addoption(parser):
     group = parser.getgroup("general")
     group.addoption('--fixtures', '--funcargs',
-               action="store_true", dest="showfixtures", default=False,
-               help="show available fixtures, sorted by plugin appearance")
+                    action="store_true", dest="showfixtures", default=False,
+                    help="show available fixtures, sorted by plugin appearance")
     group.addoption(
         '--fixtures-per-test',
         action="store_true",
@@ -72,20 +72,20 @@ def pytest_addoption(parser):
         help="show fixtures per test",
     )
     parser.addini("usefixtures", type="args", default=[],
-        help="list of default fixtures to be used with this project")
+                  help="list of default fixtures to be used with this project")
     parser.addini("python_files", type="args",
-        default=['test_*.py', '*_test.py'],
-        help="glob-style file patterns for Python test module discovery")
-    parser.addini("python_classes", type="args", default=["Test",],
-        help="prefixes or glob names for Python test class discovery")
-    parser.addini("python_functions", type="args", default=["test",],
-        help="prefixes or glob names for Python test function and "
-             "method discovery")
+                  default=['test_*.py', '*_test.py'],
+                  help="glob-style file patterns for Python test module discovery")
+    parser.addini("python_classes", type="args", default=["Test", ],
+                  help="prefixes or glob names for Python test class discovery")
+    parser.addini("python_functions", type="args", default=["test", ],
+                  help="prefixes or glob names for Python test function and "
+                  "method discovery")
 
     group.addoption("--import-mode", default="prepend",
-        choices=["prepend", "append"], dest="importmode",
-        help="prepend/append to sys.path when importing test modules, "
-             "default is to prepend.")
+                    choices=["prepend", "append"], dest="importmode",
+                    help="prepend/append to sys.path when importing test modules, "
+                    "default is to prepend.")
 
 
 def pytest_cmdline_main(config):
@@ -112,21 +112,22 @@ def pytest_generate_tests(metafunc):
     for marker in markers:
         metafunc.parametrize(*marker.args, **marker.kwargs)
 
+
 def pytest_configure(config):
     config.addinivalue_line("markers",
-        "parametrize(argnames, argvalues): call a test function multiple "
-        "times passing in different arguments in turn. argvalues generally "
-        "needs to be a list of values if argnames specifies only one name "
-        "or a list of tuples of values if argnames specifies multiple names. "
-        "Example: @parametrize('arg1', [1,2]) would lead to two calls of the "
-        "decorated test function, one with arg1=1 and another with arg1=2."
-        "see http://pytest.org/latest/parametrize.html for more info and "
-        "examples."
-    )
+                            "parametrize(argnames, argvalues): call a test function multiple "
+                            "times passing in different arguments in turn. argvalues generally "
+                            "needs to be a list of values if argnames specifies only one name "
+                            "or a list of tuples of values if argnames specifies multiple names. "
+                            "Example: @parametrize('arg1', [1,2]) would lead to two calls of the "
+                            "decorated test function, one with arg1=1 and another with arg1=2."
+                            "see http://pytest.org/latest/parametrize.html for more info and "
+                            "examples."
+                            )
     config.addinivalue_line("markers",
-        "usefixtures(fixturename1, fixturename2, ...): mark tests as needing "
-        "all of the specified fixtures. see http://pytest.org/latest/fixture.html#usefixtures "
-    )
+                            "usefixtures(fixturename1, fixturename2, ...): mark tests as needing "
+                            "all of the specified fixtures. see http://pytest.org/latest/fixture.html#usefixtures "
+                            )
 
 
 @hookimpl(trylast=True)
@@ -151,13 +152,15 @@ def pytest_collect_file(path, parent):
                 if path.fnmatch(pat):
                     break
             else:
-               return
+                return
         ihook = parent.session.gethookproxy(path)
         return ihook.pytest_pycollect_makemodule(path=path, parent=parent)
 
+
 def pytest_pycollect_makemodule(path, parent):
     return Module(path, parent)
 
+
 @hookimpl(hookwrapper=True)
 def pytest_pycollect_makeitem(collector, name, obj):
     outcome = yield
@@ -176,9 +179,8 @@ def pytest_pycollect_makeitem(collector, name, obj):
         # or a funtools.wrapped.
         # We musn't if it's been wrapped with mock.patch (python 2 only)
         if not (isfunction(obj) or isfunction(get_real_func(obj))):
-            collector.warn(code="C2", message=
-                "cannot collect %r because it is not a function."
-                % name, )
+            collector.warn(code="C2", message="cannot collect %r because it is not a function."
+                           % name, )
         elif getattr(obj, "__test__", True):
             if is_generator(obj):
                 res = Generator(name, parent=collector)
@@ -186,16 +188,17 @@ def pytest_pycollect_makeitem(collector, name, obj):
                 res = list(collector._genfunctions(name, obj))
             outcome.force_result(res)
 
+
 def pytest_make_parametrize_id(config, val, argname=None):
     return None
 
 
-
 class PyobjContext(object):
     module = pyobj_property("Module")
     cls = pyobj_property("Class")
     instance = pyobj_property("Instance")
 
+
 class PyobjMixin(PyobjContext):
     def obj():
         def fget(self):
@@ -253,6 +256,7 @@ class PyobjMixin(PyobjContext):
         assert isinstance(lineno, int)
         return fspath, lineno, modpath
 
+
 class PyCollector(PyobjMixin, main.Collector):
 
     def funcnamefilter(self, name):
@@ -271,10 +275,22 @@ class PyCollector(PyobjMixin, main.Collector):
         return self._matches_prefix_or_glob_option('python_classes', name)
 
     def istestfunction(self, obj, name):
-        return (
-            (self.funcnamefilter(name) or self.isnosetest(obj)) and
-            safe_getattr(obj, "__call__", False) and fixtures.getfixturemarker(obj) is None
-        )
+        if self.funcnamefilter(name) or self.isnosetest(obj):
+            if isinstance(obj, staticmethod):
+                # static methods need to be unwrapped
+                obj = safe_getattr(obj, '__func__', False)
+                if obj is False:
+                    # Python 2.6 wraps in a different way that we won't try to handle
+                    msg = "cannot collect static method %r because " \
+                          "it is not a function (always the case in Python 2.6)"
+                    self.warn(
+                        code="C2", message=msg % name)
+                    return False
+            return (
+                safe_getattr(obj, "__call__", False) and fixtures.getfixturemarker(obj) is None
+            )
+        else:
+            return False
 
     def istestclass(self, obj, name):
         return self.classnamefilter(name) or self.isnosetest(obj)
@@ -305,7 +321,7 @@ class PyCollector(PyobjMixin, main.Collector):
         for basecls in inspect.getmro(self.obj.__class__):
             dicts.append(basecls.__dict__)
         seen = {}
-        l = []
+        values = []
         for dic in dicts:
             for name, obj in list(dic.items()):
                 if name in seen:
@@ -316,12 +332,12 @@ class PyCollector(PyobjMixin, main.Collector):
                     continue
                 if not isinstance(res, list):
                     res = [res]
-                l.extend(res)
-        l.sort(key=lambda item: item.reportinfo()[:2])
-        return l
+                values.extend(res)
+        values.sort(key=lambda item: item.reportinfo()[:2])
+        return values
 
     def makeitem(self, name, obj):
-        #assert self.ihook.fspath == self.fspath, self
+        # assert self.ihook.fspath == self.fspath, self
         return self.ihook.pytest_pycollect_makeitem(
             collector=self, name=name, obj=obj)
 
@@ -357,40 +373,11 @@ class PyCollector(PyobjMixin, main.Collector):
                 yield Function(name=subname, parent=self,
                                callspec=callspec, callobj=funcobj,
                                fixtureinfo=fixtureinfo,
-                               keywords={callspec.id:True},
+                               keywords={callspec.id: True},
                                originalname=name,
                                )
 
 
-def _marked(func, mark):
-    """ Returns True if :func: is already marked with :mark:, False otherwise.
-    This can happen if marker is applied to class and the test file is
-    invoked more than once.
-    """
-    try:
-        func_mark = getattr(func, mark.name)
-    except AttributeError:
-        return False
-    return mark.args == func_mark.args and mark.kwargs == func_mark.kwargs
-
-
-def transfer_markers(funcobj, cls, mod):
-    # XXX this should rather be code in the mark plugin or the mark
-    # plugin should merge with the python plugin.
-    for holder in (cls, mod):
-        try:
-            pytestmark = holder.pytestmark
-        except AttributeError:
-            continue
-        if isinstance(pytestmark, list):
-            for mark in pytestmark:
-                if not _marked(funcobj, mark):
-                    mark(funcobj)
-        else:
-            if not _marked(funcobj, pytestmark):
-                pytestmark(funcobj)
-
-
 class Module(main.File, PyCollector):
     """ Collector for test classes and functions. """
 
@@ -419,7 +406,7 @@ class Module(main.File, PyCollector):
                 "  %s\n"
                 "HINT: remove __pycache__ / .pyc files and/or use a "
                 "unique basename for your test file modules"
-                 % e.args
+                % e.args
             )
         except ImportError:
             from _pytest._code.code import ExceptionInfo
@@ -438,9 +425,10 @@ class Module(main.File, PyCollector):
             if e.allow_module_level:
                 raise
             raise self.CollectError(
-                "Using pytest.skip outside of a test is not allowed. If you are "
-                "trying to decorate a test function, use the @pytest.mark.skip "
-                "or @pytest.mark.skipif decorators instead."
+                "Using pytest.skip outside of a test is not allowed. "
+                "To decorate a test function, use the @pytest.mark.skip "
+                "or @pytest.mark.skipif decorators instead, and to skip a "
+                "module use `pytestmark = pytest.mark.{skip,skipif}."
             )
         self.config.pluginmanager.consider_module(mod)
         return mod
@@ -491,12 +479,13 @@ def _get_xunit_func(obj, name):
 
 class Class(PyCollector):
     """ Collector for test methods. """
+
     def collect(self):
         if not safe_getattr(self.obj, "__test__", True):
             return []
         if hasinit(self.obj):
             self.warn("C1", "cannot collect test class %r because it has a "
-                "__init__ constructor" % self.obj.__name__)
+                      "__init__ constructor" % self.obj.__name__)
             return []
         elif hasnew(self.obj):
             self.warn("C1", "cannot collect test class %r because it has a "
@@ -517,6 +506,7 @@ class Class(PyCollector):
             fin_class = getattr(fin_class, '__func__', fin_class)
             self.addfinalizer(lambda: fin_class(self.obj))
 
+
 class Instance(PyCollector):
     def _getobj(self):
         return self.parent.obj()
@@ -529,6 +519,7 @@ class Instance(PyCollector):
         self.obj = self._getobj()
         return self.obj
 
+
 class FunctionMixin(PyobjMixin):
     """ mixin for the code common to Function and Generator.
     """
@@ -564,7 +555,7 @@ class FunctionMixin(PyobjMixin):
             if ntraceback == traceback:
                 ntraceback = ntraceback.cut(path=path)
                 if ntraceback == traceback:
-                    #ntraceback = ntraceback.cut(excludepath=cutdir2)
+                    # ntraceback = ntraceback.cut(excludepath=cutdir2)
                     ntraceback = ntraceback.filter(filter_traceback)
                     if not ntraceback:
                         ntraceback = traceback
@@ -582,7 +573,7 @@ class FunctionMixin(PyobjMixin):
             if not excinfo.value.pytrace:
                 return py._builtin._totext(excinfo.value)
         return super(FunctionMixin, self)._repr_failure_py(excinfo,
-            style=style)
+                                                           style=style)
 
     def repr_failure(self, excinfo, outerr=None):
         assert outerr is None, "XXX outerr usage is deprecated"
@@ -601,22 +592,22 @@ class Generator(FunctionMixin, PyCollector):
         self.session._setupstate.prepare(self)
         # see FunctionMixin.setup and test_setupstate_is_preserved_134
         self._preservedparent = self.parent.obj
-        l = []
+        values = []
         seen = {}
         for i, x in enumerate(self.obj()):
             name, call, args = self.getcallargs(x)
             if not callable(call):
-                raise TypeError("%r yielded non callable test %r" %(self.obj, call,))
+                raise TypeError("%r yielded non callable test %r" % (self.obj, call,))
             if name is None:
                 name = "[%d]" % i
             else:
                 name = "['%s']" % name
             if name in seen:
-                raise ValueError("%r generated tests with non-unique name %r" %(self, name))
+                raise ValueError("%r generated tests with non-unique name %r" % (self, name))
             seen[name] = True
-            l.append(self.Function(name, self, args=args, callobj=call))
-            self.config.warn('C1', deprecated.YIELD_TESTS, fslocation=self.fspath)
-        return l
+            values.append(self.Function(name, self, args=args, callobj=call))
+        self.warn('C1', deprecated.YIELD_TESTS)
+        return values
 
     def getcallargs(self, obj):
         if not isinstance(obj, (tuple, list)):
@@ -671,7 +662,7 @@ class CallSpec2(object):
 
     def _checkargnotcontained(self, arg):
         if arg in self.params or arg in self.funcargs:
-            raise ValueError("duplicate %r" %(arg,))
+            raise ValueError("duplicate %r" % (arg,))
 
     def getparam(self, name):
         try:
@@ -687,7 +678,7 @@ class CallSpec2(object):
 
     def setmulti(self, valtypes, argnames, valset, id, keywords, scopenum,
                  param_index):
-        for arg,val in zip(argnames, valset):
+        for arg, val in zip(argnames, valset):
             self._checkargnotcontained(arg)
             valtype_for_arg = valtypes[arg]
             getattr(self, valtype_for_arg)[arg] = val
@@ -716,6 +707,7 @@ class Metafunc(fixtures.FuncargnamesCompatAttr):
     test configuration or values specified in the class or module where a
     test function is defined.
     """
+
     def __init__(self, function, fixtureinfo, config, cls=None, module=None):
         #: access to the :class:`_pytest.config.Config` object for the test session
         self.config = config
@@ -737,7 +729,7 @@ class Metafunc(fixtures.FuncargnamesCompatAttr):
         self._arg2fixturedefs = fixtureinfo.name2fixturedefs
 
     def parametrize(self, argnames, argvalues, indirect=False, ids=None,
-        scope=None):
+                    scope=None):
         """ Add new invocations to the underlying test function using the list
         of argvalues for the given argnames.  Parametrization is performed
         during the collection phase.  If you need to setup expensive resources
@@ -792,7 +784,7 @@ class Metafunc(fixtures.FuncargnamesCompatAttr):
         if not parameters:
             fs, lineno = getfslineno(self.function)
             reason = "got empty parameter set %r, function %s at %s:%d" % (
-                    argnames, self.function.__name__, fs, lineno)
+                argnames, self.function.__name__, fs, lineno)
             mark = MARK_GEN.skip(reason=reason)
             parameters.append(ParameterSet(
                 values=(NOTSET,) * len(argnames),
@@ -813,7 +805,7 @@ class Metafunc(fixtures.FuncargnamesCompatAttr):
                     name = 'fixture' if indirect else 'argument'
                 raise ValueError(
                     "%r uses no %s %r" % (
-                            self.function, name, arg))
+                        self.function, name, arg))
 
         if indirect is True:
             valtypes = dict.fromkeys(argnames, "params")
@@ -904,7 +896,7 @@ def _find_parametrized_scope(argnames, arg2fixturedefs, indirect):
     from _pytest.fixtures import scopes
     indirect_as_list = isinstance(indirect, (list, tuple))
     all_arguments_are_fixtures = indirect is True or \
-                                 indirect_as_list and len(indirect) == argnames
+        indirect_as_list and len(indirect) == argnames
     if all_arguments_are_fixtures:
         fixturedefs = arg2fixturedefs or {}
         used_scopes = [fixturedef[0].scope for name, fixturedef in fixturedefs.items()]
@@ -929,7 +921,7 @@ def _idval(val, argname, idx, idfn, config=None):
             msg += '\nUpdate your code as this will raise an error in pytest-4.0.'
             warnings.warn(msg, DeprecationWarning)
         if s:
-            return _escape_strings(s)
+            return _ascii_escaped(s)
 
     if config:
         hook_id = config.hook.pytest_make_parametrize_id(
@@ -938,16 +930,16 @@ def _idval(val, argname, idx, idfn, config=None):
             return hook_id
 
     if isinstance(val, STRING_TYPES):
-        return _escape_strings(val)
+        return _ascii_escaped(val)
     elif isinstance(val, (float, int, bool, NoneType)):
         return str(val)
     elif isinstance(val, REGEX_TYPE):
-        return _escape_strings(val.pattern)
+        return _ascii_escaped(val.pattern)
     elif enum is not None and isinstance(val, enum.Enum):
         return str(val)
     elif isclass(val) and hasattr(val, '__name__'):
         return val.__name__
-    return str(argname)+str(idx)
+    return str(argname) + str(idx)
 
 
 def _idvalset(idx, parameterset, argnames, idfn, ids, config=None):
@@ -958,7 +950,7 @@ def _idvalset(idx, parameterset, argnames, idfn, ids, config=None):
                    for val, argname in zip(parameterset.values, argnames)]
         return "-".join(this_id)
     else:
-        return _escape_strings(ids[idx])
+        return _ascii_escaped(ids[idx])
 
 
 def idmaker(argnames, parametersets, idfn=None, ids=None, config=None):
@@ -987,52 +979,48 @@ def _show_fixtures_per_test(config, session):
     tw = _pytest.config.create_terminal_writer(config)
     verbose = config.getvalue("verbose")
 
-    def get_best_rel(func):
+    def get_best_relpath(func):
         loc = getlocation(func, curdir)
         return curdir.bestrelpath(loc)
 
     def write_fixture(fixture_def):
         argname = fixture_def.argname
-
         if verbose <= 0 and argname.startswith("_"):
             return
         if verbose > 0:
-            bestrel = get_best_rel(fixture_def.func)
+            bestrel = get_best_relpath(fixture_def.func)
             funcargspec = "{0} -- {1}".format(argname, bestrel)
         else:
             funcargspec = argname
         tw.line(funcargspec, green=True)
-
-        INDENT = '    {0}'
         fixture_doc = fixture_def.func.__doc__
-
         if fixture_doc:
-            for line in fixture_doc.strip().split('\n'):
-                tw.line(INDENT.format(line.strip()))
+            write_docstring(tw, fixture_doc)
         else:
-            tw.line(INDENT.format('no docstring available'), red=True)
+            tw.line('    no docstring available', red=True)
 
     def write_item(item):
-        name2fixturedefs = item._fixtureinfo.name2fixturedefs
-
-        if not name2fixturedefs:
-            # The given test item does not use any fixtures
+        try:
+            info = item._fixtureinfo
+        except AttributeError:
+            # doctests items have no _fixtureinfo attribute
+            return
+        if not info.name2fixturedefs:
+            # this test item does not use any fixtures
             return
-        bestrel = get_best_rel(item.function)
-
         tw.line()
         tw.sep('-', 'fixtures used by {0}'.format(item.name))
-        tw.sep('-', '({0})'.format(bestrel))
-        for argname, fixture_defs in sorted(name2fixturedefs.items()):
-            assert fixture_defs is not None
-            if not fixture_defs:
+        tw.sep('-', '({0})'.format(get_best_relpath(item.function)))
+        # dict key not used in loop but needed for sorting
+        for _, fixturedefs in sorted(info.name2fixturedefs.items()):
+            assert fixturedefs is not None
+            if not fixturedefs:
                 continue
-            # The last fixture def item in the list is expected
-            # to be the one used by the test item
-            write_fixture(fixture_defs[-1])
+            # last item is expected to be the one used by the test item
+            write_fixture(fixturedefs[-1])
 
-    for item in session.items:
-        write_item(item)
+    for session_item in session.items:
+        write_item(session_item)
 
 
 def showfixtures(config):
@@ -1072,458 +1060,46 @@ def _showfixtures_main(config, session):
         if currentmodule != module:
             if not module.startswith("_pytest."):
                 tw.line()
-                tw.sep("-", "fixtures defined from %s" %(module,))
+                tw.sep("-", "fixtures defined from %s" % (module,))
                 currentmodule = module
         if verbose <= 0 and argname[0] == "_":
             continue
         if verbose > 0:
-            funcargspec = "%s -- %s" %(argname, bestrel,)
+            funcargspec = "%s -- %s" % (argname, bestrel,)
         else:
             funcargspec = argname
         tw.line(funcargspec, green=True)
         loc = getlocation(fixturedef.func, curdir)
         doc = fixturedef.func.__doc__ or ""
         if doc:
-            for line in doc.strip().split("\n"):
-                tw.line("    " + line.strip())
+            write_docstring(tw, doc)
         else:
-            tw.line("    %s: no docstring available" %(loc,),
-                red=True)
+            tw.line("    %s: no docstring available" % (loc,),
+                    red=True)
 
 
-# builtin pytest.raises helper
-
-def raises(expected_exception, *args, **kwargs):
-    """
-    Assert that a code block/function call raises ``expected_exception``
-    and raise a failure exception otherwise.
-
-    This helper produces a ``ExceptionInfo()`` object (see below).
-
-    If using Python 2.5 or above, you may use this function as a
-    context manager::
-
-        >>> with raises(ZeroDivisionError):
-        ...    1/0
-
-    .. versionchanged:: 2.10
-
-    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
-        Traceback (most recent call last):
-          ...
-        Failed: Expecting ZeroDivisionError
-
-
-    .. note::
-
-       When using ``pytest.raises`` as a context manager, it's worthwhile to
-       note that normal context manager rules apply and that the exception
-       raised *must* be the final line in the scope of the context manager.
-       Lines of code after that, within the scope of the context manager will
-       not be executed. For example::
-
-           >>> value = 15
-           >>> with raises(ValueError) as exc_info:
-           ...     if value > 10:
-           ...         raise ValueError("value must be <= 10")
-           ...     assert exc_info.type == ValueError  # this will not execute
-
-       Instead, the following approach must be taken (note the difference in
-       scope)::
-
-           >>> with raises(ValueError) as exc_info:
-           ...     if value > 10:
-           ...         raise ValueError("value must be <= 10")
-           ...
-           >>> assert exc_info.type == ValueError
-
-    Or you can use the keyword argument ``match`` to assert that the
-    exception matches a text or regex::
-
-        >>> with raises(ValueError, match='must be 0 or None'):
-        ...     raise ValueError("value must be 0 or None")
-
-        >>> with raises(ValueError, match=r'must be \d+$'):
-        ...     raise ValueError("value must be 42")
-
-
-    Or you can specify a callable by passing a to-be-called lambda::
-
-        >>> raises(ZeroDivisionError, lambda: 1/0)
-        <ExceptionInfo ...>
-
-    or you can specify an arbitrary callable with arguments::
-
-        >>> def f(x): return 1/x
-        ...
-        >>> raises(ZeroDivisionError, f, 0)
-        <ExceptionInfo ...>
-        >>> raises(ZeroDivisionError, f, x=0)
-        <ExceptionInfo ...>
-
-    A third possibility is to use a string to be executed::
-
-        >>> raises(ZeroDivisionError, "f(0)")
-        <ExceptionInfo ...>
-
-    .. autoclass:: _pytest._code.ExceptionInfo
-        :members:
-
-    .. note::
-        Similar to caught exception objects in Python, explicitly clearing
-        local references to returned ``ExceptionInfo`` objects can
-        help the Python interpreter speed up its garbage collection.
-
-        Clearing those references breaks a reference cycle
-        (``ExceptionInfo`` --> caught exception --> frame stack raising
-        the exception --> current frame stack --> local variables -->
-        ``ExceptionInfo``) which makes Python keep all objects referenced
-        from that cycle (including all local variables in the current
-        frame) alive until the next cyclic garbage collection run. See the
-        official Python ``try`` statement documentation for more detailed
-        information.
-
-    """
-    __tracebackhide__ = True
-    msg = ("exceptions must be old-style classes or"
-           " derived from BaseException, not %s")
-    if isinstance(expected_exception, tuple):
-        for exc in expected_exception:
-            if not isclass(exc):
-                raise TypeError(msg % type(exc))
-    elif not isclass(expected_exception):
-        raise TypeError(msg % type(expected_exception))
-
-    message = "DID NOT RAISE {0}".format(expected_exception)
-    match_expr = None
-
-    if not args:
-        if "message" in kwargs:
-            message = kwargs.pop("message")
-        if "match" in kwargs:
-            match_expr = kwargs.pop("match")
-            message += " matching '{0}'".format(match_expr)
-        return RaisesContext(expected_exception, message, match_expr)
-    elif isinstance(args[0], str):
-        code, = args
-        assert isinstance(code, str)
-        frame = sys._getframe(1)
-        loc = frame.f_locals.copy()
-        loc.update(kwargs)
-        #print "raises frame scope: %r" % frame.f_locals
-        try:
-            code = _pytest._code.Source(code).compile()
-            py.builtin.exec_(code, frame.f_globals, loc)
-            # XXX didn'T mean f_globals == f_locals something special?
-            #     this is destroyed here ...
-        except expected_exception:
-            return _pytest._code.ExceptionInfo()
+def write_docstring(tw, doc):
+    INDENT = "    "
+    doc = doc.rstrip()
+    if "\n" in doc:
+        firstline, rest = doc.split("\n", 1)
     else:
-        func = args[0]
-        try:
-            func(*args[1:], **kwargs)
-        except expected_exception:
-            return _pytest._code.ExceptionInfo()
-    fail(message)
+        firstline, rest = doc, ""
 
+    if firstline.strip():
+        tw.line(INDENT + firstline.strip())
 
-raises.Exception = fail.Exception
+    if rest:
+        for line in dedent(rest).split("\n"):
+            tw.write(INDENT + line + "\n")
 
 
-class RaisesContext(object):
-    def __init__(self, expected_exception, message, match_expr):
-        self.expected_exception = expected_exception
-        self.message = message
-        self.match_expr = match_expr
-        self.excinfo = None
-
-    def __enter__(self):
-        self.excinfo = object.__new__(_pytest._code.ExceptionInfo)
-        return self.excinfo
-
-    def __exit__(self, *tp):
-        __tracebackhide__ = True
-        if tp[0] is None:
-            fail(self.message)
-        if sys.version_info < (2, 7):
-            # py26: on __exit__() exc_value often does not contain the
-            # exception value.
-            # http://bugs.python.org/issue7853
-            if not isinstance(tp[1], BaseException):
-                exc_type, value, traceback = tp
-                tp = exc_type, exc_type(value), traceback
-        self.excinfo.__init__(tp)
-        suppress_exception = issubclass(self.excinfo.type, self.expected_exception)
-        if sys.version_info[0] == 2 and suppress_exception:
-            sys.exc_clear()
-        if self.match_expr:
-            self.excinfo.match(self.match_expr)
-        return suppress_exception
-
-
-# builtin pytest.approx helper
-
-class approx(object):
-    """
-    Assert that two numbers (or two sets of numbers) are equal to each other
-    within some tolerance.
-
-    Due to the `intricacies of floating-point arithmetic`__, numbers that we
-    would intuitively expect to be equal are not always so::
-
-        >>> 0.1 + 0.2 == 0.3
-        False
-
-    __ https://docs.python.org/3/tutorial/floatingpoint.html
-
-    This problem is commonly encountered when writing tests, e.g. when making
-    sure that floating-point values are what you expect them to be.  One way to
-    deal with this problem is to assert that two floating-point numbers are
-    equal to within some appropriate tolerance::
-
-        >>> abs((0.1 + 0.2) - 0.3) < 1e-6
-        True
-
-    However, comparisons like this are tedious to write and difficult to
-    understand.  Furthermore, absolute comparisons like the one above are
-    usually discouraged because there's no tolerance that works well for all
-    situations.  ``1e-6`` is good for numbers around ``1``, but too small for
-    very big numbers and too big for very small ones.  It's better to express
-    the tolerance as a fraction of the expected value, but relative comparisons
-    like that are even more difficult to write correctly and concisely.
-
-    The ``approx`` class performs floating-point comparisons using a syntax
-    that's as intuitive as possible::
-
-        >>> from pytest import approx
-        >>> 0.1 + 0.2 == approx(0.3)
-        True
-
-    The same syntax also works on sequences of numbers::
-
-        >>> (0.1 + 0.2, 0.2 + 0.4) == approx((0.3, 0.6))
-        True
-
-    By default, ``approx`` considers numbers within a relative tolerance of
-    ``1e-6`` (i.e. one part in a million) of its expected value to be equal.
-    This treatment would lead to surprising results if the expected value was
-    ``0.0``, because nothing but ``0.0`` itself is relatively close to ``0.0``.
-    To handle this case less surprisingly, ``approx`` also considers numbers
-    within an absolute tolerance of ``1e-12`` of its expected value to be
-    equal.  Infinite numbers are another special case.  They are only
-    considered equal to themselves, regardless of the relative tolerance.  Both
-    the relative and absolute tolerances can be changed by passing arguments to
-    the ``approx`` constructor::
-
-        >>> 1.0001 == approx(1)
-        False
-        >>> 1.0001 == approx(1, rel=1e-3)
-        True
-        >>> 1.0001 == approx(1, abs=1e-3)
-        True
-
-    If you specify ``abs`` but not ``rel``, the comparison will not consider
-    the relative tolerance at all.  In other words, two numbers that are within
-    the default relative tolerance of ``1e-6`` will still be considered unequal
-    if they exceed the specified absolute tolerance.  If you specify both
-    ``abs`` and ``rel``, the numbers will be considered equal if either
-    tolerance is met::
-
-        >>> 1 + 1e-8 == approx(1)
-        True
-        >>> 1 + 1e-8 == approx(1, abs=1e-12)
-        False
-        >>> 1 + 1e-8 == approx(1, rel=1e-6, abs=1e-12)
-        True
-
-    If you're thinking about using ``approx``, then you might want to know how
-    it compares to other good ways of comparing floating-point numbers.  All of
-    these algorithms are based on relative and absolute tolerances and should
-    agree for the most part, but they do have meaningful differences:
-
-    - ``math.isclose(a, b, rel_tol=1e-9, abs_tol=0.0)``:  True if the relative
-      tolerance is met w.r.t. either ``a`` or ``b`` or if the absolute
-      tolerance is met.  Because the relative tolerance is calculated w.r.t.
-      both ``a`` and ``b``, this test is symmetric (i.e.  neither ``a`` nor
-      ``b`` is a "reference value").  You have to specify an absolute tolerance
-      if you want to compare to ``0.0`` because there is no tolerance by
-      default.  Only available in python>=3.5.  `More information...`__
-
-      __ https://docs.python.org/3/library/math.html#math.isclose
-
-    - ``numpy.isclose(a, b, rtol=1e-5, atol=1e-8)``: True if the difference
-      between ``a`` and ``b`` is less that the sum of the relative tolerance
-      w.r.t. ``b`` and the absolute tolerance.  Because the relative tolerance
-      is only calculated w.r.t. ``b``, this test is asymmetric and you can
-      think of ``b`` as the reference value.  Support for comparing sequences
-      is provided by ``numpy.allclose``.  `More information...`__
-
-      __ http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.isclose.html
-
-    - ``unittest.TestCase.assertAlmostEqual(a, b)``: True if ``a`` and ``b``
-      are within an absolute tolerance of ``1e-7``.  No relative tolerance is
-      considered and the absolute tolerance cannot be changed, so this function
-      is not appropriate for very large or very small numbers.  Also, it's only
-      available in subclasses of ``unittest.TestCase`` and it's ugly because it
-      doesn't follow PEP8.  `More information...`__
-
-      __ https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertAlmostEqual
-
-    - ``a == pytest.approx(b, rel=1e-6, abs=1e-12)``: True if the relative
-      tolerance is met w.r.t. ``b`` or if the absolute tolerance is met.
-      Because the relative tolerance is only calculated w.r.t. ``b``, this test
-      is asymmetric and you can think of ``b`` as the reference value.  In the
-      special case that you explicitly specify an absolute tolerance but not a
-      relative tolerance, only the absolute tolerance is considered.
-    """
-
-    def __init__(self, expected, rel=None, abs=None):
-        self.expected = expected
-        self.abs = abs
-        self.rel = rel
-
-    def __repr__(self):
-        return ', '.join(repr(x) for x in self.expected)
-
-    def __eq__(self, actual):
-        from collections import Iterable
-        if not isinstance(actual, Iterable):
-            actual = [actual]
-        if len(actual) != len(self.expected):
-            return False
-        return all(a == x for a, x in zip(actual, self.expected))
-
-    __hash__ = None
-
-    def __ne__(self, actual):
-        return not (actual == self)
-
-    @property
-    def expected(self):
-        # Regardless of whether the user-specified expected value is a number
-        # or a sequence of numbers, return a list of ApproxNotIterable objects
-        # that can be compared against.
-        from collections import Iterable
-        approx_non_iter = lambda x: ApproxNonIterable(x, self.rel, self.abs)
-        if isinstance(self._expected, Iterable):
-            return [approx_non_iter(x) for x in self._expected]
-        else:
-            return [approx_non_iter(self._expected)]
-
-    @expected.setter
-    def expected(self, expected):
-        self._expected = expected
-
-
-class ApproxNonIterable(object):
-    """
-    Perform approximate comparisons for single numbers only.
-
-    In other words, the ``expected`` attribute for objects of this class must
-    be some sort of number.  This is in contrast to the ``approx`` class, where
-    the ``expected`` attribute can either be a number of a sequence of numbers.
-    This class is responsible for making comparisons, while ``approx`` is
-    responsible for abstracting the difference between numbers and sequences of
-    numbers.  Although this class can stand on its own, it's only meant to be
-    used within ``approx``.
-    """
-
-    def __init__(self, expected, rel=None, abs=None):
-        self.expected = expected
-        self.abs = abs
-        self.rel = rel
-
-    def __repr__(self):
-        if isinstance(self.expected, complex):
-            return str(self.expected)
-
-        # Infinities aren't compared using tolerances, so don't show a
-        # tolerance.
-        if math.isinf(self.expected):
-            return str(self.expected)
-
-        # If a sensible tolerance can't be calculated, self.tolerance will
-        # raise a ValueError.  In this case, display '???'.
-        try:
-            vetted_tolerance = '{:.1e}'.format(self.tolerance)
-        except ValueError:
-            vetted_tolerance = '???'
-
-        if sys.version_info[0] == 2:
-            return '{0} +- {1}'.format(self.expected, vetted_tolerance)
-        else:
-            return u'{0} \u00b1 {1}'.format(self.expected, vetted_tolerance)
-
-    def __eq__(self, actual):
-        # Short-circuit exact equality.
-        if actual == self.expected:
-            return True
-
-        # Infinity shouldn't be approximately equal to anything but itself, but
-        # if there's a relative tolerance, it will be infinite and infinity
-        # will seem approximately equal to everything.  The equal-to-itself
-        # case would have been short circuited above, so here we can just
-        # return false if the expected value is infinite.  The abs() call is
-        # for compatibility with complex numbers.
-        if math.isinf(abs(self.expected)):
-            return False
-
-        # Return true if the two numbers are within the tolerance.
-        return abs(self.expected - actual) <= self.tolerance
-
-    __hash__ = None
-
-    def __ne__(self, actual):
-        return not (actual == self)
-
-    @property
-    def tolerance(self):
-        set_default = lambda x, default: x if x is not None else default
-
-        # Figure out what the absolute tolerance should be.  ``self.abs`` is
-        # either None or a value specified by the user.
-        absolute_tolerance = set_default(self.abs, 1e-12)
-
-        if absolute_tolerance < 0:
-            raise ValueError("absolute tolerance can't be negative: {}".format(absolute_tolerance))
-        if math.isnan(absolute_tolerance):
-            raise ValueError("absolute tolerance can't be NaN.")
-
-        # If the user specified an absolute tolerance but not a relative one,
-        # just return the absolute tolerance.
-        if self.rel is None:
-            if self.abs is not None:
-                return absolute_tolerance
-
-        # Figure out what the relative tolerance should be.  ``self.rel`` is
-        # either None or a value specified by the user.  This is done after
-        # we've made sure the user didn't ask for an absolute tolerance only,
-        # because we don't want to raise errors about the relative tolerance if
-        # we aren't even going to use it.
-        relative_tolerance = set_default(self.rel, 1e-6) * abs(self.expected)
-
-        if relative_tolerance < 0:
-            raise ValueError("relative tolerance can't be negative: {}".format(absolute_tolerance))
-        if math.isnan(relative_tolerance):
-            raise ValueError("relative tolerance can't be NaN.")
-
-        # Return the larger of the relative and absolute tolerances.
-        return max(relative_tolerance, absolute_tolerance)
-
-
-#
-#  the basic pytest Function item
-#
-
 class Function(FunctionMixin, main.Item, fixtures.FuncargnamesCompatAttr):
     """ a Function Item is responsible for setting up and executing a
     Python test function.
     """
     _genid = None
+
     def __init__(self, name, parent, args=None, config=None,
                  callspec=None, callobj=NOTSET, keywords=None, session=None,
                  fixtureinfo=None, originalname=None):
@@ -1575,7 +1151,7 @@ class Function(FunctionMixin, main.Item, fixtures.FuncargnamesCompatAttr):
 
     def _getobj(self):
         name = self.name
-        i = name.find("[") # parametrization
+        i = name.find("[")  # parametrization
         if i != -1:
             name = name[:i]
         return getattr(self.parent.obj, name)

_pytest/python_api.py

@@ -0,0 +1,626 @@
+import math
+import sys
+
+import py
+
+from _pytest.compat import isclass, izip
+from _pytest.outcomes import fail
+import _pytest._code
+
+
+def _cmp_raises_type_error(self, other):
+    """__cmp__ implementation which raises TypeError. Used
+    by Approx base classes to implement only == and != and raise a
+    TypeError for other comparisons.
+
+    Needed in Python 2 only, Python 3 all it takes is not implementing the
+    other operators at all.
+    """
+    __tracebackhide__ = True
+    raise TypeError('Comparison operators other than == and != not supported by approx objects')
+
+
+# builtin pytest.approx helper
+
+
+class ApproxBase(object):
+    """
+    Provide shared utilities for making approximate comparisons between numbers
+    or sequences of numbers.
+    """
+
+    def __init__(self, expected, rel=None, abs=None, nan_ok=False):
+        self.expected = expected
+        self.abs = abs
+        self.rel = rel
+        self.nan_ok = nan_ok
+
+    def __repr__(self):
+        raise NotImplementedError
+
+    def __eq__(self, actual):
+        return all(
+            a == self._approx_scalar(x)
+            for a, x in self._yield_comparisons(actual))
+
+    __hash__ = None
+
+    def __ne__(self, actual):
+        return not (actual == self)
+
+    if sys.version_info[0] == 2:
+        __cmp__ = _cmp_raises_type_error
+
+    def _approx_scalar(self, x):
+        return ApproxScalar(x, rel=self.rel, abs=self.abs, nan_ok=self.nan_ok)
+
+    def _yield_comparisons(self, actual):
+        """
+        Yield all the pairs of numbers to be compared.  This is used to
+        implement the `__eq__` method.
+        """
+        raise NotImplementedError
+
+
+class ApproxNumpy(ApproxBase):
+    """
+    Perform approximate comparisons for numpy arrays.
+    """
+
+    # Tell numpy to use our `__eq__` operator instead of its.
+    __array_priority__ = 100
+
+    def __repr__(self):
+        # It might be nice to rewrite this function to account for the
+        # shape of the array...
+        return "approx({0!r})".format(list(
+            self._approx_scalar(x) for x in self.expected))
+
+    if sys.version_info[0] == 2:
+        __cmp__ = _cmp_raises_type_error
+
+    def __eq__(self, actual):
+        import numpy as np
+
+        try:
+            actual = np.asarray(actual)
+        except:  # noqa
+            raise TypeError("cannot compare '{0}' to numpy.ndarray".format(actual))
+
+        if actual.shape != self.expected.shape:
+            return False
+
+        return ApproxBase.__eq__(self, actual)
+
+    def _yield_comparisons(self, actual):
+        import numpy as np
+
+        # We can be sure that `actual` is a numpy array, because it's
+        # casted in `__eq__` before being passed to `ApproxBase.__eq__`,
+        # which is the only method that calls this one.
+        for i in np.ndindex(self.expected.shape):
+            yield actual[i], self.expected[i]
+
+
+class ApproxMapping(ApproxBase):
+    """
+    Perform approximate comparisons for mappings where the values are numbers
+    (the keys can be anything).
+    """
+
+    def __repr__(self):
+        return "approx({0!r})".format(dict(
+            (k, self._approx_scalar(v))
+            for k, v in self.expected.items()))
+
+    def __eq__(self, actual):
+        if set(actual.keys()) != set(self.expected.keys()):
+            return False
+
+        return ApproxBase.__eq__(self, actual)
+
+    def _yield_comparisons(self, actual):
+        for k in self.expected.keys():
+            yield actual[k], self.expected[k]
+
+
+class ApproxSequence(ApproxBase):
+    """
+    Perform approximate comparisons for sequences of numbers.
+    """
+
+    # Tell numpy to use our `__eq__` operator instead of its.
+    __array_priority__ = 100
+
+    def __repr__(self):
+        seq_type = type(self.expected)
+        if seq_type not in (tuple, list, set):
+            seq_type = list
+        return "approx({0!r})".format(seq_type(
+            self._approx_scalar(x) for x in self.expected))
+
+    def __eq__(self, actual):
+        if len(actual) != len(self.expected):
+            return False
+        return ApproxBase.__eq__(self, actual)
+
+    def _yield_comparisons(self, actual):
+        return izip(actual, self.expected)
+
+
+class ApproxScalar(ApproxBase):
+    """
+    Perform approximate comparisons for single numbers only.
+    """
+
+    def __repr__(self):
+        """
+        Return a string communicating both the expected value and the tolerance
+        for the comparison being made, e.g. '1.0 +- 1e-6'.  Use the unicode
+        plus/minus symbol if this is python3 (it's too hard to get right for
+        python2).
+        """
+        if isinstance(self.expected, complex):
+            return str(self.expected)
+
+        # Infinities aren't compared using tolerances, so don't show a
+        # tolerance.
+        if math.isinf(self.expected):
+            return str(self.expected)
+
+        # If a sensible tolerance can't be calculated, self.tolerance will
+        # raise a ValueError.  In this case, display '???'.
+        try:
+            vetted_tolerance = '{:.1e}'.format(self.tolerance)
+        except ValueError:
+            vetted_tolerance = '???'
+
+        if sys.version_info[0] == 2:
+            return '{0} +- {1}'.format(self.expected, vetted_tolerance)
+        else:
+            return u'{0} \u00b1 {1}'.format(self.expected, vetted_tolerance)
+
+    def __eq__(self, actual):
+        """
+        Return true if the given value is equal to the expected value within
+        the pre-specified tolerance.
+        """
+
+        # Short-circuit exact equality.
+        if actual == self.expected:
+            return True
+
+        # Allow the user to control whether NaNs are considered equal to each
+        # other or not.  The abs() calls are for compatibility with complex
+        # numbers.
+        if math.isnan(abs(self.expected)):
+            return self.nan_ok and math.isnan(abs(actual))
+
+        # Infinity shouldn't be approximately equal to anything but itself, but
+        # if there's a relative tolerance, it will be infinite and infinity
+        # will seem approximately equal to everything.  The equal-to-itself
+        # case would have been short circuited above, so here we can just
+        # return false if the expected value is infinite.  The abs() call is
+        # for compatibility with complex numbers.
+        if math.isinf(abs(self.expected)):
+            return False
+
+        # Return true if the two numbers are within the tolerance.
+        return abs(self.expected - actual) <= self.tolerance
+
+    __hash__ = None
+
+    @property
+    def tolerance(self):
+        """
+        Return the tolerance for the comparison.  This could be either an
+        absolute tolerance or a relative tolerance, depending on what the user
+        specified or which would be larger.
+        """
+        def set_default(x, default):
+            return x if x is not None else default
+
+        # Figure out what the absolute tolerance should be.  ``self.abs`` is
+        # either None or a value specified by the user.
+        absolute_tolerance = set_default(self.abs, 1e-12)
+
+        if absolute_tolerance < 0:
+            raise ValueError("absolute tolerance can't be negative: {}".format(absolute_tolerance))
+        if math.isnan(absolute_tolerance):
+            raise ValueError("absolute tolerance can't be NaN.")
+
+        # If the user specified an absolute tolerance but not a relative one,
+        # just return the absolute tolerance.
+        if self.rel is None:
+            if self.abs is not None:
+                return absolute_tolerance
+
+        # Figure out what the relative tolerance should be.  ``self.rel`` is
+        # either None or a value specified by the user.  This is done after
+        # we've made sure the user didn't ask for an absolute tolerance only,
+        # because we don't want to raise errors about the relative tolerance if
+        # we aren't even going to use it.
+        relative_tolerance = set_default(self.rel, 1e-6) * abs(self.expected)
+
+        if relative_tolerance < 0:
+            raise ValueError("relative tolerance can't be negative: {}".format(absolute_tolerance))
+        if math.isnan(relative_tolerance):
+            raise ValueError("relative tolerance can't be NaN.")
+
+        # Return the larger of the relative and absolute tolerances.
+        return max(relative_tolerance, absolute_tolerance)
+
+
+def approx(expected, rel=None, abs=None, nan_ok=False):
+    """
+    Assert that two numbers (or two sets of numbers) are equal to each other
+    within some tolerance.
+
+    Due to the `intricacies of floating-point arithmetic`__, numbers that we
+    would intuitively expect to be equal are not always so::
+
+        >>> 0.1 + 0.2 == 0.3
+        False
+
+    __ https://docs.python.org/3/tutorial/floatingpoint.html
+
+    This problem is commonly encountered when writing tests, e.g. when making
+    sure that floating-point values are what you expect them to be.  One way to
+    deal with this problem is to assert that two floating-point numbers are
+    equal to within some appropriate tolerance::
+
+        >>> abs((0.1 + 0.2) - 0.3) < 1e-6
+        True
+
+    However, comparisons like this are tedious to write and difficult to
+    understand.  Furthermore, absolute comparisons like the one above are
+    usually discouraged because there's no tolerance that works well for all
+    situations.  ``1e-6`` is good for numbers around ``1``, but too small for
+    very big numbers and too big for very small ones.  It's better to express
+    the tolerance as a fraction of the expected value, but relative comparisons
+    like that are even more difficult to write correctly and concisely.
+
+    The ``approx`` class performs floating-point comparisons using a syntax
+    that's as intuitive as possible::
+
+        >>> from pytest import approx
+        >>> 0.1 + 0.2 == approx(0.3)
+        True
+
+    The same syntax also works for sequences of numbers::
+
+        >>> (0.1 + 0.2, 0.2 + 0.4) == approx((0.3, 0.6))
+        True
+
+    Dictionary *values*::
+
+        >>> {'a': 0.1 + 0.2, 'b': 0.2 + 0.4} == approx({'a': 0.3, 'b': 0.6})
+        True
+
+    And ``numpy`` arrays::
+
+        >>> import numpy as np                                                          # doctest: +SKIP
+        >>> np.array([0.1, 0.2]) + np.array([0.2, 0.4]) == approx(np.array([0.3, 0.6])) # doctest: +SKIP
+        True
+
+    By default, ``approx`` considers numbers within a relative tolerance of
+    ``1e-6`` (i.e. one part in a million) of its expected value to be equal.
+    This treatment would lead to surprising results if the expected value was
+    ``0.0``, because nothing but ``0.0`` itself is relatively close to ``0.0``.
+    To handle this case less surprisingly, ``approx`` also considers numbers
+    within an absolute tolerance of ``1e-12`` of its expected value to be
+    equal.  Infinity and NaN are special cases.  Infinity is only considered
+    equal to itself, regardless of the relative tolerance.  NaN is not
+    considered equal to anything by default, but you can make it be equal to
+    itself by setting the ``nan_ok`` argument to True.  (This is meant to
+    facilitate comparing arrays that use NaN to mean "no data".)
+
+    Both the relative and absolute tolerances can be changed by passing
+    arguments to the ``approx`` constructor::
+
+        >>> 1.0001 == approx(1)
+        False
+        >>> 1.0001 == approx(1, rel=1e-3)
+        True
+        >>> 1.0001 == approx(1, abs=1e-3)
+        True
+
+    If you specify ``abs`` but not ``rel``, the comparison will not consider
+    the relative tolerance at all.  In other words, two numbers that are within
+    the default relative tolerance of ``1e-6`` will still be considered unequal
+    if they exceed the specified absolute tolerance.  If you specify both
+    ``abs`` and ``rel``, the numbers will be considered equal if either
+    tolerance is met::
+
+        >>> 1 + 1e-8 == approx(1)
+        True
+        >>> 1 + 1e-8 == approx(1, abs=1e-12)
+        False
+        >>> 1 + 1e-8 == approx(1, rel=1e-6, abs=1e-12)
+        True
+
+    If you're thinking about using ``approx``, then you might want to know how
+    it compares to other good ways of comparing floating-point numbers.  All of
+    these algorithms are based on relative and absolute tolerances and should
+    agree for the most part, but they do have meaningful differences:
+
+    - ``math.isclose(a, b, rel_tol=1e-9, abs_tol=0.0)``:  True if the relative
+      tolerance is met w.r.t. either ``a`` or ``b`` or if the absolute
+      tolerance is met.  Because the relative tolerance is calculated w.r.t.
+      both ``a`` and ``b``, this test is symmetric (i.e.  neither ``a`` nor
+      ``b`` is a "reference value").  You have to specify an absolute tolerance
+      if you want to compare to ``0.0`` because there is no tolerance by
+      default.  Only available in python>=3.5.  `More information...`__
+
+      __ https://docs.python.org/3/library/math.html#math.isclose
+
+    - ``numpy.isclose(a, b, rtol=1e-5, atol=1e-8)``: True if the difference
+      between ``a`` and ``b`` is less that the sum of the relative tolerance
+      w.r.t. ``b`` and the absolute tolerance.  Because the relative tolerance
+      is only calculated w.r.t. ``b``, this test is asymmetric and you can
+      think of ``b`` as the reference value.  Support for comparing sequences
+      is provided by ``numpy.allclose``.  `More information...`__
+
+      __ http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.isclose.html
+
+    - ``unittest.TestCase.assertAlmostEqual(a, b)``: True if ``a`` and ``b``
+      are within an absolute tolerance of ``1e-7``.  No relative tolerance is
+      considered and the absolute tolerance cannot be changed, so this function
+      is not appropriate for very large or very small numbers.  Also, it's only
+      available in subclasses of ``unittest.TestCase`` and it's ugly because it
+      doesn't follow PEP8.  `More information...`__
+
+      __ https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertAlmostEqual
+
+    - ``a == pytest.approx(b, rel=1e-6, abs=1e-12)``: True if the relative
+      tolerance is met w.r.t. ``b`` or if the absolute tolerance is met.
+      Because the relative tolerance is only calculated w.r.t. ``b``, this test
+      is asymmetric and you can think of ``b`` as the reference value.  In the
+      special case that you explicitly specify an absolute tolerance but not a
+      relative tolerance, only the absolute tolerance is considered.
+
+    .. warning::
+
+       .. versionchanged:: 3.2
+
+       In order to avoid inconsistent behavior, ``TypeError`` is
+       raised for ``>``, ``>=``, ``<`` and ``<=`` comparisons.
+       The example below illustrates the problem::
+
+           assert approx(0.1) > 0.1 + 1e-10  # calls approx(0.1).__gt__(0.1 + 1e-10)
+           assert 0.1 + 1e-10 > approx(0.1)  # calls approx(0.1).__lt__(0.1 + 1e-10)
+
+       In the second example one expects ``approx(0.1).__le__(0.1 + 1e-10)``
+       to be called. But instead, ``approx(0.1).__lt__(0.1 + 1e-10)`` is used to
+       comparison. This is because the call hierarchy of rich comparisons
+       follows a fixed behavior. `More information...`__
+
+       __ https://docs.python.org/3/reference/datamodel.html#object.__ge__
+    """
+
+    from collections import Mapping, Sequence
+    from _pytest.compat import STRING_TYPES as String
+
+    # Delegate the comparison to a class that knows how to deal with the type
+    # of the expected value (e.g. int, float, list, dict, numpy.array, etc).
+    #
+    # This architecture is really driven by the need to support numpy arrays.
+    # The only way to override `==` for arrays without requiring that approx be
+    # the left operand is to inherit the approx object from `numpy.ndarray`.
+    # But that can't be a general solution, because it requires (1) numpy to be
+    # installed and (2) the expected value to be a numpy array.  So the general
+    # solution is to delegate each type of expected value to a different class.
+    #
+    # This has the advantage that it made it easy to support mapping types
+    # (i.e. dict).  The old code accepted mapping types, but would only compare
+    # their keys, which is probably not what most people would expect.
+
+    if _is_numpy_array(expected):
+        cls = ApproxNumpy
+    elif isinstance(expected, Mapping):
+        cls = ApproxMapping
+    elif isinstance(expected, Sequence) and not isinstance(expected, String):
+        cls = ApproxSequence
+    else:
+        cls = ApproxScalar
+
+    return cls(expected, rel, abs, nan_ok)
+
+
+def _is_numpy_array(obj):
+    """
+    Return true if the given object is a numpy array.  Make a special effort to
+    avoid importing numpy unless it's really necessary.
+    """
+    import inspect
+
+    for cls in inspect.getmro(type(obj)):
+        if cls.__module__ == 'numpy':
+            try:
+                import numpy as np
+                return isinstance(obj, np.ndarray)
+            except ImportError:
+                pass
+
+    return False
+
+
+# builtin pytest.raises helper
+
+def raises(expected_exception, *args, **kwargs):
+    """
+    Assert that a code block/function call raises ``expected_exception``
+    and raise a failure exception otherwise.
+
+    This helper produces a ``ExceptionInfo()`` object (see below).
+
+    If using Python 2.5 or above, you may use this function as a
+    context manager::
+
+        >>> with raises(ZeroDivisionError):
+        ...    1/0
+
+    .. versionchanged:: 2.10
+
+    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
+        Traceback (most recent call last):
+          ...
+        Failed: Expecting ZeroDivisionError
+
+    .. note::
+
+       When using ``pytest.raises`` as a context manager, it's worthwhile to
+       note that normal context manager rules apply and that the exception
+       raised *must* be the final line in the scope of the context manager.
+       Lines of code after that, within the scope of the context manager will
+       not be executed. For example::
+
+           >>> value = 15
+           >>> with raises(ValueError) as exc_info:
+           ...     if value > 10:
+           ...         raise ValueError("value must be <= 10")
+           ...     assert exc_info.type == ValueError  # this will not execute
+
+       Instead, the following approach must be taken (note the difference in
+       scope)::
+
+           >>> with raises(ValueError) as exc_info:
+           ...     if value > 10:
+           ...         raise ValueError("value must be <= 10")
+           ...
+           >>> assert exc_info.type == ValueError
+
+
+    Since version ``3.1`` you can use the keyword argument ``match`` to assert that the
+    exception matches a text or regex::
+
+        >>> with raises(ValueError, match='must be 0 or None'):
+        ...     raise ValueError("value must be 0 or None")
+
+        >>> with raises(ValueError, match=r'must be \d+$'):
+        ...     raise ValueError("value must be 42")
+
+    **Legacy forms**
+
+    The forms below are fully supported but are discouraged for new code because the
+    context manager form is regarded as more readable and less error-prone.
+
+    It is possible to specify a callable by passing a to-be-called lambda::
+
+        >>> raises(ZeroDivisionError, lambda: 1/0)
+        <ExceptionInfo ...>
+
+    or you can specify an arbitrary callable with arguments::
+
+        >>> def f(x): return 1/x
+        ...
+        >>> raises(ZeroDivisionError, f, 0)
+        <ExceptionInfo ...>
+        >>> raises(ZeroDivisionError, f, x=0)
+        <ExceptionInfo ...>
+
+    It is also possible to pass a string to be evaluated at runtime::
+
+        >>> raises(ZeroDivisionError, "f(0)")
+        <ExceptionInfo ...>
+
+    The string will be evaluated using the same ``locals()`` and ``globals()``
+    at the moment of the ``raises`` call.
+
+    .. autoclass:: _pytest._code.ExceptionInfo
+        :members:
+
+    .. note::
+        Similar to caught exception objects in Python, explicitly clearing
+        local references to returned ``ExceptionInfo`` objects can
+        help the Python interpreter speed up its garbage collection.
+
+        Clearing those references breaks a reference cycle
+        (``ExceptionInfo`` --> caught exception --> frame stack raising
+        the exception --> current frame stack --> local variables -->
+        ``ExceptionInfo``) which makes Python keep all objects referenced
+        from that cycle (including all local variables in the current
+        frame) alive until the next cyclic garbage collection run. See the
+        official Python ``try`` statement documentation for more detailed
+        information.
+
+    """
+    __tracebackhide__ = True
+    msg = ("exceptions must be old-style classes or"
+           " derived from BaseException, not %s")
+    if isinstance(expected_exception, tuple):
+        for exc in expected_exception:
+            if not isclass(exc):
+                raise TypeError(msg % type(exc))
+    elif not isclass(expected_exception):
+        raise TypeError(msg % type(expected_exception))
+
+    message = "DID NOT RAISE {0}".format(expected_exception)
+    match_expr = None
+
+    if not args:
+        if "message" in kwargs:
+            message = kwargs.pop("message")
+        if "match" in kwargs:
+            match_expr = kwargs.pop("match")
+            message += " matching '{0}'".format(match_expr)
+        return RaisesContext(expected_exception, message, match_expr)
+    elif isinstance(args[0], str):
+        code, = args
+        assert isinstance(code, str)
+        frame = sys._getframe(1)
+        loc = frame.f_locals.copy()
+        loc.update(kwargs)
+        # print "raises frame scope: %r" % frame.f_locals
+        try:
+            code = _pytest._code.Source(code).compile()
+            py.builtin.exec_(code, frame.f_globals, loc)
+            # XXX didn'T mean f_globals == f_locals something special?
+            #     this is destroyed here ...
+        except expected_exception:
+            return _pytest._code.ExceptionInfo()
+    else:
+        func = args[0]
+        try:
+            func(*args[1:], **kwargs)
+        except expected_exception:
+            return _pytest._code.ExceptionInfo()
+    fail(message)
+
+
+raises.Exception = fail.Exception
+
+
+class RaisesContext(object):
+    def __init__(self, expected_exception, message, match_expr):
+        self.expected_exception = expected_exception
+        self.message = message
+        self.match_expr = match_expr
+        self.excinfo = None
+
+    def __enter__(self):
+        self.excinfo = object.__new__(_pytest._code.ExceptionInfo)
+        return self.excinfo
+
+    def __exit__(self, *tp):
+        __tracebackhide__ = True
+        if tp[0] is None:
+            fail(self.message)
+        if sys.version_info < (2, 7):
+            # py26: on __exit__() exc_value often does not contain the
+            # exception value.
+            # http://bugs.python.org/issue7853
+            if not isinstance(tp[1], BaseException):
+                exc_type, value, traceback = tp
+                tp = exc_type, exc_type(value), traceback
+        self.excinfo.__init__(tp)
+        suppress_exception = issubclass(self.excinfo.type, self.expected_exception)
+        if sys.version_info[0] == 2 and suppress_exception:
+            sys.exc_clear()
+        if self.match_expr:
+            self.excinfo.match(self.match_expr)
+        return suppress_exception

_pytest/recwarn.py

@@ -7,7 +7,9 @@ import _pytest._code
 import py
 import sys
 import warnings
+
 from _pytest.fixtures import yield_fixture
+from _pytest.outcomes import fail
 
 
 @yield_fixture
@@ -27,10 +29,8 @@ def recwarn():
 
 
 def deprecated_call(func=None, *args, **kwargs):
-    """ assert that calling ``func(*args, **kwargs)`` triggers a
-    ``DeprecationWarning`` or ``PendingDeprecationWarning``.
-
-    This function can be used as a context manager::
+    """context manager that can be used to ensure a block of code triggers a
+    ``DeprecationWarning`` or ``PendingDeprecationWarning``::
 
         >>> import warnings
         >>> def api_call_v2():
@@ -40,38 +40,47 @@ def deprecated_call(func=None, *args, **kwargs):
         >>> with deprecated_call():
         ...    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
-    triggered twice for the same module. See #1190.
+    ``deprecated_call`` can also be used by passing a function and ``*args`` and ``*kwargs``,
+    in which case it will ensure calling ``func(*args, **kwargs)`` produces one of the warnings
+    types above.
     """
     if not func:
-        return WarningsChecker(expected_warning=(DeprecationWarning, PendingDeprecationWarning))
-
-    categories = []
-
-    def warn_explicit(message, category, *args, **kwargs):
-        categories.append(category)
-
-    def warn(message, category=None, *args, **kwargs):
-        if isinstance(message, Warning):
-            categories.append(message.__class__)
-        else:
-            categories.append(category)
-
-    old_warn = warnings.warn
-    old_warn_explicit = warnings.warn_explicit
-    warnings.warn_explicit = warn_explicit
-    warnings.warn = warn
-    try:
-        ret = func(*args, **kwargs)
-    finally:
-        warnings.warn_explicit = old_warn_explicit
-        warnings.warn = old_warn
-    deprecation_categories = (DeprecationWarning, PendingDeprecationWarning)
-    if not any(issubclass(c, deprecation_categories) for c in categories):
+        return _DeprecatedCallContext()
+    else:
         __tracebackhide__ = True
-        raise AssertionError("%r did not produce DeprecationWarning" % (func,))
-    return ret
+        with _DeprecatedCallContext():
+            return func(*args, **kwargs)
+
+
+class _DeprecatedCallContext(object):
+    """Implements the logic to capture deprecation warnings as a context manager."""
+
+    def __enter__(self):
+        self._captured_categories = []
+        self._old_warn = warnings.warn
+        self._old_warn_explicit = warnings.warn_explicit
+        warnings.warn_explicit = self._warn_explicit
+        warnings.warn = self._warn
+
+    def _warn_explicit(self, message, category, *args, **kwargs):
+        self._captured_categories.append(category)
+
+    def _warn(self, message, category=None, *args, **kwargs):
+        if isinstance(message, Warning):
+            self._captured_categories.append(message.__class__)
+        else:
+            self._captured_categories.append(category)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        warnings.warn_explicit = self._old_warn_explicit
+        warnings.warn = self._old_warn
+
+        if exc_type is None:
+            deprecation_categories = (DeprecationWarning, PendingDeprecationWarning)
+            if not any(issubclass(c, deprecation_categories) for c in self._captured_categories):
+                __tracebackhide__ = True
+                msg = "Did not produce DeprecationWarning or PendingDeprecationWarning"
+                raise AssertionError(msg)
 
 
 def warns(expected_warning, *args, **kwargs):
@@ -190,8 +199,7 @@ class WarningsChecker(WarningsRecorder):
                 if not any(issubclass(r.category, self.expected_warning)
                            for r in self):
                     __tracebackhide__ = True
-                    from _pytest.runner import fail
                     fail("DID NOT WARN. No warnings of type {0} was emitted. "
                          "The list of emitted warnings is: {1}.".format(
-                            self.expected_warning,
-                            [each.message for each in self]))
+                             self.expected_warning,
+                             [each.message for each in self]))

_pytest/resultlog.py

@@ -6,11 +6,13 @@ from __future__ import absolute_import, division, print_function
 import py
 import os
 
+
 def pytest_addoption(parser):
     group = parser.getgroup("terminal reporting", "resultlog plugin options")
     group.addoption('--resultlog', '--result-log', action="store",
-        metavar="path", default=None,
-        help="DEPRECATED path for machine-readable result log.")
+                    metavar="path", default=None,
+                    help="DEPRECATED path for machine-readable result log.")
+
 
 def pytest_configure(config):
     resultlog = config.option.resultlog
@@ -19,13 +21,14 @@ def pytest_configure(config):
         dirname = os.path.dirname(os.path.abspath(resultlog))
         if not os.path.isdir(dirname):
             os.makedirs(dirname)
-        logfile = open(resultlog, 'w', 1) # line buffered
+        logfile = open(resultlog, 'w', 1)  # line buffered
         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:
@@ -33,6 +36,7 @@ def pytest_unconfigure(config):
         del config._resultlog
         config.pluginmanager.unregister(resultlog)
 
+
 def generic_path(item):
     chain = item.listchain()
     gpath = [chain[0].name]
@@ -56,10 +60,11 @@ def generic_path(item):
         fspath = newfspath
     return ''.join(gpath)
 
+
 class ResultLog(object):
     def __init__(self, config, logfile):
         self.config = config
-        self.logfile = logfile # preferably line buffered
+        self.logfile = logfile  # preferably line buffered
 
     def write_log_entry(self, testpath, lettercode, longrepr):
         print("%s %s" % (lettercode, testpath), file=self.logfile)

_pytest/runner.py

@@ -2,22 +2,25 @@
 from __future__ import absolute_import, division, print_function
 
 import bdb
+import os
 import sys
 from time import time
 
 import py
+from _pytest.compat import _PY2
 from _pytest._code.code import TerminalRepr, ExceptionInfo
-
-
+from _pytest.outcomes import skip, Skipped, TEST_OUTCOME
 
 #
 # pytest plugin hooks
 
+
 def pytest_addoption(parser):
     group = parser.getgroup("terminal reporting", "reporting", after="general")
     group.addoption('--durations',
-         action="store", type=int, default=None, metavar="N",
-         help="show N slowest setup/test durations (N=0 for all)."),
+                    action="store", type=int, default=None, metavar="N",
+                    help="show N slowest setup/test durations (N=0 for all)."),
+
 
 def pytest_terminal_summary(terminalreporter):
     durations = terminalreporter.config.option.durations
@@ -42,16 +45,16 @@ def pytest_terminal_summary(terminalreporter):
     for rep in dlist:
         nodeid = rep.nodeid.replace("::()::", "::")
         tr.write_line("%02.2fs %-8s %s" %
-            (rep.duration, rep.when, nodeid))
+                      (rep.duration, rep.when, nodeid))
+
 
 def pytest_sessionstart(session):
     session._setupstate = SetupState()
+
+
 def pytest_sessionfinish(session):
     session._setupstate.teardown_all()
 
-class NodeInfo:
-    def __init__(self, location):
-        self.location = location
 
 def pytest_runtest_protocol(item, nextitem):
     item.ihook.pytest_runtest_logstart(
@@ -60,6 +63,7 @@ def pytest_runtest_protocol(item, nextitem):
     runtestprotocol(item, nextitem=nextitem)
     return True
 
+
 def runtestprotocol(item, log=True, nextitem=None):
     hasrequest = hasattr(item, "_request")
     if hasrequest and not item._request:
@@ -72,7 +76,7 @@ def runtestprotocol(item, log=True, nextitem=None):
         if not item.config.option.setuponly:
             reports.append(call_and_report(item, "call", log))
     reports.append(call_and_report(item, "teardown", log,
-        nextitem=nextitem))
+                                   nextitem=nextitem))
     # after all teardown hooks have been called
     # want funcargs and request info to go away
     if hasrequest:
@@ -80,6 +84,7 @@ 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()
@@ -90,10 +95,14 @@ def show_test_item(item):
     if used_fixtures:
         tw.write(' (fixtures used: {0})'.format(', '.join(used_fixtures)))
 
+
 def pytest_runtest_setup(item):
+    _update_current_test_var(item, 'setup')
     item.session._setupstate.prepare(item)
 
+
 def pytest_runtest_call(item):
+    _update_current_test_var(item, 'call')
     try:
         item.runtest()
     except Exception:
@@ -106,8 +115,29 @@ def pytest_runtest_call(item):
         del tb  # Get rid of it in this namespace
         raise
 
+
 def pytest_runtest_teardown(item, nextitem):
+    _update_current_test_var(item, 'teardown')
     item.session._setupstate.teardown_exact(item, nextitem)
+    _update_current_test_var(item, None)
+
+
+def _update_current_test_var(item, when):
+    """
+    Update PYTEST_CURRENT_TEST to reflect the current item and stage.
+
+    If ``when`` is None, delete PYTEST_CURRENT_TEST from the environment.
+    """
+    var_name = 'PYTEST_CURRENT_TEST'
+    if when:
+        value = '{0} ({1})'.format(item.nodeid, when)
+        if _PY2:
+            # python 2 doesn't like null bytes on environment variables (see #2644)
+            value = value.replace('\x00', '(null)')
+        os.environ[var_name] = value
+    else:
+        os.environ.pop(var_name)
+
 
 def pytest_report_teststatus(report):
     if report.when in ("setup", "teardown"):
@@ -133,21 +163,25 @@ def call_and_report(item, when, log=True, **kwds):
         hook.pytest_exception_interact(node=item, call=call, report=report)
     return report
 
+
 def check_interactive_exception(call, report):
     return call.excinfo and not (
-                hasattr(report, "wasxfail") or
-                call.excinfo.errisinstance(skip.Exception) or
-                call.excinfo.errisinstance(bdb.BdbQuit))
+        hasattr(report, "wasxfail") or
+        call.excinfo.errisinstance(skip.Exception) or
+        call.excinfo.errisinstance(bdb.BdbQuit))
+
 
 def call_runtest_hook(item, when, **kwds):
     hookname = "pytest_runtest_" + when
     ihook = getattr(item.ihook, hookname)
     return CallInfo(lambda: ihook(item=item, **kwds), when=when)
 
+
 class CallInfo:
     """ Result/Exception info a function invocation. """
     #: None or ExceptionInfo object.
     excinfo = None
+
     def __init__(self, func, when):
         #: context of invocation: one of "setup", "call",
         #: "teardown", "memocollect"
@@ -158,7 +192,7 @@ class CallInfo:
         except KeyboardInterrupt:
             self.stop = time()
             raise
-        except:
+        except:  # noqa
             self.excinfo = ExceptionInfo()
         self.stop = time()
 
@@ -169,6 +203,7 @@ class CallInfo:
             status = "result: %r" % (self.result,)
         return "<CallInfo when=%r %s>" % (self.when, status)
 
+
 def getslaveinfoline(node):
     try:
         return node._slaveinfocache
@@ -179,6 +214,7 @@ def getslaveinfoline(node):
             d['id'], d['sysplatform'], ver, d['executable'])
         return s
 
+
 class BaseReport(object):
 
     def __init__(self, **kw):
@@ -243,10 +279,11 @@ class BaseReport(object):
     def fspath(self):
         return self.nodeid.split("::")[0]
 
+
 def pytest_runtest_makereport(item, call):
     when = call.when
-    duration = call.stop-call.start
-    keywords = dict([(x,1) for x in item.keywords])
+    duration = call.stop - call.start
+    keywords = dict([(x, 1) for x in item.keywords])
     excinfo = call.excinfo
     sections = []
     if not call.excinfo:
@@ -264,19 +301,21 @@ def pytest_runtest_makereport(item, call):
             outcome = "failed"
             if call.when == "call":
                 longrepr = item.repr_failure(excinfo)
-            else: # exception in setup or teardown
+            else:  # exception in setup or teardown
                 longrepr = item._repr_failure_py(excinfo,
-                                            style=item.config.option.tbstyle)
+                                                 style=item.config.option.tbstyle)
     for rwhen, key, content in item._report_sections:
-        sections.append(("Captured %s %s" %(key, rwhen), content))
+        sections.append(("Captured %s %s" % (key, rwhen), content))
     return TestReport(item.nodeid, item.location,
                       keywords, outcome, longrepr, when,
                       sections, duration)
 
+
 class TestReport(BaseReport):
     """ Basic test report object (also used for setup and teardown calls if
     they fail).
     """
+
     def __init__(self, nodeid, location, keywords, outcome,
                  longrepr, when, sections=(), duration=0, **extra):
         #: normalized collection node id
@@ -315,14 +354,17 @@ class TestReport(BaseReport):
         return "<TestReport %r when=%r outcome=%r>" % (
             self.nodeid, self.when, self.outcome)
 
+
 class TeardownErrorReport(BaseReport):
     outcome = "failed"
     when = "teardown"
+
     def __init__(self, longrepr, **extra):
         self.longrepr = longrepr
         self.sections = []
         self.__dict__.update(extra)
 
+
 def pytest_make_collect_report(collector):
     call = CallInfo(
         lambda: list(collector.collect()),
@@ -344,7 +386,7 @@ def pytest_make_collect_report(collector):
                 errorinfo = CollectErrorRepr(errorinfo)
             longrepr = errorinfo
     rep = CollectReport(collector.nodeid, outcome, longrepr,
-        getattr(call, 'result', None))
+                        getattr(call, 'result', None))
     rep.call = call  # see collect_one_node
     return rep
 
@@ -365,16 +407,20 @@ class CollectReport(BaseReport):
 
     def __repr__(self):
         return "<CollectReport %r lenresult=%s outcome=%r>" % (
-                self.nodeid, len(self.result), self.outcome)
+            self.nodeid, len(self.result), self.outcome)
+
 
 class CollectErrorRepr(TerminalRepr):
     def __init__(self, msg):
         self.longrepr = msg
+
     def toterminal(self, out):
         out.line(self.longrepr, red=True)
 
+
 class SetupState(object):
     """ shared state for setting up/tearing down test items or collectors. """
+
     def __init__(self):
         self.stack = []
         self._finalizers = {}
@@ -386,7 +432,7 @@ class SetupState(object):
         """
         assert colitem and not isinstance(colitem, tuple)
         assert py.builtin.callable(finalizer)
-        #assert colitem in self.stack  # some unit tests don't setup stack :/
+        # assert colitem in self.stack  # some unit tests don't setup stack :/
         self._finalizers.setdefault(colitem, []).append(finalizer)
 
     def _pop_and_teardown(self):
@@ -400,7 +446,7 @@ class SetupState(object):
             fin = finalizers.pop()
             try:
                 fin()
-            except Exception:
+            except TEST_OUTCOME:
                 # XXX Only first exception will be seen by user,
                 #     ideally all should be reported.
                 if exc is None:
@@ -414,7 +460,7 @@ class SetupState(object):
             colitem.teardown()
         for colitem in self._finalizers:
             assert colitem is None or colitem in self.stack \
-             or isinstance(colitem, tuple)
+                or isinstance(colitem, tuple)
 
     def teardown_all(self):
         while self.stack:
@@ -447,10 +493,11 @@ class SetupState(object):
             self.stack.append(col)
             try:
                 col.setup()
-            except Exception:
+            except TEST_OUTCOME:
                 col._prepare_exc = sys.exc_info()
                 raise
 
+
 def collect_one_node(collector):
     ihook = collector.ihook
     ihook.pytest_collectstart(collector=collector)
@@ -459,122 +506,3 @@ def collect_one_node(collector):
     if call and check_interactive_exception(call, rep):
         ihook.pytest_exception_interact(node=collector, call=call, report=rep)
     return rep
-
-
-# =============================================================
-# Test OutcomeExceptions and helpers for creating them.
-
-
-class OutcomeException(Exception):
-    """ OutcomeException and its subclass instances indicate and
-        contain info about test and collection outcomes.
-    """
-    def __init__(self, msg=None, pytrace=True):
-        Exception.__init__(self, msg)
-        self.msg = msg
-        self.pytrace = pytrace
-
-    def __repr__(self):
-        if self.msg:
-            val = self.msg
-            if isinstance(val, bytes):
-                val = py._builtin._totext(val, errors='replace')
-            return val
-        return "<%s instance>" %(self.__class__.__name__,)
-    __str__ = __repr__
-
-class Skipped(OutcomeException):
-    # XXX hackish: on 3k we fake to live in the builtins
-    # in order to have Skipped exception printing shorter/nicer
-    __module__ = 'builtins'
-
-    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"):
-        self.msg = msg
-        KeyboardInterrupt.__init__(self, msg)
-
-# exposed helper methods
-
-def exit(msg):
-    """ exit testing process as if KeyboardInterrupt was triggered. """
-    __tracebackhide__ = True
-    raise Exit(msg)
-
-
-exit.Exception = Exit
-
-
-def skip(msg=""):
-    """ skip an executing test with the given message.  Note: it's usually
-    better to use the pytest.mark.skipif marker to declare a test to be
-    skipped under certain conditions like mismatching platforms or
-    dependencies.  See the pytest_skipping plugin for details.
-    """
-    __tracebackhide__ = True
-    raise Skipped(msg=msg)
-
-
-skip.Exception = Skipped
-
-
-def fail(msg="", pytrace=True):
-    """ explicitly fail an currently-executing test with the given Message.
-
-    :arg pytrace: if false the msg represents the full failure information
-                  and no python traceback will be reported.
-    """
-    __tracebackhide__ = True
-    raise Failed(msg=msg, pytrace=pytrace)
-
-
-fail.Exception = Failed
-
-
-def importorskip(modname, minversion=None):
-    """ return imported module if it has at least "minversion" as its
-    __version__ attribute.  If no minversion is specified the a skip
-    is only triggered if the module can not be imported.
-    """
-    import warnings
-    __tracebackhide__ = True
-    compile(modname, '', 'eval') # to catch syntaxerrors
-    should_skip = False
-
-    with warnings.catch_warnings():
-        # make sure to ignore ImportWarnings that might happen because
-        # of existing directories with the same name we're trying to
-        # import but without a __init__.py file
-        warnings.simplefilter('ignore')
-        try:
-            __import__(modname)
-        except ImportError:
-            # 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
-    verattr = getattr(mod, '__version__', None)
-    if minversion is not None:
-        try:
-            from pkg_resources import parse_version as pv
-        except ImportError:
-            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):
-            raise Skipped("module %r has __version__ %r, required is: %r" %(
-                          modname, verattr, minversion), allow_module_level=True)
-    return mod

_pytest/skipping.py

@@ -8,13 +8,14 @@ import traceback
 import py
 from _pytest.config import hookimpl
 from _pytest.mark import MarkInfo, MarkDecorator
-from _pytest.runner import fail, skip
+from _pytest.outcomes import fail, skip, xfail, TEST_OUTCOME
+
 
 def pytest_addoption(parser):
     group = parser.getgroup("general")
     group.addoption('--runxfail',
-           action="store_true", dest="runxfail", default=False,
-           help="run tests even if they are marked xfail")
+                    action="store_true", dest="runxfail", default=False,
+                    help="run tests even if they are marked xfail")
 
     parser.addini("xfail_strict", "default for the strict parameter of xfail "
                                   "markers when not given explicitly (default: "
@@ -33,43 +34,30 @@ def pytest_configure(config):
         def nop(*args, **kwargs):
             pass
 
-        nop.Exception = XFailed
+        nop.Exception = xfail.Exception
         setattr(pytest, "xfail", nop)
 
     config.addinivalue_line("markers",
-        "skip(reason=None): skip the given test function with an optional reason. "
-        "Example: skip(reason=\"no way of currently testing this\") skips the "
-        "test."
-    )
+                            "skip(reason=None): skip the given test function with an optional reason. "
+                            "Example: skip(reason=\"no way of currently testing this\") skips the "
+                            "test."
+                            )
     config.addinivalue_line("markers",
-        "skipif(condition): skip the given test function if eval(condition) "
-        "results in a True value.  Evaluation happens within the "
-        "module global context. Example: skipif('sys.platform == \"win32\"') "
-        "skips the test if we are on the win32 platform. see "
-        "http://pytest.org/latest/skipping.html"
-    )
+                            "skipif(condition): skip the given test function if eval(condition) "
+                            "results in a True value.  Evaluation happens within the "
+                            "module global context. Example: skipif('sys.platform == \"win32\"') "
+                            "skips the test if we are on the win32 platform. see "
+                            "http://pytest.org/latest/skipping.html"
+                            )
     config.addinivalue_line("markers",
-        "xfail(condition, reason=None, run=True, raises=None, strict=False): "
-        "mark the test function as an expected failure if eval(condition) "
-        "has a True value. Optionally specify a reason for better reporting "
-        "and run=False if you don't even want to execute the test function. "
-        "If only specific exception(s) are expected, you can list them in "
-        "raises, and if the test fails in other ways, it will be reported as "
-        "a true failure. See http://pytest.org/latest/skipping.html"
-    )
-
-
-class XFailed(fail.Exception):
-    """ raised from an explicit call to pytest.xfail() """
-
-
-def xfail(reason=""):
-    """ xfail an executing test or setup functions with the given reason."""
-    __tracebackhide__ = True
-    raise XFailed(reason)
-
-
-xfail.Exception = XFailed
+                            "xfail(condition, reason=None, run=True, raises=None, strict=False): "
+                            "mark the test function as an expected failure if eval(condition) "
+                            "has a True value. Optionally specify a reason for better reporting "
+                            "and run=False if you don't even want to execute the test function. "
+                            "If only specific exception(s) are expected, you can list them in "
+                            "raises, and if the test fails in other ways, it will be reported as "
+                            "a true failure. See http://pytest.org/latest/skipping.html"
+                            )
 
 
 class MarkEvaluator:
@@ -97,7 +85,7 @@ class MarkEvaluator:
     def istrue(self):
         try:
             return self._istrue()
-        except Exception:
+        except TEST_OUTCOME:
             self.exc = sys.exc_info()
             if isinstance(self.exc[1], SyntaxError):
                 msg = [" " * (self.exc[1].offset + 4) + "^", ]
@@ -243,7 +231,7 @@ def pytest_runtest_makereport(item, call):
         rep.wasxfail = "reason: " + call.excinfo.value.msg
         rep.outcome = "skipped"
     elif evalxfail and not rep.skipped and evalxfail.wasvalid() and \
-        evalxfail.istrue():
+            evalxfail.istrue():
         if call.excinfo:
             if evalxfail.invalidraise(call.excinfo.value):
                 rep.outcome = "failed"
@@ -269,6 +257,8 @@ def pytest_runtest_makereport(item, call):
         rep.longrepr = filename, line, reason
 
 # called by terminalreporter progress reporting
+
+
 def pytest_report_teststatus(report):
     if hasattr(report, "wasxfail"):
         if report.skipped:
@@ -277,10 +267,12 @@ def pytest_report_teststatus(report):
             return "xpassed", "X", ("XPASS", {'yellow': True})
 
 # called by the terminalreporter instance/plugin
+
+
 def pytest_terminal_summary(terminalreporter):
     tr = terminalreporter
     if not tr.reportchars:
-        #for name in "xfailed skipped failed xpassed":
+        # for name in "xfailed skipped failed xpassed":
         #    if not tr.stats.get(name, 0):
         #        tr.write_line("HINT: use '-r' option to see extra "
         #              "summary info about tests")
@@ -354,27 +346,27 @@ def folded_skips(skipped):
         key = event.longrepr
         assert len(key) == 3, (event, key)
         d.setdefault(key, []).append(event)
-    l = []
+    values = []
     for key, events in d.items():
-        l.append((len(events),) + key)
-    return l
+        values.append((len(events),) + key)
+    return values
 
 
 def show_skipped(terminalreporter, lines):
     tr = terminalreporter
     skipped = tr.stats.get('skipped', [])
     if skipped:
-        #if not tr.hasopt('skipped'):
+        # if not tr.hasopt('skipped'):
         #    tr.write_line(
         #        "%d skipped tests, specify -rs for more info" %
         #        len(skipped))
         #    return
         fskips = folded_skips(skipped)
         if fskips:
-            #tr.write_sep("_", "skipped test summary")
+            # tr.write_sep("_", "skipped test summary")
             for num, fspath, lineno, reason in fskips:
                 if reason.startswith("Skipped: "):
                     reason = reason[9:]
                 lines.append(
                     "SKIP [%d] %s:%d: %s" %
-                    (num, fspath, lineno, reason))
+                    (num, fspath, lineno + 1, reason))

_pytest/terminal.py

@@ -13,39 +13,41 @@ import sys
 import time
 import platform
 
+from _pytest import nodes
 import _pytest._pluggy as pluggy
 
 
 def pytest_addoption(parser):
     group = parser.getgroup("terminal reporting", "reporting", after="general")
     group._addoption('-v', '--verbose', action="count",
-               dest="verbose", default=0, help="increase verbosity."),
+                     dest="verbose", default=0, help="increase verbosity."),
     group._addoption('-q', '--quiet', action="count",
-               dest="quiet", default=0, help="decrease verbosity."),
+                     dest="quiet", default=0, help="decrease verbosity."),
     group._addoption('-r',
-         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, "
-              "(p)passed, (P)passed with output, (a)all except pP. "
-              "Warnings are displayed at all times except when "
-              "--disable-warnings is set")
+                     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, "
+                     "(p)passed, (P)passed with output, (a)all except pP. "
+                     "Warnings are displayed at all times except when "
+                     "--disable-warnings is set")
     group._addoption('--disable-warnings', '--disable-pytest-warnings', default=False,
                      dest='disable_warnings', action='store_true',
                      help='disable warnings summary')
     group._addoption('-l', '--showlocals',
-         action="store_true", dest="showlocals", default=False,
-         help="show locals in tracebacks (disabled by default).")
+                     action="store_true", dest="showlocals", default=False,
+                     help="show locals in tracebacks (disabled by default).")
     group._addoption('--tb', metavar="style",
-               action="store", dest="tbstyle", default='auto',
-               choices=['auto', 'long', 'short', 'no', 'line', 'native'],
-               help="traceback print mode (auto/long/short/line/native/no).")
+                     action="store", dest="tbstyle", default='auto',
+                     choices=['auto', 'long', 'short', 'no', 'line', 'native'],
+                     help="traceback print mode (auto/long/short/line/native/no).")
     group._addoption('--fulltrace', '--full-trace',
-               action="store_true", default=False,
-               help="don't cut any tracebacks (default is to cut).")
+                     action="store_true", default=False,
+                     help="don't cut any tracebacks (default is to cut).")
     group._addoption('--color', metavar="color",
-               action="store", dest="color", default='auto',
-               choices=['yes', 'no', 'auto'],
-               help="color terminal output (yes/no/auto).")
+                     action="store", dest="color", default='auto',
+                     choices=['yes', 'no', 'auto'],
+                     help="color terminal output (yes/no/auto).")
+
 
 def pytest_configure(config):
     config.option.verbose -= config.option.quiet
@@ -57,6 +59,7 @@ def pytest_configure(config):
             reporter.write_line("[traceconfig] " + msg)
         config.trace.root.setprocessor("pytest:config", mywriter)
 
+
 def getreportopt(config):
     reportopts = ""
     reportchars = config.option.reportchars
@@ -72,6 +75,7 @@ def getreportopt(config):
                 reportopts = 'fEsxXw'
     return reportopts
 
+
 def pytest_report_teststatus(report):
     if report.passed:
         letter = "."
@@ -88,6 +92,7 @@ class WarningReport:
     """
     Simple structure to hold warnings information captured by ``pytest_logwarning``.
     """
+
     def __init__(self, code, message, nodeid=None, fslocation=None):
         """
         :param code: unused
@@ -176,8 +181,22 @@ class TerminalReporter:
         self._tw.line(line, **markup)
 
     def rewrite(self, line, **markup):
+        """
+        Rewinds the terminal cursor to the beginning and writes the given line.
+
+        :kwarg erase: if True, will also add spaces until the full terminal width to ensure
+            previous lines are properly erased.
+
+        The rest of the keyword arguments are markup instructions.
+        """
+        erase = markup.pop('erase', False)
+        if erase:
+            fill_count = self._tw.fullwidth - len(line)
+            fill = ' ' * fill_count
+        else:
+            fill = ''
         line = str(line)
-        self._tw.write("\r" + line, **markup)
+        self._tw.write("\r" + line + fill, **markup)
 
     def write_sep(self, sep, title=None, **markup):
         self.ensure_newline()
@@ -240,15 +259,15 @@ class TerminalReporter:
                 word, markup = word
             else:
                 if rep.passed:
-                    markup = {'green':True}
+                    markup = {'green': True}
                 elif rep.failed:
-                    markup = {'red':True}
+                    markup = {'red': True}
                 elif rep.skipped:
-                    markup = {'yellow':True}
+                    markup = {'yellow': True}
             line = self._locationline(rep.nodeid, *rep.location)
             if not hasattr(rep, 'node'):
                 self.write_ensure_prefix(line, word, **markup)
-                #self._tw.write(word, **markup)
+                # self._tw.write(word, **markup)
             else:
                 self.ensure_newline()
                 if hasattr(rep, 'node'):
@@ -269,7 +288,7 @@ class TerminalReporter:
         items = [x for x in report.result if isinstance(x, pytest.Item)]
         self._numcollected += len(items)
         if self.isatty:
-            #self.write_fspath_result(report.nodeid, 'E')
+            # self.write_fspath_result(report.nodeid, 'E')
             self.report_collect()
 
     def report_collect(self, final=False):
@@ -282,15 +301,15 @@ class TerminalReporter:
             line = "collected "
         else:
             line = "collecting "
-        line += str(self._numcollected) + " items"
+        line += str(self._numcollected) + " item" + ('' if self._numcollected == 1 else 's')
         if errors:
             line += " / %d errors" % errors
         if skipped:
             line += " / %d skipped" % skipped
         if self.isatty:
+            self.rewrite(line, bold=True, erase=True)
             if final:
-                line += " \n"
-            self.rewrite(line, bold=True)
+                self.write('\n')
         else:
             self.write_line(line)
 
@@ -316,6 +335,9 @@ class TerminalReporter:
         self.write_line(msg)
         lines = self.config.hook.pytest_report_header(
             config=self.config, startdir=self.startdir)
+        self._write_report_lines_from_hooks(lines)
+
+    def _write_report_lines_from_hooks(self, lines):
         lines.reverse()
         for line in flatten(lines):
             self.write_line(line)
@@ -342,10 +364,9 @@ class TerminalReporter:
                     rep.toterminal(self._tw)
                 return 1
             return 0
-        if not self.showheader:
-            return
-        #for i, testarg in enumerate(self.config.args):
-        #    self.write_line("test path %d: %s" %(i+1, testarg))
+        lines = self.config.hook.pytest_report_collectionfinish(
+            config=self.config, startdir=self.startdir, items=session.items)
+        self._write_report_lines_from_hooks(lines)
 
     def _printcollecteditems(self, items):
         # to print out items and their parent collectors
@@ -368,14 +389,14 @@ class TerminalReporter:
         stack = []
         indent = ""
         for item in items:
-            needed_collectors = item.listchain()[1:] # strip root node
+            needed_collectors = item.listchain()[1:]  # strip root node
             while stack:
                 if stack == needed_collectors[:len(stack)]:
                     break
                 stack.pop()
             for col in needed_collectors[len(stack):]:
                 stack.append(col)
-                #if col.name == "()":
+                # if col.name == "()":
                 #    continue
                 indent = (len(stack) - 1) * "  "
                 self._tw.line("%s%s" % (indent, col))
@@ -424,15 +445,15 @@ class TerminalReporter:
             line = self.config.cwd_relative_nodeid(nodeid)
             if domain and line.endswith(domain):
                 line = line[:-len(domain)]
-                l = domain.split("[")
-                l[0] = l[0].replace('.', '::')  # don't replace '.' in params
-                line += "[".join(l)
+                values = domain.split("[")
+                values[0] = values[0].replace('.', '::')  # don't replace '.' in params
+                line += "[".join(values)
             return line
         # collect_fspath comes from testid which has a "/"-normalized path
 
         if fspath:
             res = mkrel(nodeid).replace("::()", "")  # parens-normalization
-            if nodeid.split("::")[0] != fspath.replace("\\", "/"):
+            if nodeid.split("::")[0] != fspath.replace("\\", nodes.SEP):
                 res += " <- " + self.startdir.bestrelpath(fspath)
         else:
             res = "[location]"
@@ -443,7 +464,7 @@ class TerminalReporter:
             fspath, lineno, domain = rep.location
             return domain
         else:
-            return "test session" # XXX?
+            return "test session"  # XXX?
 
     def _getcrashline(self, rep):
         try:
@@ -458,11 +479,11 @@ class TerminalReporter:
     # summaries for sessionfinish
     #
     def getreports(self, name):
-        l = []
+        values = []
         for x in self.stats.get(name, []):
             if not hasattr(x, '_pdbshown'):
-                l.append(x)
-        return l
+                values.append(x)
+        return values
 
     def summary_warnings(self):
         if self.hasopt("w"):
@@ -502,7 +523,6 @@ class TerminalReporter:
                     content = content[:-1]
                 self._tw.line(content)
 
-
     def summary_failures(self):
         if self.config.option.tbstyle != "no":
             reports = self.getreports('failed')
@@ -564,6 +584,7 @@ class TerminalReporter:
             self.write_sep("=", "%d tests deselected" % (
                 len(self.stats['deselected'])), bold=True)
 
+
 def repr_pythonversion(v=None):
     if v is None:
         v = sys.version_info
@@ -572,21 +593,23 @@ def repr_pythonversion(v=None):
     except (TypeError, ValueError):
         return str(v)
 
-def flatten(l):
-    for x in l:
+
+def flatten(values):
+    for x in values:
         if isinstance(x, (list, tuple)):
             for y in flatten(x):
                 yield y
         else:
             yield x
 
+
 def build_summary_stats_line(stats):
     keys = ("failed passed skipped deselected "
             "xfailed xpassed warnings error").split()
     unknown_key_seen = False
     for key in stats.keys():
         if key not in keys:
-            if key: # setup/teardown reports have an empty key, ignore them
+            if key:  # setup/teardown reports have an empty key, ignore them
                 keys.append(key)
                 unknown_key_seen = True
     parts = []
@@ -613,7 +636,7 @@ def build_summary_stats_line(stats):
 
 
 def _plugin_nameversions(plugininfo):
-    l = []
+    values = []
     for plugin, dist in plugininfo:
         # gets us name and version!
         name = '{dist.project_name}-{dist.version}'.format(dist=dist)
@@ -622,6 +645,6 @@ def _plugin_nameversions(plugininfo):
             name = name[7:]
         # we decided to print python package names
         # they can have more than one plugin
-        if name not in l:
-            l.append(name)
-    return l
+        if name not in values:
+            values.append(name)
+    return values

_pytest/tmpdir.py

@@ -25,7 +25,7 @@ class TempdirFactory:
             provides an empty unique-per-test-invocation directory
             and is guaranteed to be empty.
         """
-        #py.log._apiwarn(">1.1", "use tmpdir function argument")
+        # py.log._apiwarn(">1.1", "use tmpdir function argument")
         return self.getbasetemp().ensure(string, dir=dir)
 
     def mktemp(self, basename, numbered=True):
@@ -38,7 +38,7 @@ class TempdirFactory:
             p = basetemp.mkdir(basename)
         else:
             p = py.path.local.make_numbered_dir(prefix=basename,
-                keep=0, rootdir=basetemp, lock_timeout=None)
+                                                keep=0, rootdir=basetemp, lock_timeout=None)
         self.trace("mktemp", p)
         return p
 

_pytest/unittest.py

@@ -7,9 +7,9 @@ import traceback
 # for transferring markers
 import _pytest._code
 from _pytest.config import hookimpl
-from _pytest.runner import fail, skip
+from _pytest.outcomes import fail, skip, xfail
 from _pytest.python import transfer_markers, Class, Module, Function
-from _pytest.skipping import MarkEvaluator, xfail
+from _pytest.skipping import MarkEvaluator
 
 
 def pytest_pycollect_makeitem(collector, name, obj):
@@ -109,13 +109,13 @@ class TestCaseFunction(Function):
         except TypeError:
             try:
                 try:
-                    l = traceback.format_exception(*rawexcinfo)
-                    l.insert(0, "NOTE: Incompatible Exception Representation, "
-                                "displaying natively:\n\n")
-                    fail("".join(l), pytrace=False)
+                    values = traceback.format_exception(*rawexcinfo)
+                    values.insert(0, "NOTE: Incompatible Exception Representation, "
+                                  "displaying natively:\n\n")
+                    fail("".join(values), pytrace=False)
                 except (fail.Exception, KeyboardInterrupt):
                     raise
-                except:
+                except:  # noqa
                     fail("ERROR: Unknown Incompatible Exception "
                          "representation:\n%r" % (rawexcinfo,), pytrace=False)
             except KeyboardInterrupt:
@@ -158,7 +158,7 @@ class TestCaseFunction(Function):
         # analog to pythons Lib/unittest/case.py:run
         testMethod = getattr(self._testcase, self._testcase._testMethodName)
         if (getattr(self._testcase.__class__, "__unittest_skip__", False) or
-            getattr(testMethod, "__unittest_skip__", False)):
+                getattr(testMethod, "__unittest_skip__", False)):
             # If the class or method was skipped.
             skip_why = (getattr(self._testcase.__class__, '__unittest_skip_why__', '') or
                         getattr(testMethod, '__unittest_skip_why__', ''))
@@ -210,7 +210,7 @@ def pytest_runtest_protocol(item):
         check_testcase_implements_trial_reporter()
 
         def excstore(self, exc_value=None, exc_type=None, exc_tb=None,
-            captureVars=None):
+                     captureVars=None):
             if exc_value is None:
                 self._rawexcinfo = sys.exc_info()
             else:
@@ -219,7 +219,7 @@ def pytest_runtest_protocol(item):
                 self._rawexcinfo = (exc_type, exc_value, exc_tb)
             try:
                 Failure__init__(self, exc_value, exc_type, exc_tb,
-                    captureVars=captureVars)
+                                captureVars=captureVars)
             except TypeError:
                 Failure__init__(self, exc_value, exc_type, exc_tb)
 

_pytest/warnings.py

@@ -39,8 +39,9 @@ def pytest_addoption(parser):
         '-W', '--pythonwarnings', action='append',
         help="set which warnings to report, see -W option of python itself.")
     parser.addini("filterwarnings", type="linelist",
-                  help="Each line specifies warning filter pattern which would be passed"
-                  "to warnings.filterwarnings. Process after -W and --pythonwarnings.")
+                  help="Each line specifies a pattern for "
+                  "warnings.filterwarnings. "
+                  "Processed after -W and --pythonwarnings.")
 
 
 @contextmanager
@@ -59,6 +60,11 @@ def catch_warnings_for_item(item):
         for arg in inifilters:
             _setoption(warnings, arg)
 
+        mark = item.get_marker('filterwarnings')
+        if mark:
+            for arg in mark.args:
+                warnings._setoption(arg)
+
         yield
 
         for warning in log:
@@ -78,7 +84,7 @@ def catch_warnings_for_item(item):
             if unicode_warning:
                 warnings.warn(
                     "Warning is using unicode non convertible to ascii, "
-                    "converting to a safe representation:\n  %s"  % msg,
+                    "converting to a safe representation:\n  %s" % msg,
                     UnicodeWarning)
 
 

appveyor.yml

@@ -20,12 +20,14 @@ environment:
   - TOXENV: "py27-pexpect"
   - TOXENV: "py27-xdist"
   - TOXENV: "py27-trial"
-  - TOXENV: "py35-pexpect"
-  - TOXENV: "py35-xdist"
-  - TOXENV: "py35-trial"
+  - TOXENV: "py27-numpy"
+  - TOXENV: "py36-pexpect"
+  - TOXENV: "py36-xdist"
+  - TOXENV: "py36-trial"
+  - TOXENV: "py36-numpy"
   - TOXENV: "py27-nobyte"
   - TOXENV: "doctesting"
-  - TOXENV: "freeze"
+  - TOXENV: "py35-freeze"
   - TOXENV: "docs"
 
 install:
@@ -34,7 +36,7 @@ install:
 
   - if "%TOXENV%" == "pypy" call scripts\install-pypy.bat
 
-  - C:\Python35\python -m pip install tox
+  - C:\Python36\python -m pip install --upgrade --pre tox
 
 build: false  # Not a C# project, build stuff at the test step instead.
 

changelog/2836.bug

@@ -0,0 +1 @@
+Match fixture paths against actual path segments in order to avoid matching folders which share a prefix.

changelog/_template.rst

@@ -6,14 +6,15 @@
 
 {% endif %}
 {% if sections[section] %}
-{% for category, val in definitions.items() if category in sections[section] and category != 'trivial' %}
+{% for category, val in definitions.items() if category in sections[section] %}
 
 {{ definitions[category]['name'] }}
 {{ underline * definitions[category]['name']|length }}
 
 {% if definitions[category]['showcontent'] %}
 {% for text, values in sections[section][category]|dictsort(by='value') %}
-- {{ text }}{% if category != 'vendor' %} ({{ values|sort|join(', ') }}){% endif %}
+{% set issue_joiner = joiner(', ') %}
+- {{ text }}{% if category != 'vendor' %} ({% for value in values|sort %}{{ issue_joiner() }}`{{ value }} <https://github.com/pytest-dev/pytest/issues/{{ value[1:] }}>`_{% endfor %}){% endif %}
 
 
 {% endfor %}

doc/en/_templates/globaltoc.html

@@ -9,6 +9,7 @@
   <li><a href="{{ pathto('contact') }}">Contact</a></li>
   <li><a href="{{ pathto('talks') }}">Talks/Posts</a></li>
   <li><a href="{{ pathto('changelog') }}">Changelog</a></li>
+  <li><a href="{{ pathto('backwards-compatibility') }}">Backwards Compatibility</a></li>
   <li><a href="{{ pathto('license') }}">License</a></li>
 </ul>
 

doc/en/announce/index.rst

@@ -6,6 +6,12 @@ Release announcements
    :maxdepth: 2
 
    
+   release-3.2.4
+   release-3.2.3
+   release-3.2.2
+   release-3.2.1
+   release-3.2.0
+   release-3.1.3
    release-3.1.2
    release-3.1.1
    release-3.1.0

doc/en/announce/release-3.1.3.rst

@@ -0,0 +1,23 @@
+pytest-3.1.3
+=======================================
+
+pytest 3.1.3 has just been released to PyPI.
+
+This is a bug-fix release, being a drop-in replacement. To upgrade::
+
+  pip install --upgrade pytest
+  
+The full changelog is available at http://doc.pytest.org/en/latest/changelog.html.
+
+Thanks to all who contributed to this release, among them:
+
+* Antoine Legrand
+* Bruno Oliveira
+* Max Moroz
+* Raphael Pierzina
+* Ronny Pfannschmidt
+* Ryan Fitzpatrick
+
+
+Happy testing,
+The pytest Development Team

doc/en/announce/release-3.2.0.rst

@@ -0,0 +1,48 @@
+pytest-3.2.0
+=======================================
+
+The pytest team is proud to announce the 3.2.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 number of bugs fixes and improvements, so users are encouraged
+to take a look at the CHANGELOG:
+
+    http://doc.pytest.org/en/latest/changelog.html
+
+For complete 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:
+
+* Alex Hartoto
+* Andras Tim
+* Bruno Oliveira
+* Daniel Hahler
+* Florian Bruhin
+* Floris Bruynooghe
+* John Still
+* Jordan Moldow
+* Kale Kundert
+* Lawrence Mitchell
+* Llandy Riveron Del Risco
+* Maik Figura
+* Martin Altmayer
+* Mihai Capotă
+* Nathaniel Waisbrot
+* Nguyễn Hồng Quân
+* Pauli Virtanen
+* Raphael Pierzina
+* Ronny Pfannschmidt
+* Segev Finer
+* V.Kuznetsov
+
+
+Happy testing,
+The Pytest Development Team

doc/en/announce/release-3.2.1.rst

@@ -0,0 +1,22 @@
+pytest-3.2.1
+=======================================
+
+pytest 3.2.1 has just been released to PyPI.
+
+This is a bug-fix release, being a drop-in replacement. To upgrade::
+
+  pip install --upgrade pytest
+  
+The full changelog is available at http://doc.pytest.org/en/latest/changelog.html.
+
+Thanks to all who contributed to this release, among them:
+
+* Alex Gaynor
+* Bruno Oliveira
+* Florian Bruhin
+* Ronny Pfannschmidt
+* Srinivas Reddy Thatiparthy
+
+
+Happy testing,
+The pytest Development Team

doc/en/announce/release-3.2.2.rst

@@ -0,0 +1,28 @@
+pytest-3.2.2
+=======================================
+
+pytest 3.2.2 has just been released to PyPI.
+
+This is a bug-fix release, being a drop-in replacement. To upgrade::
+
+  pip install --upgrade pytest
+  
+The full changelog is available at http://doc.pytest.org/en/latest/changelog.html.
+
+Thanks to all who contributed to this release, among them:
+
+* Andreas Pelme
+* Antonio Hidalgo
+* Bruno Oliveira
+* Felipe Dau
+* Fernando Macedo
+* Jesús Espino
+* Joan Massich
+* Joe Talbott
+* Kirill Pinchuk
+* Ronny Pfannschmidt
+* Xuan Luong
+
+
+Happy testing,
+The pytest Development Team

doc/en/announce/release-3.2.3.rst

@@ -0,0 +1,23 @@
+pytest-3.2.3
+=======================================
+
+pytest 3.2.3 has just been released to PyPI.
+
+This is a bug-fix release, being a drop-in replacement. To upgrade::
+
+  pip install --upgrade pytest
+  
+The full changelog is available at http://doc.pytest.org/en/latest/changelog.html.
+
+Thanks to all who contributed to this release, among them:
+
+* Bruno Oliveira
+* Evan
+* Joe Hamman
+* Oliver Bestwalter
+* Ronny Pfannschmidt
+* Xuan Luong
+
+
+Happy testing,
+The pytest Development Team

doc/en/announce/release-3.2.4.rst

@@ -0,0 +1,36 @@
+pytest-3.2.4
+=======================================
+
+pytest 3.2.4 has just been released to PyPI.
+
+This is a bug-fix release, being a drop-in replacement. To upgrade::
+
+  pip install --upgrade pytest
+  
+The full changelog is available at http://doc.pytest.org/en/latest/changelog.html.
+
+Thanks to all who contributed to this release, among them:
+
+* Bruno Oliveira
+* Christian Boelsen
+* Christoph Buchner
+* Daw-Ran Liou
+* Florian Bruhin
+* Franck Michea
+* Leonard Lausen
+* Matty G
+* Owen Tuz
+* Pavel Karateev
+* Pierre GIRAUD
+* Ronny Pfannschmidt
+* Stephen Finucane
+* Sviatoslav Abakumov
+* Thomas Hisch
+* Tom Dalton
+* Xuan Luong
+* Yorgos Pagles
+* Семён Марьясин
+
+
+Happy testing,
+The pytest Development Team

doc/en/assert.rst

@@ -28,7 +28,7 @@ you will see the return value of the function call::
     ======= test session starts ========
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
     rootdir: $REGENDOC_TMPDIR, inifile:
-    collected 1 items
+    collected 1 item
     
     test_assert1.py F
     
@@ -119,9 +119,9 @@ 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::
+Also, the context manager form accepts a ``match`` keyword parameter to test
+that a regular expression matches on the string representation of an exception
+(like the ``TestCase.assertRaisesRegexp`` method from ``unittest``)::
 
     import pytest
 
@@ -129,12 +129,11 @@ from ``unittest``) you can use the ``ExceptionInfo.match`` method::
         raise ValueError("Exception 123 raised")
 
     def test_match():
-        with pytest.raises(ValueError) as excinfo:
+        with pytest.raises(ValueError, match=r'.* 123 .*'):
             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
+function. So in the above example ``match='123'`` would have worked as
 well.
 
 
@@ -172,7 +171,7 @@ if you run this module::
     ======= test session starts ========
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
     rootdir: $REGENDOC_TMPDIR, inifile:
-    collected 1 items
+    collected 1 item
     
     test_assert2.py F
     
@@ -210,8 +209,8 @@ 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::
+As an example consider adding the following hook in a :ref:`conftest.py <conftest.py>` 
+file which provides an alternative explanation for ``Foo`` objects::
 
    # content of conftest.py
    from test_foocompare import Foo

doc/en/builtin.rst

@@ -38,7 +38,7 @@ Examples at :ref:`assertraises`.
 Comparing floating point numbers
 --------------------------------
 
-.. autoclass:: approx
+.. autofunction:: approx
 
 Raising a specific test outcome
 --------------------------------------
@@ -47,11 +47,11 @@ You can use the following functions in your test, fixture or setup
 functions to force a certain test outcome.  Note that most often
 you can rather use declarative marks, see :ref:`skipping`.
 
-.. autofunction:: _pytest.runner.fail
-.. autofunction:: _pytest.runner.skip
-.. autofunction:: _pytest.runner.importorskip
-.. autofunction:: _pytest.skipping.xfail
-.. autofunction:: _pytest.runner.exit
+.. autofunction:: _pytest.outcomes.fail
+.. autofunction:: _pytest.outcomes.skip
+.. autofunction:: _pytest.outcomes.importorskip
+.. autofunction:: _pytest.outcomes.xfail
+.. autofunction:: _pytest.outcomes.exit
 
 Fixtures and requests
 -----------------------------------------------------
@@ -108,14 +108,14 @@ You can ask for available builtin or project-custom
         The returned ``monkeypatch`` fixture provides these
         helper methods to modify objects, dictionaries or os.environ::
         
-        monkeypatch.setattr(obj, name, value, raising=True)
-        monkeypatch.delattr(obj, name, raising=True)
-        monkeypatch.setitem(mapping, name, value)
-        monkeypatch.delitem(obj, name, raising=True)
-        monkeypatch.setenv(name, value, prepend=False)
-        monkeypatch.delenv(name, value, raising=True)
-        monkeypatch.syspath_prepend(path)
-        monkeypatch.chdir(path)
+            monkeypatch.setattr(obj, name, value, raising=True)
+            monkeypatch.delattr(obj, name, raising=True)
+            monkeypatch.setitem(mapping, name, value)
+            monkeypatch.delitem(obj, name, raising=True)
+            monkeypatch.setenv(name, value, prepend=False)
+            monkeypatch.delenv(name, value, raising=True)
+            monkeypatch.syspath_prepend(path)
+            monkeypatch.chdir(path)
         
         All modifications will be undone after the requesting
         test function or fixture has finished. The ``raising``

doc/en/cache.rst

@@ -1,16 +1,12 @@
+.. _`cache_provider`:
+.. _cache:
+
+
 Cache: working with cross-testrun state
 =======================================
 
 .. versionadded:: 2.8
 
-.. warning::
-
-  The functionality of this core plugin was previously distributed
-  as a third party plugin named ``pytest-cache``.  The core plugin
-  is compatible regarding command line options and API usage except that you
-  can only store/receive data between test runs that is json-serializable.
-
-
 Usage
 ---------
 
@@ -81,9 +77,9 @@ If you then run it with ``--lf``::
     $ pytest --lf
     ======= test session starts ========
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
-    run-last-failure: rerun last 2 failures
     rootdir: $REGENDOC_TMPDIR, inifile:
     collected 50 items
+    run-last-failure: rerun previous 2 failures
     
     test_50.py FF
     
@@ -123,9 +119,9 @@ of ``FF`` and dots)::
     $ pytest --ff
     ======= test session starts ========
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
-    run-last-failure: rerun last 2 failures first
     rootdir: $REGENDOC_TMPDIR, inifile:
     collected 50 items
+    run-last-failure: rerun previous 2 failures first
     
     test_50.py FF................................................
     

doc/en/contact.rst

@@ -19,9 +19,9 @@ Contact channels
 - `pytest-commit at python.org (mailing list)`_: for commits and new issues
 
 - :doc:`contribution guide <contributing>` for help on submitting pull
-  requests to bitbucket (including using git via gitifyhg).
+  requests to GitHub.
 
-- #pylib on irc.freenode.net IRC channel for random questions.
+- ``#pylib`` on irc.freenode.net IRC channel for random questions.
 
 - private mail to Holger.Krekel at gmail com if you want to communicate sensitive issues
 
@@ -46,6 +46,5 @@ Contact channels
 .. _`py-dev`:
 .. _`development mailing list`:
 .. _`pytest-dev at python.org (mailing list)`: http://mail.python.org/mailman/listinfo/pytest-dev
-.. _`py-svn`:
 .. _`pytest-commit at python.org (mailing list)`: http://mail.python.org/mailman/listinfo/pytest-commit
 

doc/en/contents.rst

@@ -31,14 +31,17 @@ Full pytest documentation
    plugins
    writing_plugins
 
-   example/index
    goodpractices
+   pythonpath
    customize
+   example/index
    bash-completion
 
    backwards-compatibility
+   historical-notes
    license
    contributing
+   development_guide
    talks
    projects
    faq

doc/en/customize.rst

@@ -1,5 +1,5 @@
-Basic test configuration
-===================================
+Configuration
+=============
 
 Command line options and configuration file settings
 -----------------------------------------------------------------
@@ -15,17 +15,31 @@ which were registered by installed plugins.
 .. _rootdir:
 .. _inifiles:
 
-initialization: determining rootdir and inifile
+Initialization: determining rootdir and inifile
 -----------------------------------------------
 
 .. versionadded:: 2.7
 
-pytest determines a "rootdir" for each test run which depends on
+pytest determines a ``rootdir`` for each test run which depends on
 the command line arguments (specified test files, paths) and on
-the existence of inifiles.  The determined rootdir and ini-file are
-printed as part of the pytest header.  The rootdir is used for constructing
-"nodeids" during collection and may also be used by plugins to store
-project/testrun-specific information.
+the existence of *ini-files*.  The determined ``rootdir`` and *ini-file* are
+printed as part of the pytest header during startup.
+
+Here's a summary what ``pytest`` uses ``rootdir`` for:
+
+* Construct *nodeids* during collection; each test is assigned
+  a unique *nodeid* which is rooted at the ``rootdir`` and takes in account full path,
+  class name, function name and parametrization (if any).
+
+* Is used by plugins as a stable location to store project/test run specific information;
+  for example, the internal :ref:`cache <cache>` plugin creates a ``.cache`` subdirectory
+  in ``rootdir`` to store its cross-test run state.
+
+Important to emphasize that ``rootdir`` is **NOT** used to modify ``sys.path``/``PYTHONPATH`` or
+influence how modules are imported. See :ref:`pythonpath` for more details.
+
+Finding the ``rootdir``
+~~~~~~~~~~~~~~~~~~~~~~~
 
 Here is the algorithm which finds the rootdir from ``args``:
 
@@ -112,15 +126,27 @@ progress output, you can write it into a configuration file:
     # content of pytest.ini
     # (or tox.ini or setup.cfg)
     [pytest]
-    addopts = -rsxX -q
+    addopts = -ra -q
 
-Alternatively, you can set a PYTEST_ADDOPTS environment variable to add command
+Alternatively, you can set a ``PYTEST_ADDOPTS`` environment variable to add command
 line options while the environment is in use::
 
-    export PYTEST_ADDOPTS="-rsxX -q"
+    export PYTEST_ADDOPTS="-v"
 
-From now on, running ``pytest`` will add the specified options.
+Here's how the command-line is built in the presence of ``addopts`` or the environment variable::
 
+    <pytest.ini:addopts> $PYTEST_ADDOTPS <extra command-line arguments>
+
+So if the user executes in the command-line::
+
+    pytest -m slow
+
+The actual command line executed is::
+
+    pytest -ra -q -v -m slow
+
+Note that as usual for other command-line applications, in case of conflicting options the last one wins, so the example
+above will show verbose output because ``-v`` overwrites ``-q``.
 
 
 Builtin configuration file options
@@ -171,7 +197,16 @@ Builtin configuration file options
         norecursedirs = .svn _build tmp*
 
    This would tell ``pytest`` to not look into typical subversion or
-   sphinx-build directories or into any ``tmp`` prefixed directory.
+   sphinx-build directories or into any ``tmp`` prefixed directory.  
+   
+   Additionally, ``pytest`` will attempt to intelligently identify and ignore a
+   virtualenv by the presence of an activation script.  Any directory deemed to
+   be the root of a virtual environment will not be considered during test
+   collection unless ``‑‑collect‑in‑virtualenv`` is given.  Note also that
+   ``norecursedirs`` takes precedence over ``‑‑collect‑in‑virtualenv``; e.g. if
+   you intend to run tests in a virtualenv with a base directory that matches
+   ``'.*'`` you *must* override ``norecursedirs`` in addition to using the
+   ``‑‑collect‑in‑virtualenv`` flag.
 
 .. confval:: testpaths
 
@@ -195,13 +230,16 @@ Builtin configuration file options
 .. confval:: python_files
 
    One or more Glob-style file patterns determining which python files
-   are considered as test modules.
+   are considered as test modules. By default, pytest will consider
+   any file matching with ``test_*.py`` and ``*_test.py`` globs as a test
+   module.
 
 .. confval:: python_classes
 
    One or more name prefixes or glob-style patterns determining which classes
-   are considered for test collection. Here is an example of how to collect
-   tests from classes that end in ``Suite``:
+   are considered for test collection. By default, pytest will consider any
+   class prefixed with ``Test`` as a test collection.  Here is an example of how
+   to collect tests from classes that end in ``Suite``:
 
    .. code-block:: ini
 
@@ -216,7 +254,8 @@ Builtin configuration file options
 .. confval:: python_functions
 
    One or more name prefixes or glob-patterns determining which test functions
-   and methods are considered tests. Here is an example of how
+   and methods are considered tests. By default, pytest will consider any
+   function prefixed with ``test`` as a test.  Here is an example of how
    to collect test functions and methods that end in ``_test``:
 
    .. code-block:: ini
@@ -262,3 +301,14 @@ Builtin configuration file options
 
    This tells pytest to ignore deprecation warnings and turn all other warnings
    into errors. For more information please refer to :ref:`warnings`.
+
+.. confval:: cache_dir
+
+   .. versionadded:: 3.2
+
+   Sets a directory where stores content of cache plugin. Default directory is
+   ``.cache`` which is created in :ref:`rootdir <rootdir>`. Directory may be
+   relative or absolute path. If setting relative path, then directory is created
+   relative to :ref:`rootdir <rootdir>`. Additionally path may contain environment
+   variables, that will be expanded. For more information about cache plugin
+   please refer to :ref:`cache_provider`.

doc/en/development_guide.rst

@@ -0,0 +1,108 @@
+=================
+Development Guide
+=================
+
+Some general guidelines regarding development in pytest for core maintainers and general contributors. Nothing here
+is set in stone and can't be changed, feel free to suggest improvements or changes in the workflow.
+
+
+Code Style
+----------
+
+* `PEP-8 <https://www.python.org/dev/peps/pep-0008>`_
+* `flake8 <https://pypi.python.org/pypi/flake8>`_ for quality checks
+* `invoke <http://www.pyinvoke.org/>`_ to automate development tasks
+
+
+Branches
+--------
+
+We have two long term branches:
+
+* ``master``: contains the code for the next bugfix release.
+* ``features``: contains the code with new features for the next minor release.
+
+The official repository usually does not contain topic branches, developers and contributors should create topic
+branches in their own forks.
+
+Exceptions can be made for cases where more than one contributor is working on the same
+topic or where it makes sense to use some automatic capability of the main repository, such as automatic docs from
+`readthedocs <readthedocs.org>`_ for a branch dealing with documentation refactoring.
+
+Issues
+------
+
+Any question, feature, bug or proposal is welcome as an issue. Users are encouraged to use them whenever they need.
+
+GitHub issues should use labels to categorize them. Labels should be created sporadically, to fill a niche; we should
+avoid creating labels just for the sake of creating them.
+
+Here is a list of labels and a brief description mentioning their intent.
+
+
+**Type**
+
+* ``type: backward compatibility``: issue that will cause problems with old pytest versions.
+* ``type: bug``: problem that needs to be addressed.
+* ``type: deprecation``: feature that will be deprecated in the future.
+* ``type: docs``: documentation missing or needing clarification.
+* ``type: enhancement``: new feature or API change, should be merged into ``features``.
+* ``type: feature-branch``: new feature or API change, should be merged into ``features``.
+* ``type: infrastructure``: improvement to development/releases/CI structure.
+* ``type: performance``: performance or memory problem/improvement.
+* ``type: proposal``: proposal for a new feature, often to gather opinions or design the API around the new feature.
+* ``type: question``: question regarding usage, installation, internals or how to test something.
+* ``type: refactoring``: internal improvements to the code.
+* ``type: regression``: indicates a problem that was introduced in a release which was working previously.
+
+**Status**
+
+* ``status: critical``: grave problem or usability issue that affects lots of users.
+* ``status: easy``: easy issue that is friendly to new contributors.
+* ``status: help wanted``: core developers need help from experts on this topic.
+* ``status: needs information``: reporter needs to provide more information; can be closed after 2 or more weeks of inactivity.
+
+**Topic**
+
+* ``topic: collection``
+* ``topic: fixtures``
+* ``topic: parametrize``
+* ``topic: reporting``
+* ``topic: selection``
+* ``topic: tracebacks``
+
+**Plugin (internal or external)**
+
+* ``plugin: cache``
+* ``plugin: capture``
+* ``plugin: doctests``
+* ``plugin: junitxml``
+* ``plugin: monkeypatch``
+* ``plugin: nose``
+* ``plugin: pastebin``
+* ``plugin: pytester``
+* ``plugin: tmpdir``
+* ``plugin: unittest``
+* ``plugin: warnings``
+* ``plugin: xdist``
+
+
+**OS**
+
+Issues specific to a single operating system. Do not use as a means to indicate where an issue originated from, only
+for problems that happen **only** in that system.
+
+* ``os: linux``
+* ``os: mac``
+* ``os: windows``
+
+**Temporary**
+
+Used to classify issues for limited time, to help find issues related in events for example.
+They should be removed after they are no longer relevant.
+
+* ``temporary: EP2017 sprint``:
+* ``temporary: sprint-candidate``:
+
+
+.. include:: ../../HOWTORELEASE.rst

doc/en/doctest.rst

@@ -64,7 +64,7 @@ then you can just invoke ``pytest`` without command line options::
     ======= test session starts ========
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
     rootdir: $REGENDOC_TMPDIR, inifile: pytest.ini
-    collected 1 items
+    collected 1 item
     
     mymodule.py .
     

doc/en/example/attic.rst

@@ -17,7 +17,7 @@ example: specifying and selecting acceptance tests
 
     class AcceptFixture(object):
         def __init__(self, request):
-            if not request.config.option.acceptance:
+            if not request.config.getoption('acceptance'):
                 pytest.skip("specify -A to run acceptance tests")
             self.tmpdir = request.config.mktemp(request.function.__name__, numbered=True)
 

doc/en/example/index.rst

@@ -1,8 +1,8 @@
 
 .. _examples:
 
-Usages and Examples
-===========================================
+Examples and customization tricks
+=================================
 
 Here is a (growing) list of examples. :ref:`Contact <contact>` us if you
 need more examples or have questions. Also take a look at the

doc/en/example/markers.rst

@@ -69,7 +69,7 @@ tests based on their module, class, method, or function name::
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y -- $PYTHON_PREFIX/bin/python3.5
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile:
-    collecting ... collected 5 items
+    collecting ... collected 1 item
     
     test_server.py::TestClass::test_method PASSED
     
@@ -82,7 +82,7 @@ You can also select on the class::
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y -- $PYTHON_PREFIX/bin/python3.5
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile:
-    collecting ... collected 4 items
+    collecting ... collected 1 item
     
     test_server.py::TestClass::test_method PASSED
     
@@ -95,7 +95,7 @@ Or select multiple nodes::
   platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y -- $PYTHON_PREFIX/bin/python3.5
   cachedir: .cache
   rootdir: $REGENDOC_TMPDIR, inifile:
-  collecting ... collected 8 items
+  collecting ... collected 2 items
   
   test_server.py::TestClass::test_method PASSED
   test_server.py::test_send_http PASSED
@@ -173,14 +173,18 @@ Or to select "http" and "quick" tests::
 
 .. note::
 
-    If you are using expressions such as "X and Y" then both X and Y
-    need to be simple non-keyword names.  For example, "pass" or "from"
-    will result in SyntaxErrors because "-k" evaluates the expression.
+    If you are using expressions such as ``"X and Y"`` then both ``X`` and ``Y``
+    need to be simple non-keyword names. For example, ``"pass"`` or ``"from"``
+    will result in SyntaxErrors because ``"-k"`` evaluates the expression using
+    Python's `eval`_ function.
 
-    However, if the "-k" argument is a simple string, no such restrictions
-    apply.  Also "-k 'not STRING'" has no restrictions.  You can also
-    specify numbers like "-k 1.3" to match tests which are parametrized
-    with the float "1.3".
+.. _`eval`: https://docs.python.org/3.6/library/functions.html#eval
+
+
+    However, if the ``"-k"`` argument is a simple string, no such restrictions
+    apply. Also ``"-k 'not STRING'"`` has no restrictions.  You can also
+    specify numbers like ``"-k 1.3"`` to match tests which are parametrized
+    with the float ``"1.3"``.
 
 Registering markers
 -------------------------------------
@@ -223,13 +227,12 @@ For an example on how to add and work with markers from a plugin, see
 
     It is recommended to explicitly register markers so that:
 
-    * there is one place in your test suite defining your markers
+    * There is one place in your test suite defining your markers
 
-    * asking for existing markers via ``pytest --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
-      going to start treating non-registered markers as errors at some point.
+    * Typos in function markers are treated as an error if you use
+      the ``--strict`` option. 
 
 .. _`scoped-marking`:
 
@@ -354,7 +357,7 @@ the test needs::
     ======= test session starts ========
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
     rootdir: $REGENDOC_TMPDIR, inifile:
-    collected 1 items
+    collected 1 item
     
     test_someenv.py s
     
@@ -366,7 +369,7 @@ and here is one that specifies exactly the environment needed::
     ======= test session starts ========
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
     rootdir: $REGENDOC_TMPDIR, inifile:
-    collected 1 items
+    collected 1 item
     
     test_someenv.py .
     
@@ -392,6 +395,49 @@ The ``--markers`` option always gives you a list of available markers::
     @pytest.mark.trylast: mark a hook implementation function such that the plugin machinery will try to call it last/as late as possible.
     
 
+.. _`passing callables to custom markers`:
+
+Passing a callable to custom markers
+--------------------------------------------
+
+.. regendoc:wipe
+
+Below is the config file that will be used in the next examples::
+
+    # content of conftest.py
+    import sys
+
+    def pytest_runtest_setup(item):
+        marker = item.get_marker('my_marker')
+        if marker is not None:
+            for info in marker:
+                print('Marker info name={} args={} kwars={}'.format(info.name, info.args, info.kwargs))
+                sys.stdout.flush()
+
+A custom marker can have its argument set, i.e. ``args`` and ``kwargs`` properties, defined by either invoking it as a callable or using ``pytest.mark.MARKER_NAME.with_args``. These two methods achieve the same effect most of the time.
+
+However, if there is a callable as the single positional argument with no keyword arguments, using the ``pytest.mark.MARKER_NAME(c)`` will not pass ``c`` as a positional argument but decorate ``c`` with the custom marker (see :ref:`MarkDecorator <mark>`). Fortunately, ``pytest.mark.MARKER_NAME.with_args`` comes to the rescue::
+
+    # content of test_custom_marker.py
+    import pytest
+
+    def hello_world(*args, **kwargs):
+        return 'Hello World'
+
+    @pytest.mark.my_marker.with_args(hello_world)
+    def test_with_args():
+        pass
+
+The output is as follows::
+
+    $ pytest -q -s
+    Marker info name=my_marker args=(<function hello_world at 0xdeadbeef>,) kwars={}
+    .
+    1 passed in 0.12 seconds
+
+We can see that the custom marker has its argument set extended with the function ``hello_world``. This is the key difference between creating a custom marker as a callable, which invokes ``__call__`` behind the scenes, and using ``with_args``.
+
+
 Reading markers which were set from multiple places
 ----------------------------------------------------
 
@@ -491,7 +537,7 @@ then you will see two tests skipped and two executed tests as expected::
     
     test_plat.py s.s.
     ======= short test summary info ========
-    SKIP [2] $REGENDOC_TMPDIR/conftest.py:12: cannot run on platform linux
+    SKIP [2] $REGENDOC_TMPDIR/conftest.py:13: cannot run on platform linux
     
     ======= 2 passed, 2 skipped in 0.12 seconds ========
 

doc/en/example/parametrize.rst

@@ -36,7 +36,7 @@ Now we add a test configuration like this::
 
     def pytest_generate_tests(metafunc):
         if 'param1' in metafunc.fixturenames:
-            if metafunc.config.option.all:
+            if metafunc.config.getoption('all'):
                 end = 5
             else:
                 end = 2
@@ -336,7 +336,7 @@ The result of this test will be successful::
     ======= test session starts ========
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
     rootdir: $REGENDOC_TMPDIR, inifile:
-    collected 1 items
+    collected 1 item
     <Module 'test_indirect_list.py'>
       <Function 'test_indirect[a-b]'>
     
@@ -350,7 +350,7 @@ Parametrizing test methods through per-class configuration
 .. _`unittest parametrizer`: https://github.com/testing-cabal/unittest-ext/blob/master/params.py
 
 
-Here is an example ``pytest_generate_function`` function implementing a
+Here is an example ``pytest_generate_tests`` function implementing a
 parametrization scheme similar to Michael Foord's `unittest
 parametrizer`_ but in a lot less code::
 
@@ -413,7 +413,7 @@ Running it results in some skips if we don't have all the python interpreters in
    . $ pytest -rs -q multipython.py
    sssssssssssssss.........sss.........sss.........
    ======= short test summary info ========
-   SKIP [21] $REGENDOC_TMPDIR/CWD/multipython.py:23: 'python2.6' not found
+   SKIP [21] $REGENDOC_TMPDIR/CWD/multipython.py:24: 'python2.6' not found
    27 passed, 21 skipped in 0.12 seconds
 
 Indirect parametrization of optional implementations/imports
@@ -467,7 +467,7 @@ If you run this with reporting for skips enabled::
     
     test_module.py .s
     ======= short test summary info ========
-    SKIP [1] $REGENDOC_TMPDIR/conftest.py:10: could not import 'opt2'
+    SKIP [1] $REGENDOC_TMPDIR/conftest.py:11: could not import 'opt2'
     
     ======= 1 passed, 1 skipped in 0.12 seconds ========
 
@@ -485,4 +485,54 @@ of our ``test_func1`` was skipped.  A few notes:
   values as well.
 
 
+Set marks or test ID for individual parametrized test
+--------------------------------------------------------------------
 
+Use ``pytest.param`` to apply marks or set test ID to individual parametrized test.
+For example::
+
+    # content of test_pytest_param_example.py
+    import pytest
+    @pytest.mark.parametrize('test_input,expected', [
+        ('3+5', 8),
+        pytest.param('1+7', 8,
+                     marks=pytest.mark.basic),
+        pytest.param('2+4', 6,
+                     marks=pytest.mark.basic,
+                     id='basic_2+4'),
+        pytest.param('6*9', 42,
+                     marks=[pytest.mark.basic, pytest.mark.xfail],
+                     id='basic_6*9'),
+    ])
+    def test_eval(test_input, expected):
+        assert eval(test_input) == expected
+    
+In this example, we have 4 parametrized tests. Except for the first test,
+we mark the rest three parametrized tests with the custom marker ``basic``,
+and for the fourth test we also use the built-in mark ``xfail`` to indicate this 
+test is expected to fail. For explicitness, we set test ids for some tests.
+
+Then run ``pytest`` with verbose mode and with only the ``basic`` marker::
+
+    pytest -v -m basic
+    ============================================ test session starts =============================================
+    platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
+    rootdir: $REGENDOC_TMPDIR, inifile:
+    collected 4 items
+
+    test_pytest_param_example.py::test_eval[1+7-8] PASSED
+    test_pytest_param_example.py::test_eval[basic_2+4] PASSED
+    test_pytest_param_example.py::test_eval[basic_6*9] xfail
+    ========================================== short test summary info ===========================================
+    XFAIL test_pytest_param_example.py::test_eval[basic_6*9]
+
+    ============================================= 1 tests deselected =============================================
+
+As the result:
+
+- Four tests were collected
+- One test was deselected because it doesn't have the ``basic`` mark.
+- Three tests with the ``basic`` mark was selected.
+- The test ``test_eval[1+7-8]`` passed, but the name is autogenerated and confusing.
+- The test ``test_eval[basic_2+4]`` passed.
+- The test ``test_eval[basic_6*9]`` was expected to fail and did fail.

doc/en/example/pythoncollection.rst

@@ -175,21 +175,23 @@ You can always peek at the collection tree without running tests like this::
     
     ======= no tests ran in 0.12 seconds ========
 
-customizing test collection to find all .py files
----------------------------------------------------------
+.. _customizing-test-collection:
+
+Customizing test collection
+---------------------------
 
 .. regendoc:wipe
 
-You can easily instruct ``pytest`` to discover tests from every python file::
-
+You can easily instruct ``pytest`` to discover tests from every Python file::
 
     # content of pytest.ini
     [pytest]
     python_files = *.py
 
-However, many projects will have a ``setup.py`` which they don't want to be imported. Moreover, there may files only importable by a specific python version.
-For such cases you can dynamically define files to be ignored by listing
-them in a ``conftest.py`` file::
+However, many projects will have a ``setup.py`` which they don't want to be
+imported. Moreover, there may files only importable by a specific python
+version. For such cases you can dynamically define files to be ignored by
+listing them in a ``conftest.py`` file::
 
     # content of conftest.py
     import sys
@@ -198,7 +200,7 @@ them in a ``conftest.py`` file::
     if sys.version_info[0] > 2:
         collect_ignore.append("pkg/module_py2.py")
 
-And then if you have a module file like this::
+and then if you have a module file like this::
 
     # content of pkg/module_py2.py
     def test_only_on_python2():
@@ -207,13 +209,13 @@ And then if you have a module file like this::
         except Exception, e:
             pass
 
-and a setup.py dummy file like this::
+and a ``setup.py`` dummy file like this::
 
     # content of setup.py
     0/0  # will raise exception if imported
 
-then a pytest run on Python2 will find the one test and will leave out the
-setup.py file::
+If you run with a Python 2 interpreter then you will find the one test and will
+leave out the ``setup.py`` file::
 
     #$ pytest --collect-only
     ====== test session starts ======
@@ -225,8 +227,8 @@ setup.py file::
 
     ====== no tests ran in 0.04 seconds ======
 
-If you run with a Python3 interpreter both the one test and the setup.py file
-will be left out::
+If you run with a Python 3 interpreter both the one test and the ``setup.py``
+file will be left out::
 
     $ pytest --collect-only
     ======= test session starts ========

doc/en/example/reportingdemo.rst

@@ -358,7 +358,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:1219>:1: ValueError
+    <0-codegen $PYTHON_PREFIX/lib/python3.5/site-packages/_pytest/python_api.py:580>:1: ValueError
     _______ TestRaises.test_raises_doesnt ________
     
     self = <failure_demo.TestRaises object at 0xdeadbeef>

doc/en/example/simple.rst

@@ -127,7 +127,7 @@ 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 ``pytest.mark.slow`` marked tests:
 
 .. code-block:: python
 
@@ -136,7 +136,16 @@ line option to control skipping of ``slow`` marked tests:
     import pytest
     def pytest_addoption(parser):
         parser.addoption("--runslow", action="store_true",
-            help="run slow tests")
+                         default=False, help="run slow tests")
+
+    def pytest_collection_modifyitems(config, items):
+        if config.getoption("--runslow"):
+            # --runslow given in cli: do not skip slow tests
+            return
+        skip_slow = pytest.mark.skip(reason="need --runslow option to run")
+        for item in items:
+            if "slow" in item.keywords:
+                item.add_marker(skip_slow)
 
 We can now write a test module like this:
 
@@ -146,17 +155,11 @@ We can now write a test module like this:
     import pytest
 
 
-    slow = pytest.mark.skipif(
-        not pytest.config.getoption("--runslow"),
-        reason="need --runslow option to run"
-    )
-
-
     def test_func_fast():
         pass
 
 
-    @slow
+    @pytest.mark.slow
     def test_func_slow():
         pass
 
@@ -170,7 +173,7 @@ and when running it will see a skipped "slow" test::
     
     test_module.py .s
     ======= short test summary info ========
-    SKIP [1] test_module.py:13: need --runslow option to run
+    SKIP [1] test_module.py:8: need --runslow option to run
     
     ======= 1 passed, 1 skipped in 0.12 seconds ========
 
@@ -363,14 +366,14 @@ out which tests are the slowest. Let's make an artificial test suite:
     import time
 
     def test_funcfast():
-        pass
-
-    def test_funcslow1():
         time.sleep(0.1)
 
-    def test_funcslow2():
+    def test_funcslow1():
         time.sleep(0.2)
 
+    def test_funcslow2():
+        time.sleep(0.3)
+
 Now we can profile which test functions execute the slowest::
 
     $ pytest --durations=3
@@ -382,9 +385,9 @@ Now we can profile which test functions execute the slowest::
     test_some_are_slow.py ...
     
     ======= slowest 3 test durations ========
-    0.20s call     test_some_are_slow.py::test_funcslow2
-    0.10s call     test_some_are_slow.py::test_funcslow1
-    0.00s setup    test_some_are_slow.py::test_funcfast
+    0.30s call     test_some_are_slow.py::test_funcslow2
+    0.20s call     test_some_are_slow.py::test_funcslow1
+    0.10s call     test_some_are_slow.py::test_funcfast
     ======= 3 passed in 0.12 seconds ========
 
 incremental testing - test steps
@@ -761,6 +764,47 @@ and run it::
 You'll see that the fixture finalizers could use the precise reporting
 information.
 
+``PYTEST_CURRENT_TEST`` environment variable
+--------------------------------------------
+
+.. versionadded:: 3.2
+
+Sometimes a test session might get stuck and there might be no easy way to figure out
+which test got stuck, for example if pytest was run in quiet mode (``-q``) or you don't have access to the console
+output. This is particularly a problem if the problem helps only sporadically, the famous "flaky" kind of tests.
+
+``pytest`` sets a ``PYTEST_CURRENT_TEST`` environment variable when running tests, which can be inspected
+by process monitoring utilities or libraries like `psutil <https://pypi.python.org/pypi/psutil>`_ to discover which
+test got stuck if necessary:
+
+.. code-block:: python
+
+    import psutil
+
+    for pid in psutil.pids():
+        environ = psutil.Process(pid).environ()
+        if 'PYTEST_CURRENT_TEST' in environ:
+            print(f'pytest process {pid} running: {environ["PYTEST_CURRENT_TEST"]}')
+
+During the test session pytest will set ``PYTEST_CURRENT_TEST`` to the current test
+:ref:`nodeid <nodeids>` and the current stage, which can be ``setup``, ``call``
+and ``teardown``.
+
+For example, when running a single test function named ``test_foo`` from ``foo_module.py``,
+``PYTEST_CURRENT_TEST`` will be set to:
+
+#. ``foo_module.py::test_foo (setup)``
+#. ``foo_module.py::test_foo (call)``
+#. ``foo_module.py::test_foo (teardown)``
+
+In that order.
+
+.. note::
+
+    The contents of ``PYTEST_CURRENT_TEST`` is meant to be human readable and the actual format
+    can be changed between releases (even bug fixes) so it shouldn't be relied on for scripting
+    or automation.
+
 Freezing pytest 
 ---------------
 

doc/en/fixture.rst

@@ -27,7 +27,7 @@ functions:
 * fixture management scales from simple unit to complex
   functional testing, allowing to parametrize fixtures and tests according
   to configuration and component options, or to re-use fixtures
-  across class, module or whole test session scopes.
+  across function, class, module or whole test session scopes.
 
 In addition, pytest continues to support :ref:`xunitsetup`.  You can mix
 both styles, moving incrementally from classic to new style, as you
@@ -57,7 +57,7 @@ using it::
     @pytest.fixture
     def smtp():
         import smtplib
-        return smtplib.SMTP("smtp.gmail.com")
+        return smtplib.SMTP("smtp.gmail.com", 587, timeout=5)
 
     def test_ehlo(smtp):
         response, msg = smtp.ehlo()
@@ -72,7 +72,7 @@ marked ``smtp`` fixture function.  Running the test looks like this::
     ======= test session starts ========
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
     rootdir: $REGENDOC_TMPDIR, inifile:
-    collected 1 items
+    collected 1 item
     
     test_smtpsimple.py F
     
@@ -109,7 +109,7 @@ Note that if you misspell a function argument or want
 to use one that isn't available, you'll see an error
 with a list of available function arguments.
 
-.. Note::
+.. note::
 
     You can always issue::
 
@@ -117,33 +117,49 @@ with a list of available function arguments.
 
     to see available fixtures.
 
-    In versions prior to 2.3 there was no ``@pytest.fixture`` marker
-    and you had to use a magic ``pytest_funcarg__NAME`` prefix
-    for the fixture factory.  This remains and will remain supported
-    but is not anymore advertised as the primary means of declaring fixture
-    functions.
-
-"Funcargs" a prime example of dependency injection
+Fixtures: a prime example of dependency injection
 ---------------------------------------------------
 
-When injecting fixtures to test functions, pytest-2.0 introduced the
-term "funcargs" or "funcarg mechanism" which continues to be present
-also in docs today.  It now refers to the specific case of injecting
-fixture values as arguments to test functions.  With pytest-2.3 there are
-more possibilities to use fixtures but "funcargs" remain as the main way
-as they allow to directly state the dependencies of a test function.
-
-As the following examples show in more detail, funcargs allow test
-functions to easily receive and work against specific pre-initialized
-application objects without having to care about import/setup/cleanup
-details.  It's a prime example of `dependency injection`_ where fixture
+Fixtures allow test functions to easily receive and work
+against specific pre-initialized application objects without having
+to care about import/setup/cleanup details.
+It's a prime example of `dependency injection`_ where fixture
 functions take the role of the *injector* and test functions are the
 *consumers* of fixture objects.
 
+.. _`conftest.py`:
+.. _`conftest`:
+
+``conftest.py``: sharing fixture functions
+------------------------------------------
+
+If during implementing your tests you realize that you
+want to use a fixture function from multiple test files you can move it
+to a ``conftest.py`` file.
+You don't need to import the fixture you want to use in a test, it
+automatically gets discovered by pytest. The discovery of
+fixture functions starts at test classes, then test modules, then
+``conftest.py`` files and finally builtin and third party plugins.
+
+You can also use the ``conftest.py`` file to implement 
+:ref:`local per-directory plugins <conftest.py plugins>`.
+
+Sharing test data
+-----------------
+
+If you want to make test data from files available to your tests, a good way
+to do this is by loading these data in a fixture for use by your tests.
+This makes use of the automatic caching mechanisms of pytest.
+
+Another good approach is by adding the data files in the ``tests`` folder.
+There are also community plugins available to help managing this aspect of 
+testing, e.g. `pytest-datadir <https://github.com/gabrielcnr/pytest-datadir>`__ 
+and `pytest-datafiles <https://pypi.python.org/pypi/pytest-datafiles>`__. 
+
 .. _smtpshared:
 
-Sharing a fixture across tests in a module (or class/session)
------------------------------------------------------------------
+Scope: sharing a fixture instance across tests in a class, module or session
+----------------------------------------------------------------------------
 
 .. regendoc:wipe
 
@@ -152,10 +168,12 @@ usually time-expensive to create.  Extending the previous example, we
 can add a ``scope='module'`` parameter to the
 :py:func:`@pytest.fixture <_pytest.python.fixture>` invocation
 to cause the decorated ``smtp`` fixture function to only be invoked once
-per test module.  Multiple test functions in a test module will thus
-each receive the same ``smtp`` fixture instance.  The next example puts
-the fixture function into a separate ``conftest.py`` file so
-that tests from multiple test modules in the directory can
+per test *module* (the default is to invoke once per test *function*).
+Multiple test functions in a test module will thus
+each receive the same ``smtp`` fixture instance, thus saving time.
+
+The next example puts the fixture function into a separate ``conftest.py`` file 
+so that tests from multiple test modules in the directory can
 access the fixture function::
 
     # content of conftest.py
@@ -164,7 +182,7 @@ access the fixture function::
 
     @pytest.fixture(scope="module")
     def smtp():
-        return smtplib.SMTP("smtp.gmail.com")
+        return smtplib.SMTP("smtp.gmail.com", 587, timeout=5)
 
 The name of the fixture again is ``smtp`` and you can access its result by
 listing the name ``smtp`` as an input parameter in any test or fixture
@@ -176,7 +194,7 @@ function (in or below the directory where ``conftest.py`` is located)::
         response, msg = smtp.ehlo()
         assert response == 250
         assert b"smtp.gmail.com" in msg
-        assert 0  # for demo purposes   
+        assert 0  # for demo purposes
 
     def test_noop(smtp):
         response, msg = smtp.noop()
@@ -236,6 +254,8 @@ instance, you can simply declare it:
         # the returned fixture value will be shared for
         # all tests needing it
 
+Finally, the ``class`` scope will invoke the fixture once per test *class*.
+
 .. _`finalization`:
 
 Fixture finalization / executing teardown code
@@ -254,7 +274,7 @@ the code after the *yield* statement serves as the teardown code:
 
     @pytest.fixture(scope="module")
     def smtp():
-        smtp = smtplib.SMTP("smtp.gmail.com")
+        smtp = smtplib.SMTP("smtp.gmail.com", 587, timeout=5)
         yield smtp  # provide the fixture value
         print("teardown smtp")
         smtp.close()
@@ -288,7 +308,7 @@ Note that we can also seamlessly use the ``yield`` syntax with ``with`` statemen
 
     @pytest.fixture(scope="module")
     def smtp():
-        with smtplib.SMTP("smtp.gmail.com") as smtp:
+        with smtplib.SMTP("smtp.gmail.com", 587, timeout=5) as smtp:
             yield smtp  # provide the fixture value
 
 
@@ -296,36 +316,53 @@ The ``smtp`` connection will be closed after the test finished execution
 because the ``smtp`` object automatically closes when
 the ``with`` statement ends.
 
+Note that if an exception happens during the *setup* code (before the ``yield`` keyword), the
+*teardown* code (after the ``yield``) will not be called.
 
-.. note::
-    Prior to version 2.10, in order to use a ``yield`` statement to execute teardown code one
-    had to mark a fixture using the ``yield_fixture`` marker. From 2.10 onward, normal
-    fixtures can use ``yield`` directly so the ``yield_fixture`` decorator is no longer needed
-    and considered deprecated.
+An alternative option for executing *teardown* code is to
+make use of the ``addfinalizer`` method of the `request-context`_ object to register
+finalization functions.
 
-.. note::
-    As historical note, another way to write teardown code is
-    by accepting a ``request`` object into your fixture function and can call its
-    ``request.addfinalizer`` one or multiple times::
+Here's the ``smtp`` fixture changed to use ``addfinalizer`` for cleanup:
 
-        # content of conftest.py
+.. code-block:: python
 
-        import smtplib
-        import pytest
+    # content of conftest.py
+    import smtplib
+    import pytest
 
-        @pytest.fixture(scope="module")
-        def smtp(request):
-            smtp = smtplib.SMTP("smtp.gmail.com")
-            def fin():
-                print ("teardown smtp")
-                smtp.close()
-            request.addfinalizer(fin)
-            return smtp  # provide the fixture value
+    @pytest.fixture(scope="module")
+    def smtp(request):
+        smtp = smtplib.SMTP("smtp.gmail.com", 587, timeout=5)
+        def fin():
+            print ("teardown smtp")
+            smtp.close()
+        request.addfinalizer(fin)
+        return smtp  # provide the fixture value
 
-    The ``fin`` function will execute when the last test in the module has finished execution.
 
-    This method is still fully supported, but ``yield`` is recommended from 2.10 onward because
-    it is considered simpler and better describes the natural code flow.
+Both ``yield`` and ``addfinalizer`` methods work similarly by calling their code after the test
+ends, but ``addfinalizer`` has two key differences over ``yield``:
+
+1. It is possible to register multiple finalizer functions.
+
+2. Finalizers will always be called regardless if the fixture *setup* code raises an exception.
+   This is handy to properly close all resources created by a fixture even if one of them
+   fails to be created/acquired::
+
+        @pytest.fixture
+        def equipments(request):
+            r = []
+            for port in ('C1', 'C3', 'C28'):
+                equip = connect(port)
+                request.addfinalizer(equip.disconnect)
+                r.append(equip)
+            return r
+
+   In the example above, if ``"C28"`` fails with an exception, ``"C1"`` and ``"C3"`` will still
+   be properly closed. Of course, if an exception happens before the finalize function is
+   registered then it will not be executed.
+
 
 .. _`request-context`:
 
@@ -344,7 +381,7 @@ read an optional server URL from the test module which uses our fixture::
     @pytest.fixture(scope="module")
     def smtp(request):
         server = getattr(request.module, "smtpserver", "smtp.gmail.com")
-        smtp = smtplib.SMTP(server)
+        smtp = smtplib.SMTP(server, 587, timeout=5)
         yield smtp
         print ("finalizing %s (%s)" % (smtp, server))
         smtp.close()
@@ -408,7 +445,7 @@ through the special :py:class:`request <FixtureRequest>` object::
     @pytest.fixture(scope="module",
                     params=["smtp.gmail.com", "mail.python.org"])
     def smtp(request):
-        smtp = smtplib.SMTP(request.param)
+        smtp = smtplib.SMTP(request.param, 587, timeout=5)
         yield smtp
         print ("finalizing %s" % smtp)
         smtp.close()
@@ -453,7 +490,7 @@ So let's just do another run::
             response, msg = smtp.ehlo()
             assert response == 250
     >       assert b"smtp.gmail.com" in msg
-    E       AssertionError: assert b'smtp.gmail.com' in b'mail.python.org\nSIZE 51200000\nETRN\nSTARTTLS\nENHANCEDSTATUSCODES\n8BITMIME\nDSN\nSMTPUTF8'
+    E       AssertionError: assert b'smtp.gmail.com' in b'mail.python.org\nPIPELINING\nSIZE 51200000\nETRN\nSTARTTLS\nAUTH DIGEST-MD5 NTLM CRAM-MD5\nENHANCEDSTATUSCODES\n8BITMIME\nDSN\nSMTPUTF8'
     
     test_module.py:5: AssertionError
     -------------------------- Captured stdout setup ---------------------------
@@ -782,8 +819,8 @@ Autouse fixtures (xUnit setup on steroids)
 .. regendoc:wipe
 
 Occasionally, you may want to have fixtures get invoked automatically
-without a `usefixtures`_ or `funcargs`_ reference.   As a practical
-example, suppose we have a database fixture which has a
+without declaring a function argument explicitly or a `usefixtures`_ decorator.
+As a practical example, suppose we have a database fixture which has a
 begin/rollback/commit architecture and we want to automatically surround
 each test method by a transaction and a rollback.  Here is a dummy
 self-contained implementation of this idea::
@@ -854,7 +891,7 @@ into a conftest.py file **without** using ``autouse``::
 
     # content of conftest.py
     @pytest.fixture
-    def transact(self, request, db):
+    def transact(request, db):
         db.begin()
         yield
         db.rollback()
@@ -870,17 +907,6 @@ All test methods in this TestClass will use the transaction fixture while
 other test classes or functions in the module will not use it unless
 they also add a ``transact`` reference.
 
-
-Shifting (visibility of) fixture functions
-----------------------------------------------------
-
-If during implementing your tests you realize that you
-want to use a fixture function from multiple test files you can move it
-to a :ref:`conftest.py <conftest.py>` file or even separately installable
-:ref:`plugins <plugins>` without changing test code.  The discovery of
-fixtures functions starts at test classes, then test modules, then
-``conftest.py`` files and finally builtin and third party plugins.
-
 Overriding fixtures on various levels
 -------------------------------------
 

doc/en/getting-started.rst

@@ -1,7 +1,7 @@
 Installation and Getting Started
 ===================================
 
-**Pythons**: Python 2.6,2.7,3.3,3.4,3.5, Jython, PyPy-2.3
+**Pythons**: Python 2.6,2.7,3.3,3.4,3.5,3.6 Jython, PyPy-2.3
 
 **Platforms**: Unix/Posix and Windows
 
@@ -9,7 +9,8 @@ Installation and Getting Started
 
 **dependencies**: `py <http://pypi.python.org/pypi/py>`_,
 `colorama (Windows) <http://pypi.python.org/pypi/colorama>`_,
-`argparse (py26) <http://pypi.python.org/pypi/argparse>`_.
+`argparse (py26) <http://pypi.python.org/pypi/argparse>`_,
+`ordereddict (py26) <http://pypi.python.org/pypi/ordereddict>`_.
 
 **documentation as PDF**: `download latest <https://media.readthedocs.org/pdf/pytest/latest/pytest.pdf>`_
 
@@ -48,7 +49,7 @@ That's it. You can execute the test function now::
     ======= test session starts ========
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
     rootdir: $REGENDOC_TMPDIR, inifile:
-    collected 1 items
+    collected 1 item
     
     test_sample.py F
     

doc/en/goodpractices.rst

@@ -122,7 +122,7 @@ want to distribute them along with your application::
             test_view.py
             ...
 
-In this scheme, it is easy to your run tests using the ``--pyargs`` option::
+In this scheme, it is easy to run your tests using the ``--pyargs`` option::
 
     pytest --pyargs mypkg
 
@@ -249,15 +249,6 @@ by putting them into a ``[tool:pytest]`` section:
     python_files = testing/*/*.py
 
 
-.. note::
-    Prior to 3.0, the supported section name was ``[pytest]``. Due to how
-    this may collide with some distutils commands, the recommended
-    section name for ``setup.cfg`` files is now ``[tool:pytest]``.
-
-    Note that for ``pytest.ini`` and ``tox.ini`` files the section
-    name is ``[pytest]``.
-
-
 Manual Integration
 ^^^^^^^^^^^^^^^^^^
 
@@ -276,7 +267,7 @@ your own setuptools Test command for invoking pytest.
 
         def initialize_options(self):
             TestCommand.initialize_options(self)
-            self.pytest_args = []
+            self.pytest_args = ''
 
         def run_tests(self):
             import shlex

doc/en/historical-notes.rst

@@ -0,0 +1,177 @@
+Historical Notes
+================
+
+This page lists features or behavior from previous versions of pytest which have changed over the years. They are
+kept here as a historical note so users looking at old code can find documentation related to them.
+
+cache plugin integrated into the core
+-------------------------------------
+
+.. versionadded:: 2.8
+
+The functionality of the :ref:`core cache <cache>` plugin was previously distributed
+as a third party plugin named ``pytest-cache``.  The core plugin
+is compatible regarding command line options and API usage except that you
+can only store/receive data between test runs that is json-serializable.
+
+
+funcargs and ``pytest_funcarg__``
+---------------------------------
+
+.. versionchanged:: 2.3
+
+In versions prior to 2.3 there was no ``@pytest.fixture`` marker
+and you had to use a magic ``pytest_funcarg__NAME`` prefix
+for the fixture factory.  This remains and will remain supported
+but is not anymore advertised as the primary means of declaring fixture
+functions.
+
+
+``@pytest.yield_fixture`` decorator
+-----------------------------------
+
+.. versionchanged:: 2.10
+
+Prior to version 2.10, in order to use a ``yield`` statement to execute teardown code one
+had to mark a fixture using the ``yield_fixture`` marker. From 2.10 onward, normal
+fixtures can use ``yield`` directly so the ``yield_fixture`` decorator is no longer needed
+and considered deprecated.
+
+
+``[pytest]`` header in ``setup.cfg``
+------------------------------------
+
+.. versionchanged:: 3.0
+
+Prior to 3.0, the supported section name was ``[pytest]``. Due to how
+this may collide with some distutils commands, the recommended
+section name for ``setup.cfg`` files is now ``[tool:pytest]``.
+
+Note that for ``pytest.ini`` and ``tox.ini`` files the section
+name is ``[pytest]``.
+
+
+Applying marks to ``@pytest.mark.parametrize`` parameters
+---------------------------------------------------------
+
+.. versionchanged:: 3.1
+
+Prior to version 3.1 the supported mechanism for marking values
+used the syntax::
+
+    import pytest
+    @pytest.mark.parametrize("test_input,expected", [
+        ("3+5", 8),
+        ("2+4", 6),
+        pytest.mark.xfail(("6*9", 42),),
+    ])
+    def test_eval(test_input, expected):
+        assert eval(test_input) == expected
+
+
+This was an initial hack to support the feature but soon was demonstrated to be incomplete,
+broken for passing functions or applying multiple marks with the same name but different parameters.
+
+The old syntax is planned to be removed in pytest-4.0.
+
+
+``@pytest.mark.parametrize`` argument names as a tuple
+------------------------------------------------------
+
+.. versionchanged:: 2.4
+
+In versions prior to 2.4 one needed to specify the argument
+names as a tuple.  This remains valid but the simpler ``"name1,name2,..."``
+comma-separated-string syntax is now advertised first because
+it's easier to write and produces less line noise.
+
+
+setup: is now an "autouse fixture"
+----------------------------------
+
+.. versionchanged:: 2.3
+
+During development prior to the pytest-2.3 release the name
+``pytest.setup`` was used but before the release it was renamed
+and moved to become part of the general fixture mechanism,
+namely :ref:`autouse fixtures`
+
+
+.. _string conditions:
+
+Conditions as strings instead of booleans
+-----------------------------------------
+
+.. versionchanged:: 2.4
+
+Prior to pytest-2.4 the only way to specify skipif/xfail conditions was
+to use strings::
+
+    import sys
+    @pytest.mark.skipif("sys.version_info >= (3,3)")
+    def test_function():
+        ...
+
+During test function setup the skipif condition is evaluated by calling
+``eval('sys.version_info >= (3,0)', namespace)``.  The namespace contains
+all the module globals, and ``os`` and ``sys`` as a minimum.
+
+Since pytest-2.4 :ref:`boolean conditions <condition booleans>` are considered preferable
+because markers can then be freely imported between test modules.
+With strings you need to import not only the marker but all variables
+used by the marker, which violates encapsulation.
+
+The reason for specifying the condition as a string was that ``pytest`` can
+report a summary of skip conditions based purely on the condition string.
+With conditions as booleans you are required to specify a ``reason`` string.
+
+Note that string conditions will remain fully supported and you are free
+to use them if you have no need for cross-importing markers.
+
+The evaluation of a condition string in ``pytest.mark.skipif(conditionstring)``
+or ``pytest.mark.xfail(conditionstring)`` takes place in a namespace
+dictionary which is constructed as follows:
+
+* the namespace is initialized by putting the ``sys`` and ``os`` modules
+  and the pytest ``config`` object into it.
+
+* updated with the module globals of the test function for which the
+  expression is applied.
+
+The pytest ``config`` object allows you to skip based on a test
+configuration value which you might have added::
+
+    @pytest.mark.skipif("not config.getvalue('db')")
+    def test_function(...):
+        ...
+
+The equivalent with "boolean conditions" is::
+
+    @pytest.mark.skipif(not pytest.config.getvalue("db"),
+                        reason="--db was not specified")
+    def test_function(...):
+        pass
+
+.. note::
+
+    You cannot use ``pytest.config.getvalue()`` in code
+    imported before pytest's argument parsing takes place.  For example,
+    ``conftest.py`` files are imported before command line parsing and thus
+    ``config.getvalue()`` will not execute correctly.
+
+``pytest.set_trace()``
+----------------------
+
+.. versionchanged:: 2.4
+
+Previous to version 2.4 to set a break point in code one needed to use ``pytest.set_trace()``::
+
+    import pytest
+    def test_function():
+        ...
+        pytest.set_trace()    # invoke PDB debugger and tracing
+
+
+This is no longer needed and one can use the native ``import pdb;pdb.set_trace()`` call directly.
+
+For more details see :ref:`breakpoints`.

doc/en/index.rst

@@ -27,7 +27,7 @@ To execute it::
     ======= test session starts ========
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
     rootdir: $REGENDOC_TMPDIR, inifile:
-    collected 1 items
+    collected 1 item
     
     test_sample.py F
     
@@ -59,7 +59,7 @@ Features
 
 - Python2.6+, Python3.3+, PyPy-2.3, Jython-2.5 (untested);
 
-- Rich plugin architecture, with over 150+ :ref:`external plugins <extplugins>` and thriving community;
+- Rich plugin architecture, with over 315+ `external plugins <http://plugincompat.herokuapp.com>`_ and thriving community;
 
 
 Documentation
@@ -83,8 +83,8 @@ Consult the :ref:`Changelog <changelog>` page for fixes and enhancements of each
 License
 -------
 
-Copyright Holger Krekel and others, 2004-2016.
+Copyright Holger Krekel and others, 2004-2017.
 
 Distributed under the terms of the `MIT`_ license, pytest is free and open source software.
 
-.. _`MIT`: https://github.com/pytest-dev/pytest/blob/master/LICENSE
+.. _`MIT`: https://github.com/pytest-dev/pytest/blob/master/LICENSE

doc/en/license.rst

@@ -9,7 +9,7 @@ Distributed under the terms of the `MIT`_ license, pytest is free and open sourc
 
     The MIT License (MIT)
 
-    Copyright (c) 2004-2016 Holger Krekel and others
+    Copyright (c) 2004-2017 Holger Krekel and others
 
     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

doc/en/mark.rst

@@ -10,6 +10,7 @@ By using the ``pytest.mark`` helper you can easily set
 metadata on your test functions. There are
 some builtin markers, for example:
 
+* :ref:`skip <skip>` - always skip a test function
 * :ref:`skipif <skipif>` - skip a test function if a certain condition is met
 * :ref:`xfail <xfail>` - produce an "expected failure" outcome if a certain
   condition is met

doc/en/nose.rst

@@ -26,7 +26,7 @@ Supported nose Idioms
 * setup and teardown at module/class/method level
 * SkipTest exceptions and markers
 * setup/teardown decorators
-* ``yield``-based tests and their setup
+* ``yield``-based tests and their setup (considered deprecated as of pytest 3.0)
 * ``__test__`` attribute on modules/classes/functions
 * general usage of nose utilities
 

doc/en/parametrize.rst

@@ -99,26 +99,6 @@ for example with the builtin ``mark.xfail``::
     def test_eval(test_input, expected):
         assert eval(test_input) == expected
 
-.. note::
-
-  prior to version 3.1 the supported mechanism for marking values
-  used the syntax::
-
-        import pytest
-        @pytest.mark.parametrize("test_input,expected", [
-            ("3+5", 8),
-            ("2+4", 6),
-            pytest.mark.xfail(("6*9", 42),),
-        ])
-        def test_eval(test_input, expected):
-            assert eval(test_input) == expected
-
-
-  This was an initial hack to support the feature but soon was demonstrated to be incomplete,
-  broken for passing functions or applying multiple marks with the same name but different parameters.
-  The old syntax will be removed in pytest-4.0.
-
-
 Let's run this::
 
     $ pytest
@@ -143,15 +123,8 @@ To get all combinations of multiple parametrized arguments you can stack
     def test_foo(x, y):
         pass
 
-This will run the test with the arguments set to x=0/y=2, x=0/y=3, x=1/y=2 and
-x=1/y=3.
-
-.. note::
-
-    In versions prior to 2.4 one needed to specify the argument
-    names as a tuple.  This remains valid but the simpler ``"name1,name2,..."``
-    comma-separated-string syntax is now advertised first because
-    it's easier to write and produces less line noise.
+This will run the test with the arguments set to ``x=0/y=2``, ``x=0/y=3``, ``x=1/y=2`` and
+``x=1/y=3``.
 
 .. _`pytest_generate_tests`:
 
@@ -187,7 +160,7 @@ command line option and the parametrization of our test function::
     def pytest_generate_tests(metafunc):
         if 'stringinput' in metafunc.fixturenames:
             metafunc.parametrize("stringinput",
-                                 metafunc.config.option.stringinput)
+                                 metafunc.config.getoption('stringinput'))
 
 If we now pass two stringinput values, our test will run twice::
 
@@ -222,9 +195,15 @@ list::
     $ pytest -q -rs test_strings.py
     s
     ======= short test summary info ========
-    SKIP [1] test_strings.py:1: got empty parameter set ['stringinput'], function test_valid_string at $REGENDOC_TMPDIR/test_strings.py:1
+    SKIP [1] test_strings.py:2: got empty parameter set ['stringinput'], function test_valid_string at $REGENDOC_TMPDIR/test_strings.py:1
     1 skipped in 0.12 seconds
 
+Note that when calling ``metafunc.parametrize`` multiple times with different parameter sets, all parameter names across 
+those sets cannot be duplicated, otherwise an error will be raised.
+
+More examples
+-------------
+
 For further examples, you might want to look at :ref:`more
 parametrization examples <paramexamples>`.
 

doc/en/plugins.rst

@@ -94,7 +94,7 @@ environment you can type::
 
 and will get an extended test header which shows activated plugins
 and their names. It will also print local plugins aka
-:ref:`conftest.py <conftest>` files when they are loaded.
+:ref:`conftest.py <conftest.py plugins>` files when they are loaded.
 
 .. _`cmdunregister`:
 
@@ -155,4 +155,3 @@ in the `pytest repository <https://github.com/pytest-dev/pytest>`_.
     _pytest.terminal
     _pytest.tmpdir
     _pytest.unittest
-

doc/en/proposals/parametrize_with_fixtures.rst

@@ -1,8 +1,13 @@
 :orphan:
 
-=========================
-Parametrize with fixtures
-=========================
+===================================
+PROPOSAL: Parametrize with fixtures
+===================================
+
+.. warning::
+
+    This document outlines a proposal around using fixtures as input
+    of parametrized tests or fixtures.
 
 Problem
 -------
@@ -108,8 +113,13 @@ the following values.
 Alternative approach
 --------------------
 
-A new helper function named ``fixture_request`` tells pytest to yield all
-parameters of a fixture.
+A new helper function named ``fixture_request`` would tell pytest to yield
+all parameters marked as a fixture.
+
+.. note::
+
+    The `pytest-lazy-fixture <https://pypi.python.org/pypi/pytest-lazy-fixture>`_ plugin implements a very
+    similar solution to the proposal below, make sure to check it out.
 
 .. code-block:: python
 

doc/en/pythonpath.rst

@@ -0,0 +1,76 @@
+.. _pythonpath:
+
+pytest import mechanisms and ``sys.path``/``PYTHONPATH``
+========================================================
+
+Here's a list of scenarios where pytest may need to change ``sys.path`` in order
+to import test modules or ``conftest.py`` files.
+
+Test modules / ``conftest.py`` files inside packages
+----------------------------------------------------
+
+Consider this file and directory layout::
+
+    root/
+    |- foo/
+       |- __init__.py
+       |- conftest.py
+       |- bar/
+          |- __init__.py
+          |- tests/
+             |- __init__.py
+             |- test_foo.py
+
+
+When executing::
+
+    pytest root/
+
+
+
+pytest will find ``foo/bar/tests/test_foo.py`` and realize it is part of a package given that
+there's an ``__init__.py`` file in the same folder. It will then search upwards until it can find the
+last folder which still contains an ``__init__.py`` file in order to find the package *root* (in
+this case ``foo/``). To load the module, it will insert ``root/``  to the front of
+``sys.path`` (if not there already) in order to load
+``test_foo.py`` as the *module* ``foo.bar.tests.test_foo``.
+
+The same logic applies to the ``conftest.py`` file: it will be imported as ``foo.conftest`` module.
+
+Preserving the full package name is important when tests live in a package to avoid problems
+and allow test modules to have duplicated names. This is also discussed in details in
+:ref:`test discovery`.
+
+Standalone test modules / ``conftest.py`` files
+-----------------------------------------------
+
+Consider this file and directory layout::
+
+    root/
+    |- foo/
+       |- conftest.py
+       |- bar/
+          |- tests/
+             |- test_foo.py
+
+
+When executing::
+
+    pytest root/
+
+pytest will find ``foo/bar/tests/test_foo.py`` and realize it is NOT part of a package given that
+there's no ``__init__.py`` file in the same folder. It will then add ``root/foo/bar/tests`` to
+``sys.path`` in order to import ``test_foo.py`` as the *module* ``test_foo``. The same is done
+with the ``conftest.py`` file by adding ``root/foo`` to ``sys.path`` to import it as ``conftest``.
+
+For this reason this layout cannot have test modules with the same name, as they all will be
+imported in the global import namespace.
+
+This is also discussed in details in :ref:`test discovery`.
+
+Invoking ``pytest`` versus ``python -m pytest``
+-----------------------------------------------
+
+Running pytest with ``python -m pytest [...]`` instead of ``pytest [...]`` yields nearly
+equivalent behaviour, except that the former call will add the current directory to ``sys.path``.
+See also :ref:`cmdline`.

doc/en/setup.rst

@@ -1,10 +0,0 @@
-
-setup: is now an "autouse fixture"
-========================================================
-
-During development prior to the pytest-2.3 release the name
-``pytest.setup`` was used but before the release it was renamed
-and moved to become part of the general fixture mechanism,
-namely :ref:`autouse fixtures`
-
-

doc/en/skipping.rst

@@ -3,7 +3,7 @@
 .. _skipping:
 
 Skip and xfail: dealing with tests that cannot succeed
-=====================================================================
+======================================================
 
 You can mark test functions that cannot be run on certain platforms
 or that you expect to fail so pytest can deal with them accordingly and
@@ -16,17 +16,22 @@ resource which is not available at the moment (for example a database).
 
 A **xfail** means that you expect a test to fail for some reason.
 A common example is a test for a feature not yet implemented, or a bug not yet fixed.
+When a test passes despite being expected to fail (marked with ``pytest.mark.xfail``),
+it's an **xpass** and will be reported in the test summary.
 
 ``pytest`` counts and lists *skip* and *xfail* tests separately. Detailed
 information about skipped/xfailed tests is not shown by default to avoid
 cluttering the output.  You can use the ``-r`` option to see details
 corresponding to the "short" letters shown in the test progress::
 
-    pytest -rxs  # show extra info on skips and xfails
+    pytest -rxXs  # show extra info on xfailed, xpassed, and skipped tests
+
+More details on the ``-r`` option can be found by running ``pytest -h``.
 
 (See :ref:`how to change command line options defaults`)
 
 .. _skipif:
+.. _skip:
 .. _`condition booleans`:
 
 Skipping test functions
@@ -53,7 +58,7 @@ by calling the ``pytest.skip(reason)`` function:
         if not valid_config():
             pytest.skip("unsupported configuration")
 
-The imperative method is useful when it is not possible to evaluate the skip condition 
+The imperative method is useful when it is not possible to evaluate the skip condition
 during import time.
 
 ``skipif``
@@ -72,7 +77,7 @@ when run on a Python3.3 interpreter::
         ...
 
 If the condition evaluates to ``True`` during collection, the test function will be skipped,
-with the specified reason appearing in the summary when using ``-rs``.  
+with the specified reason appearing in the summary when using ``-rs``.
 
 You can share ``skipif`` markers between modules.  Consider this test module::
 
@@ -117,6 +122,12 @@ You can use the ``skipif`` marker (as any other marker) on classes::
 If the condition is ``True``, this marker will produce a skip result for
 each of the test methods of that class.
 
+.. warning::
+
+   The use of ``skipif`` on classes that use inheritance is strongly
+   discouraged. `A Known bug <https://github.com/pytest-dev/pytest/issues/568>`_
+   in pytest's markers may cause unexpected behavior in super classes.
+
 If you want to skip all test functions of a module, you may use
 the ``pytestmark`` name on the global level:
 
@@ -131,6 +142,16 @@ will be skipped if any of the skip conditions is true.
 .. _`whole class- or module level`: mark.html#scoped-marking
 
 
+Skipping files or directories
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Sometimes you may need to skip an entire file or directory, for example if the
+tests rely on Python version-specific features or contain code that you do not
+wish pytest to run. In this case, you must exclude the files and directories
+from collection. Refer to :ref:`customizing-test-collection` for more
+information.
+
+
 Skipping on a missing import dependency
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -345,66 +366,3 @@ test instances when using parametrize:
     ])
     def test_increment(n, expected):
         assert n + 1 == expected
-
-
-.. _string conditions:
-
-Conditions as strings instead of booleans
------------------------------------------
-
-Prior to pytest-2.4 the only way to specify skipif/xfail conditions was
-to use strings::
-
-    import sys
-    @pytest.mark.skipif("sys.version_info >= (3,3)")
-    def test_function():
-        ...
-
-During test function setup the skipif condition is evaluated by calling
-``eval('sys.version_info >= (3,0)', namespace)``.  The namespace contains
-all the module globals, and ``os`` and ``sys`` as a minimum.
-
-Since pytest-2.4 `condition booleans`_ are considered preferable
-because markers can then be freely imported between test modules.
-With strings you need to import not only the marker but all variables
-used by the marker, which violates encapsulation.
-
-The reason for specifying the condition as a string was that ``pytest`` can
-report a summary of skip conditions based purely on the condition string.
-With conditions as booleans you are required to specify a ``reason`` string.
-
-Note that string conditions will remain fully supported and you are free
-to use them if you have no need for cross-importing markers.
-
-The evaluation of a condition string in ``pytest.mark.skipif(conditionstring)``
-or ``pytest.mark.xfail(conditionstring)`` takes place in a namespace
-dictionary which is constructed as follows:
-
-* the namespace is initialized by putting the ``sys`` and ``os`` modules
-  and the pytest ``config`` object into it.
-
-* updated with the module globals of the test function for which the
-  expression is applied.
-
-The pytest ``config`` object allows you to skip based on a test
-configuration value which you might have added::
-
-    @pytest.mark.skipif("not config.getvalue('db')")
-    def test_function(...):
-        ...
-
-The equivalent with "boolean conditions" is::
-
-    @pytest.mark.skipif(not pytest.config.getvalue("db"),
-                        reason="--db was not specified")
-    def test_function(...):
-        pass
-
-.. note::
-
-    You cannot use ``pytest.config.getvalue()`` in code
-    imported before pytest's argument parsing takes place.  For example,
-    ``conftest.py`` files are imported before command line parsing and thus
-    ``config.getvalue()`` will not execute correctly.
-
-

doc/en/tmpdir.rst

@@ -31,7 +31,7 @@ Running this would result in a passed test except for the last
     ======= test session starts ========
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
     rootdir: $REGENDOC_TMPDIR, inifile:
-    collected 1 items
+    collected 1 item
     
     test_tmpdir.py F
     

doc/en/unittest.rst

@@ -2,58 +2,77 @@
 .. _`unittest.TestCase`:
 .. _`unittest`:
 
-Support for unittest.TestCase / Integration of fixtures
-=====================================================================
+unittest.TestCase Support
+=========================
 
-.. _`unittest.py style`: http://docs.python.org/library/unittest.html
+``pytest`` supports running Python ``unittest``-based tests out of the box.
+It's meant for leveraging existing ``unittest``-based test suites
+to use pytest as a test runner and also allow to incrementally adapt
+the test suite to take full advantage of pytest's features.
 
-``pytest`` has support for running Python `unittest.py style`_ tests.
-It's meant for leveraging existing unittest-style projects
-to use pytest features.  Concretely, pytest will automatically 
-collect ``unittest.TestCase`` subclasses and their ``test`` methods in
-test files.  It will invoke typical setup/teardown methods and 
-generally try to make test suites written to run on unittest, to also 
-run using ``pytest``.  We assume here that you are familiar with writing
-``unittest.TestCase`` style tests and rather focus on 
-integration aspects.
+To run an existing ``unittest``-style test suite using ``pytest``, type::
 
-Note that this is meant as a provisional way of running your test code 
-until you fully convert to pytest-style tests. To fully take advantage of
-:ref:`fixtures <fixture>`, :ref:`parametrization <parametrize>` and 
-:ref:`hooks <writing-plugins>` you should convert (tools like `unittest2pytest 
-<https://pypi.python.org/pypi/unittest2pytest/>`__ are helpful). 
-Also, not all 3rd party pluging are expected to work best with 
-``unittest.TestCase`` style tests.
+    pytest tests
 
-Usage
--------------------------------------------------------------------
 
-After :ref:`installation` type::
+pytest will automatically collect ``unittest.TestCase`` subclasses and
+their ``test`` methods in ``test_*.py`` or ``*_test.py`` files.
 
-    pytest
+Almost all ``unittest`` features are supported:
 
-and you should be able to run your unittest-style tests if they
-are contained in ``test_*`` modules.  If that works for you then
-you can make use of most :ref:`pytest features <features>`, for example
-``--pdb`` debugging in failures, using :ref:`plain assert-statements <assert>`,
-:ref:`more informative tracebacks <tbreportdemo>`, stdout-capturing or 
-distributing tests to multiple CPUs via the ``-nNUM`` option if you 
-installed the ``pytest-xdist`` plugin.  Please refer to
-the general ``pytest`` documentation for many more examples.
+* ``@unittest.skip`` style decorators;
+* ``setUp/tearDown``;
+* ``setUpClass/tearDownClass()``;
 
-.. note::
+.. _`load_tests protocol`: https://docs.python.org/3/library/unittest.html#load-tests-protocol
+.. _`setUpModule/tearDownModule`: https://docs.python.org/3/library/unittest.html#setupmodule-and-teardownmodule
+.. _`subtests`: https://docs.python.org/3/library/unittest.html#distinguishing-test-iterations-using-subtests
 
-    Running tests from ``unittest.TestCase`` subclasses with ``--pdb`` will
-    disable tearDown and cleanup methods for the case that an Exception
-    occurs. This allows proper post mortem debugging for all applications
-    which have significant logic in their tearDown machinery. However,
-    supporting this feature has the following side effect: If people
-    overwrite ``unittest.TestCase`` ``__call__`` or ``run``, they need to 
-    to overwrite ``debug`` in the same way  (this is also true for standard
-    unittest).
+Up to this point pytest does not have support for the following features:
 
-Mixing pytest fixtures into unittest.TestCase style tests
------------------------------------------------------------
+* `load_tests protocol`_;
+* `setUpModule/tearDownModule`_;
+* `subtests`_;
+
+Benefits out of the box
+-----------------------
+
+By running your test suite with pytest you can make use of several features,
+in most cases without having to modify existing code:
+
+* Obtain :ref:`more informative tracebacks <tbreportdemo>`;
+* :ref:`stdout and stderr <captures>` capturing;
+* :ref:`Test selection options <select-tests>` using ``-k`` and ``-m`` flags;
+* :ref:`maxfail`;
+* :ref:`--pdb <pdb-option>` command-line option for debugging on test failures
+  (see :ref:`note <pdb-unittest-note>` below);
+* Distribute tests to multiple CPUs using the `pytest-xdist <http://pypi.python.org/pypi/pytest-xdist>`_ plugin;
+* Use :ref:`plain assert-statements <assert>` instead of ``self.assert*`` functions (`unittest2pytest
+  <https://pypi.python.org/pypi/unittest2pytest/>`__ is immensely helpful in this);
+
+
+pytest features in ``unittest.TestCase`` subclasses
+---------------------------------------------------
+
+The following pytest features work in ``unittest.TestCase`` subclasses:
+
+* :ref:`Marks <mark>`: :ref:`skip <skip>`, :ref:`skipif <skipif>`, :ref:`xfail <xfail>`;
+* :ref:`Auto-use fixtures <mixing-fixtures>`;
+
+The following pytest features **do not** work, and probably
+never will due to different design philosophies:
+
+* :ref:`Fixtures <fixture>` (except for ``autouse`` fixtures, see :ref:`below <mixing-fixtures>`);
+* :ref:`Parametrization <parametrize>`;
+* :ref:`Custom hooks <writing-plugins>`;
+
+
+Third party plugins may or may not work well, depending on the plugin and the test suite.
+
+.. _mixing-fixtures:
+
+Mixing pytest fixtures into ``unittest.TestCase`` subclasses using marks
+------------------------------------------------------------------------
 
 Running your unittest with ``pytest`` allows you to use its
 :ref:`fixture mechanism <fixture>` with ``unittest.TestCase`` style
@@ -143,8 +162,8 @@ share the same ``self.db`` instance which was our intention
 when writing the class-scoped fixture function above.
 
 
-autouse fixtures and accessing other fixtures
--------------------------------------------------------------------
+Using autouse fixtures and accessing other fixtures
+---------------------------------------------------
 
 Although it's usually better to explicitly declare use of fixtures you need
 for a given test, you may sometimes want to have fixtures that are 
@@ -165,6 +184,7 @@ creation of a per-test temporary directory::
     import unittest
 
     class MyTest(unittest.TestCase):
+
         @pytest.fixture(autouse=True)
         def initdir(self, tmpdir):
             tmpdir.chdir() # change to pytest-provided temporary directory
@@ -191,12 +211,35 @@ was executed ahead of the ``test_method``.
 
 .. note::
 
-   While pytest supports receiving fixtures via :ref:`test function arguments <funcargs>` for non-unittest test methods, ``unittest.TestCase`` methods cannot directly receive fixture 
-   function arguments as implementing that is likely to inflict
+   ``unittest.TestCase`` methods cannot directly receive fixture
+   arguments as implementing that is likely to inflict
    on the ability to run general unittest.TestCase test suites.
-   Maybe optional support would be possible, though.  If unittest finally 
-   grows a plugin system that should help as well.  In the meanwhile, the 
-   above ``usefixtures`` and ``autouse`` examples should help to mix in 
-   pytest fixtures into unittest suites.  And of course you can also start
-   to selectively leave away the ``unittest.TestCase`` subclassing, use
-   plain asserts and get the unlimited pytest feature set.
+
+   The above ``usefixtures`` and ``autouse`` examples should help to mix in
+   pytest fixtures into unittest suites.
+
+   You can also gradually move away from subclassing from ``unittest.TestCase`` to *plain asserts*
+   and then start to benefit from the full pytest feature set step by step.
+
+.. _pdb-unittest-note:
+
+.. note::
+
+    Running tests from ``unittest.TestCase`` subclasses with ``--pdb`` will
+    disable tearDown and cleanup methods for the case that an Exception
+    occurs. This allows proper post mortem debugging for all applications
+    which have significant logic in their tearDown machinery. However,
+    supporting this feature has the following side effect: If people
+    overwrite ``unittest.TestCase`` ``__call__`` or ``run``, they need to
+    to overwrite ``debug`` in the same way  (this is also true for standard
+    unittest).
+
+.. note::
+
+    Due to architectural differences between the two frameworks, setup and
+    teardown for ``unittest``-based tests is performed during the ``call`` phase
+    of testing instead of in ``pytest``'s standard ``setup`` and ``teardown``
+    stages. This can be important to understand in some situations, particularly
+    when reasoning about errors. For example, if a ``unittest``-based suite
+    exhibits errors during setup, ``pytest`` will report no errors during its
+    ``setup`` phase and will instead raise the error during ``call``.

doc/en/usage.rst

@@ -17,7 +17,7 @@ You can invoke testing through the Python interpreter from the command line::
     python -m pytest [...]
 
 This is almost equivalent to invoking the command line script ``pytest [...]``
-directly, except that python will also add the current directory to ``sys.path``.
+directly, except that calling via ``python`` will also add the current directory to ``sys.path``.
 
 Possible exit codes
 --------------------------------------------------------------
@@ -41,6 +41,8 @@ Getting help on version, option names, environment variables
     pytest -h | --help # show help on command line and config file options
 
 
+.. _maxfail:
+
 Stopping after the first (or N) failures
 ---------------------------------------------------
 
@@ -49,26 +51,69 @@ To stop the testing process after the first (N) failures::
     pytest -x            # stop after first failure
     pytest --maxfail=2    # stop after two failures
 
+.. _select-tests:
+
 Specifying tests / selecting tests
 ---------------------------------------------------
 
-Several test run options::
+Pytest supports several ways to run and select tests from the command-line.
 
-    pytest test_mod.py   # run tests in module
-    pytest somepath      # run all tests below somepath
-    pytest -k stringexpr # only run tests with names that match the
-                          # "string expression", e.g. "MyClass and not method"
-                          # will select TestMyClass.test_something
-                          # but not TestMyClass.test_method_simple
-    pytest test_mod.py::test_func  # only run tests that match the "node ID",
-                                    # e.g. "test_mod.py::test_func" will select
-                                    # only test_func in test_mod.py
-    pytest test_mod.py::TestClass::test_method  # run a single method in
-                                                 # a single class
+**Run tests in a module**
 
-Import 'pkg' and use its filesystem location to find and run tests::
+::
 
-    pytest --pyargs pkg # run all tests found below directory of pkg
+    pytest test_mod.py
+
+**Run tests in a directory**
+
+::
+
+    pytest testing/
+
+**Run tests by keyword expressions**
+
+::
+
+    pytest -k "MyClass and not method"
+
+This will run tests which contain names that match the given *string expression*, which can
+include Python operators that use filenames, class names and function names as variables.
+The example above will run ``TestMyClass.test_something``  but not ``TestMyClass.test_method_simple``.
+
+.. _nodeids:
+
+**Run tests by node ids**
+
+Each collected test is assigned a unique ``nodeid`` which consist of the module filename followed
+by specifiers like class names, function names and parameters from parametrization, separated by ``::`` characters.
+
+To run a specific test within a module::
+
+    pytest test_mod.py::test_func
+
+
+Another example specifying a test method in the command line::
+
+    pytest test_mod.py::TestClass::test_method
+
+**Run tests by marker expressions**
+
+::
+
+    pytest -m slow
+
+Will run all tests which are decorated with the ``@pytest.mark.slow`` decorator.
+
+For more information see :ref:`marks <mark>`.
+
+**Run tests from packages**
+
+::
+
+    pytest --pyargs pkg.testing
+     
+This will import ``pkg.testing`` and use its filesystem location to find and run tests from.
+    
 
 Modifying Python traceback printing
 ----------------------------------------------
@@ -94,6 +139,9 @@ with Ctrl+C to find out where the tests are *hanging*. By default no output
 will be shown (because KeyboardInterrupt is caught by pytest). By using this
 option you make sure a trace is shown.
 
+
+.. _pdb-option:
+
 Dropping to PDB_ (Python Debugger) on failures
 -----------------------------------------------
 
@@ -123,22 +171,15 @@ for example::
     >>> sys.last_value
     AssertionError('assert result == "ok"',)
 
-Setting a breakpoint / aka ``set_trace()``
-----------------------------------------------------
+.. _breakpoints:
 
-If you want to set a breakpoint and enter the ``pdb.set_trace()`` you
-can use a helper::
+Setting breakpoints
+-------------------
 
-    import pytest
-    def test_function():
-        ...
-        pytest.set_trace()    # invoke PDB debugger and tracing
+.. versionadded: 2.4.0
 
-.. versionadded: 2.0.0
-
-Prior to pytest version 2.0.0 you could only enter PDB_ tracing if you disabled
-capturing on the command line via ``pytest -s``. In later versions, pytest
-automatically disables its output capture when you enter PDB_ tracing:
+To set a breakpoint in your code use the native Python ``import pdb;pdb.set_trace()`` call
+in your code and pytest automatically disables its output capture for that test:
 
 * Output capture in other tests is not affected.
 * Any prior test output that has already been captured and will be processed as
@@ -148,12 +189,6 @@ automatically disables its output capture when you enter PDB_ tracing:
   for test output occurring after you exit the interactive PDB_ tracing session
   and continue with the regular test run.
 
-.. versionadded: 2.4.0
-
-Since pytest version 2.4.0 you can also use the native Python
-``import pdb;pdb.set_trace()`` call to enter PDB_ tracing without having to use
-the ``pytest.set_trace()`` wrapper or explicitly disable pytest's output
-capturing via ``pytest -s``.
 
 .. _durations:
 
@@ -276,6 +311,13 @@ Creating resultlog format files
 
     This option is rarely used and is scheduled for removal in 4.0.
 
+    An alternative for users which still need similar functionality is to use the
+    `pytest-tap <https://pypi.python.org/pypi/pytest-tap>`_ plugin which provides
+    a stream of test data.
+
+    If you have any concerns, please don't hesitate to
+    `open an issue <https://github.com/pytest-dev/pytest/issues>`_.
+
 To create plain-text machine-readable result files you can issue::
 
     pytest --resultlog=path

doc/en/warnings.rst

@@ -24,7 +24,7 @@ Running pytest now produces this output::
     ======= test session starts ========
     platform linux -- Python 3.x.y, pytest-3.x.y, py-1.x.y, pluggy-0.x.y
     rootdir: $REGENDOC_TMPDIR, inifile:
-    collected 1 items
+    collected 1 item
     
     test_show_warnings.py .
     
@@ -78,6 +78,40 @@ Both ``-W`` command-line option and ``filterwarnings`` ini option are based on P
 `-W option`_ and `warnings.simplefilter`_, so please refer to those sections in the Python
 documentation for other examples and advanced usage.
 
+``@pytest.mark.filterwarnings``
+-------------------------------
+
+.. versionadded:: 3.2
+
+You can use the ``@pytest.mark.filterwarnings`` to add warning filters to specific test items,
+allowing you to have finer control of which warnings should be captured at test, class or
+even module level:
+
+.. code-block:: python
+
+    import warnings
+
+    def api_v1():
+        warnings.warn(UserWarning("api v1, should use functions from v2"))
+        return 1
+
+    @pytest.mark.filterwarnings('ignore:api v1')
+    def test_one():
+        assert api_v1() == 1
+
+
+Filters applied using a mark take precedence over filters passed on the command line or configured
+by the ``filterwarnings`` ini option.
+
+You may apply a filter to all tests of a class by using the ``filterwarnings`` mark as a class
+decorator or to all tests in a module by setting the ``pytestmark`` variable:
+
+.. code-block:: python
+
+    # turns all warnings into errors for this module
+    pytestmark = pytest.mark.filterwarnings('error')
+
+
 .. note::
 
     ``DeprecationWarning`` and ``PendingDeprecationWarning`` are hidden by the standard library

doc/en/writing_plugins.rst

@@ -49,7 +49,7 @@ Plugin discovery order at tool startup
 
   Note that pytest does not find ``conftest.py`` files in deeper nested
   sub directories at tool startup.  It is usually a good idea to keep
-  your conftest.py file in the top level test or project root directory.
+  your ``conftest.py`` file in the top level test or project root directory.
 
 * by recursively loading all plugins specified by the
   ``pytest_plugins`` variable in ``conftest.py`` files
@@ -57,9 +57,7 @@ Plugin discovery order at tool startup
 
 .. _`pytest/plugin`: http://bitbucket.org/pytest-dev/pytest/src/tip/pytest/plugin/
 .. _`conftest.py plugins`:
-.. _`conftest.py`:
 .. _`localplugin`:
-.. _`conftest`:
 .. _`local conftest plugins`:
 
 conftest.py: local per-directory plugins
@@ -90,14 +88,16 @@ Here is how you might run it::
      pytest test_flat.py   # will not show "setting up"
      pytest a/test_sub.py  # will show "setting up"
 
-.. Note::
+.. note::
     If you have ``conftest.py`` files which do not reside in a
     python package directory (i.e. one containing an ``__init__.py``) then
     "import conftest" can be ambiguous because there might be other
-    ``conftest.py`` files as well on your PYTHONPATH or ``sys.path``.
+    ``conftest.py`` files as well on your ``PYTHONPATH`` or ``sys.path``.
     It is thus good practice for projects to either put ``conftest.py``
     under a package scope or to never import anything from a
-    conftest.py file.
+    ``conftest.py`` file.
+
+    See also: :ref:`pythonpath`.
 
 
 Writing your own plugin
@@ -122,8 +122,8 @@ to extend and add functionality.
     for authoring plugins.
 
     The template provides an excellent starting point with a working plugin,
-    tests running with tox, comprehensive README and
-    entry-pointy already pre-configured.
+    tests running with tox, a comprehensive README file as well as a
+    pre-configured entry-point.
 
 Also consider :ref:`contributing your plugin to pytest-dev<submitplugin>`
 once it has some happy users other than yourself.
@@ -255,11 +255,11 @@ if ``myapp.testsupport.myplugin`` also declares ``pytest_plugins``, the contents
 of the variable will also be loaded as plugins, and so on.
 
 This mechanism makes it easy to share fixtures within applications or even
-external applications without the need to create external plugins using 
+external applications without the need to create external plugins using
 the ``setuptools``'s entry point technique.
 
 Plugins imported by ``pytest_plugins`` will also automatically be marked
-for assertion rewriting (see :func:`pytest.register_assert_rewrite`). 
+for assertion rewriting (see :func:`pytest.register_assert_rewrite`).
 However for this to have any effect the module must not be
 imported already; if it was already imported at the time the
 ``pytest_plugins`` statement is processed, a warning will result and
@@ -286,34 +286,101 @@ the ``--trace-config`` option.
 Testing plugins
 ---------------
 
-pytest comes with some facilities that you can enable for testing your
-plugin.  Given that you have an installed plugin you can enable the
-:py:class:`testdir <_pytest.pytester.Testdir>` fixture via specifying a
-command line option to include the pytester plugin (``-p pytester``) or
-by putting ``pytest_plugins = "pytester"`` into your test or
-``conftest.py`` file.  You then will have a ``testdir`` fixture which you
-can use like this::
+pytest comes with a plugin named ``pytester`` that helps you write tests for
+your plugin code. The plugin is disabled by default, so you will have to enable
+it before you can use it.
 
-    # content of test_myplugin.py
+You can do so by adding the following line to a ``conftest.py`` file in your
+testing directory:
 
-    pytest_plugins = "pytester"  # to get testdir fixture
+.. code-block:: python
 
-    def test_myplugin(testdir):
+    # content of conftest.py
+
+    pytest_plugins = ["pytester"]
+
+Alternatively you can invoke pytest with the ``-p pytester`` command line
+option.
+
+This will allow you to use the :py:class:`testdir <_pytest.pytester.Testdir>`
+fixture for testing your plugin code.
+
+Let's demonstrate what you can do with the plugin with an example. Imagine we
+developed a plugin that provides a fixture ``hello`` which yields a function
+and we can invoke this function with one optional parameter. It will return a
+string value of ``Hello World!`` if we do not supply a value or ``Hello
+{value}!`` if we do supply a string value.
+
+.. code-block:: python
+
+    # -*- coding: utf-8 -*-
+
+    import pytest
+
+    def pytest_addoption(parser):
+        group = parser.getgroup('helloworld')
+        group.addoption(
+            '--name',
+            action='store',
+            dest='name',
+            default='World',
+            help='Default "name" for hello().'
+        )
+
+    @pytest.fixture
+    def hello(request):
+        name = request.config.getoption('name')
+
+        def _hello(name=None):
+            if not name:
+                name = request.config.getoption('name')
+            return "Hello {name}!".format(name=name)
+
+        return _hello
+
+
+Now the ``testdir`` fixture provides a convenient API for creating temporary
+``conftest.py`` files and test files. It also allows us to run the tests and
+return a result object, with which we can assert the tests' outcomes.
+
+.. code-block:: python
+
+    def test_hello(testdir):
+        """Make sure that our plugin works."""
+
+        # create a temporary conftest.py file
+        testdir.makeconftest("""
+            import pytest
+
+            @pytest.fixture(params=[
+                "Brianna",
+                "Andreas",
+                "Floris",
+            ])
+            def name(request):
+                return request.param
+        """)
+
+        # create a temporary pytest test file
         testdir.makepyfile("""
-            def test_example():
-                pass
-        """)
-        result = testdir.runpytest("--verbose")
-        result.stdout.fnmatch_lines("""
-            test_example*
+            def test_hello_default(hello):
+                assert hello() == "Hello World!"
+
+            def test_hello_name(hello, name):
+                assert hello(name) == "Hello {0}!".format(name)
         """)
 
-Note that by default ``testdir.runpytest()`` will perform a pytest
-in-process.  You can pass the command line option ``--runpytest=subprocess``
-to have it happen in a subprocess.
+        # run all tests with pytest
+        result = testdir.runpytest()
+
+        # check that all 4 tests passed
+        result.assert_outcomes(passed=4)
+
+
+For more information about the result object that ``runpytest()`` returns, and
+the methods that it provides please check out the :py:class:`RunResult
+<_pytest.pytester.RunResult>` documentation.
 
-Also see the :py:class:`RunResult <_pytest.pytester.RunResult>` for more
-methods of the result object that you get from a call to ``runpytest``.
 
 .. _`writinghooks`:
 
@@ -357,6 +424,8 @@ allowed to raise exceptions.  Doing so will break the pytest run.
 
 
 
+.. _firstresult:
+
 firstresult: stop at first non-None result
 -------------------------------------------
 
@@ -573,6 +642,7 @@ Session related reporting hooks:
 .. autofunction:: pytest_collectreport
 .. autofunction:: pytest_deselected
 .. autofunction:: pytest_report_header
+.. autofunction:: pytest_report_collectionfinish
 .. autofunction:: pytest_report_teststatus
 .. autofunction:: pytest_terminal_summary
 .. autofunction:: pytest_fixture_setup

pyproject.toml

@@ -31,5 +31,5 @@ template = "changelog/_template.rst"
 
   [[tool.towncrier.type]]
   directory = "trivial"
-  name = "Trivial Changes"
-  showcontent = false
+  name = "Trivial/Internal Changes"
+  showcontent = true

pytest.py

@@ -16,16 +16,16 @@ from _pytest.freeze_support import freeze_includes
 from _pytest import __version__
 from _pytest.debugging import pytestPDB as __pytestPDB
 from _pytest.recwarn import warns, deprecated_call
-from _pytest.runner import fail, skip, importorskip, exit
+from _pytest.outcomes import fail, skip, importorskip, exit, xfail
 from _pytest.mark import MARK_GEN as mark, param
-from _pytest.skipping import xfail
 from _pytest.main import Item, Collector, File, Session
 from _pytest.fixtures import fillfixtures as _fillfuncargs
 from _pytest.python import (
-    raises, approx,
     Module, Class, Instance, Function, Generator,
 )
 
+from _pytest.python_api import approx, raises
+
 set_trace = __pytestPDB.set_trace
 
 __all__ = [

scripts/call-tox.bat

@@ -5,4 +5,4 @@ if "%TOXENV%" == "coveralls" (
         exit /b 0
     )
 )
-C:\Python35\python -m tox
+C:\Python36\python -m tox

scripts/check-manifest.py

@@ -1,20 +0,0 @@
-"""
-Script used by tox.ini to check the manifest file if we are under version control, or skip the
-check altogether if not.
-
-"check-manifest" will needs a vcs to work, which is not available when testing the package
-instead of the source code (with ``devpi test`` for example).
-"""
-
-from __future__ import print_function
-
-import os
-import subprocess
-import sys
-from check_manifest import main
-
-if os.path.isdir('.git'):
-    sys.exit(main())
-else:
-    print('No .git directory found, skipping checking the manifest file')
-    sys.exit(0)

setup.py

@@ -43,14 +43,15 @@ def has_environment_marker_support():
 
 
 def main():
-    install_requires = ['py>=1.4.33', 'setuptools']  # pluggy is vendored in _pytest.vendored_packages
+    install_requires = ['py>=1.4.33,<1.5', 'setuptools']  # pluggy is vendored in _pytest.vendored_packages
     extras_require = {}
     if has_environment_marker_support():
-        extras_require[':python_version=="2.6"'] = ['argparse']
+        extras_require[':python_version=="2.6"'] = ['argparse', 'ordereddict']
         extras_require[':sys_platform=="win32"'] = ['colorama']
     else:
         if sys.version_info < (2, 7):
             install_requires.append('argparse')
+            install_requires.append('ordereddict')
         if sys.platform == 'win32':
             install_requires.append('colorama')
 

tasks/__init__.py

@@ -4,6 +4,10 @@ Invoke tasks to help with pytest development and release process.
 
 import invoke
 
-from . import generate
+from . import generate, vendoring
 
-ns = invoke.Collection(generate)
+
+ns = invoke.Collection(
+    generate,
+    vendoring
+)

tasks/requirements.txt

@@ -1,4 +1,5 @@
 invoke
 tox
 gitpython
-towncrier
+towncrier
+wheel

tasks/vendoring.py

@@ -0,0 +1,23 @@
+from __future__ import absolute_import, print_function
+import py
+import invoke
+
+VENDOR_TARGET = py.path.local("_pytest/vendored_packages")
+GOOD_FILES = 'README.md', '__init__.py'
+
+@invoke.task()
+def remove_libs(ctx):
+    print("removing vendored libs")
+    for path in VENDOR_TARGET.listdir():
+        if path.basename not in GOOD_FILES:
+            print(" ", path)
+            path.remove()
+
+@invoke.task(pre=[remove_libs])
+def update_libs(ctx):
+    print("installing libs")
+    ctx.run("pip install -t {target} pluggy".format(target=VENDOR_TARGET))
+    ctx.run("git add {target}".format(target=VENDOR_TARGET))
+    print("Please commit to finish the update after running the tests:")
+    print()
+    print('    git commit -am "Updated vendored libs"')