Regendocs

Update talks page

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,8 @@
+Thanks for submitting an issue!
+
+Here's a quick checklist in what to include:
+
+- [ ] Include a detailed description of the bug or suggestion
+- [ ] `pip list` of the virtual environment you are using
+- [ ] py.test and operating system versions
+- [ ] Minimal example if possible

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,8 @@
+Thanks for submitting a PR, your contribution is really appreciated!
+
+Here's a quick checklist that should be present in PRs:
+
+- [ ] Target: for bug or doc fixes, target `master`; for new features, target `features`
+- [ ] Make sure to include one or more tests for your change
+- [ ] Add yourself to `AUTHORS`
+- [ ] Add a new entry to the `CHANGELOG` (choose any open position to avoid merge conflicts with other PRs) 

.travis.yml

@@ -7,25 +7,25 @@ install: "pip install -U tox"
 # # command to run tests
 env:
   matrix:
+    # coveralls is not listed in tox's envlist, but should run in travis
     - TESTENV=coveralls
-    - TESTENV=doctesting
-    - TESTENV=flakes
+    # note: please use "tox --listenvs" to populate the build matrix below
+    - TESTENV=linting
     - TESTENV=py26
     - TESTENV=py27
-    - TESTENV=py27-cxfreeze
-    - TESTENV=py27-nobyte
-    - TESTENV=py27-pexpect
-    - TESTENV=py27-subprocess
-    - TESTENV=py27-trial
-    - TESTENV=py27-xdist
-    - TESTENV=py33
     - TESTENV=py33
     - TESTENV=py34
-    - TESTENV=py35-pexpect
-    - TESTENV=py35-trial
-    - TESTENV=py35-xdist
     - TESTENV=py35
     - TESTENV=pypy
+    - TESTENV=py27-pexpect
+    - TESTENV=py27-xdist
+    - TESTENV=py27-trial
+    - TESTENV=py35-pexpect
+    - TESTENV=py35-xdist
+    - TESTENV=py35-trial
+    - TESTENV=py27-nobyte
+    - TESTENV=doctesting
+    - TESTENV=py27-cxfreeze
 
 script: tox --recreate -e $TESTENV
 

AUTHORS

@@ -10,6 +10,7 @@ Andy Freeland
 Anthon van der Neut
 Armin Rigo
 Aron Curzon
+Aviv Palivoda
 Benjamin Peterson
 Bob Ippolito
 Brian Dorsey
@@ -23,11 +24,14 @@ Christian Theunert
 Christian Tismer
 Christopher Gilling
 Daniel Grana
+Daniel Hahler
 Daniel Nuri
 Dave Hunt
 David Mohr
+David Vierra
 Edison Gustavo Muenz
 Eduardo Schettino
+Endre Galaczi
 Elizaveta Shashkova
 Eric Hunsberger
 Eric Siegerman
@@ -45,16 +49,20 @@ Jaap Broekhuizen
 Jan Balster
 Janne Vanhala
 Jason R. Coombs
+Joshua Bronson
 Jurko Gospodnetić
 Katarzyna Jachim
 Kevin Cox
 Lee Kamentsky
+Lukas Bednar
 Maciek Fijalkowski
 Maho
 Marc Schlaich
 Mark Abramowitz
 Markus Unterwaditzer
 Martijn Faassen
+Matt Bachmann
+Michael Aquilina
 Michael Birtwell
 Michael Droettboom
 Nicolas Delaby
@@ -62,8 +70,10 @@ Pieter Mulder
 Piotr Banaszkiewicz
 Punyashloka Biswal
 Ralf Schmitt
+Raphael Pierzina
 Ronny Pfannschmidt
 Ross Lawley
+Ryan Wooden
 Samuele Pedroni
 Tom Viner
 Trevor Bekolay

CHANGELOG.rst

@@ -1,10 +1,162 @@
+2.9.1
+=====
+
+**Bug Fixes**
+
+* Improve error message when a plugin fails to load.
+  Thanks `@nicoddemus`_ for the PR.
+
+* Fix (`#1178 <https://github.com/pytest-dev/pytest/issues/1178>`_):
+  ``pytest.fail`` with non-ascii characters raises an internal pytest error.
+  Thanks `@nicoddemus`_ for the PR.
+
+* Fix (`#469`_): junit parses report.nodeid incorrectly, when params IDs
+  contain ``::``. Thanks `@tomviner`_ for the PR (`#1431`_).
+
+* Fix (`#578 <https://github.com/pytest-dev/pytest/issues/578>`_): SyntaxErrors
+  containing non-ascii lines at the point of failure generated an internal
+  py.test error.
+  Thanks `@asottile`_ for the report and `@nicoddemus`_ for the PR.
+
+* Fix (`#1437`_): When passing in a bytestring regex pattern to parameterize
+  attempt to decode it as utf-8 ignoring errors.
+
+* Fix (`#649`_): parametrized test nodes cannot be specified to run on the command line.
+
+
+.. _#1437: https://github.com/pytest-dev/pytest/issues/1437
+.. _#469: https://github.com/pytest-dev/pytest/issues/469
+.. _#1431: https://github.com/pytest-dev/pytest/pull/1431
+.. _#649: https://github.com/pytest-dev/pytest/issues/649
+
+.. _@asottile: https://github.com/asottile
+
+
+2.9.0
+=====
+
+**New Features**
+
+* New ``pytest.mark.skip`` mark, which unconditionally skips marked tests.
+  Thanks `@MichaelAquilina`_ for the complete PR (`#1040`_).
+
+* ``--doctest-glob`` may now be passed multiple times in the command-line.
+  Thanks `@jab`_ and `@nicoddemus`_ for the PR.
+
+* New ``-rp`` and ``-rP`` reporting options give the summary and full output
+  of passing tests, respectively. Thanks to `@codewarrior0`_ for the PR.
+
+* ``pytest.mark.xfail`` now has a ``strict`` option, which makes ``XPASS``
+  tests to fail the test suite (defaulting to ``False``). There's also a
+  ``xfail_strict`` ini option that can be used to configure it project-wise.
+  Thanks `@rabbbit`_ for the request and `@nicoddemus`_ for the PR (`#1355`_).
+
+* ``Parser.addini`` now supports options of type ``bool``. 
+  Thanks `@nicoddemus`_ for the PR.
+
+* New ``ALLOW_BYTES`` doctest option. This strips ``b`` prefixes from byte strings
+  in doctest output (similar to ``ALLOW_UNICODE``).
+  Thanks `@jaraco`_ for the request and `@nicoddemus`_ for the PR (`#1287`_).
+
+* Give a hint on ``KeyboardInterrupt`` to use the ``--fulltrace`` option to show the errors.
+  Fixes `#1366`_.
+  Thanks to `@hpk42`_ for the report and `@RonnyPfannschmidt`_ for the PR.
+
+* Catch ``IndexError`` exceptions when getting exception source location. 
+  Fixes a pytest internal error for dynamically generated code (fixtures and tests)
+  where source lines are fake by intention.
+
+**Changes**
+
+* **Important**: `py.code <http://pylib.readthedocs.org/en/latest/code.html>`_ has been
+  merged into the ``pytest`` repository as ``pytest._code``. This decision 
+  was made because ``py.code`` had very few uses outside ``pytest`` and the 
+  fact that it was in a different repository made it difficult to fix bugs on 
+  its code in a timely manner. The team hopes with this to be able to better
+  refactor out and improve that code.
+  This change shouldn't affect users, but it is useful to let users aware
+  if they encounter any strange behavior.
+  
+  Keep in mind that the code for ``pytest._code`` is **private** and 
+  **experimental**, so you definitely should not import it explicitly!
+
+  Please note that the original ``py.code`` is still available in 
+  `pylib <http://pylib.readthedocs.org>`_.
+
+* ``pytest_enter_pdb`` now optionally receives the pytest config object.
+  Thanks `@nicoddemus`_ for the PR.
+
+* Removed code and documentation for Python 2.5 or lower versions,
+  including removal of the obsolete ``_pytest.assertion.oldinterpret`` module.
+  Thanks `@nicoddemus`_ for the PR (`#1226`_).
+
+* Comparisons now always show up in full when ``CI`` or ``BUILD_NUMBER`` is
+  found in the environment, even when ``-vv`` isn't used.
+  Thanks `@The-Compiler`_ for the PR.
+
+* ``--lf`` and ``--ff`` now support long names: ``--last-failed`` and
+  ``--failed-first`` respectively.
+  Thanks `@MichaelAquilina`_ for the PR.
+
+* Added expected exceptions to ``pytest.raises`` fail message.
+
+* Collection only displays progress ("collecting X items") when in a terminal.
+  This avoids cluttering the output when using ``--color=yes`` to obtain
+  colors in CI integrations systems (`#1397`_).
+
+**Bug Fixes**
+
+* The ``-s`` and ``-c`` options should now work under ``xdist``;
+  ``Config.fromdictargs`` now represents its input much more faithfully.
+  Thanks to `@bukzor`_ for the complete PR (`#680`_).
+
+* Fix (`#1290`_): support Python 3.5's ``@`` operator in assertion rewriting.
+  Thanks `@Shinkenjoe`_ for report with test case and `@tomviner`_ for the PR.
+
+* Fix formatting utf-8 explanation messages (`#1379`_).
+  Thanks `@biern`_ for the PR.
+
+* Fix `traceback style docs`_ to describe all of the available options
+  (auto/long/short/line/native/no), with `auto` being the default since v2.6.
+  Thanks `@hackebrot`_ for the PR.
+
+* Fix (`#1422`_): junit record_xml_property doesn't allow multiple records
+  with same name.
+
+.. _`traceback style docs`: https://pytest.org/latest/usage.html#modifying-python-traceback-printing
+
+.. _#1422: https://github.com/pytest-dev/pytest/issues/1422
+.. _#1379: https://github.com/pytest-dev/pytest/issues/1379
+.. _#1366: https://github.com/pytest-dev/pytest/issues/1366
+.. _#1040: https://github.com/pytest-dev/pytest/pull/1040
+.. _#680: https://github.com/pytest-dev/pytest/issues/680
+.. _#1287: https://github.com/pytest-dev/pytest/pull/1287
+.. _#1226: https://github.com/pytest-dev/pytest/pull/1226
+.. _#1290: https://github.com/pytest-dev/pytest/pull/1290
+.. _#1355: https://github.com/pytest-dev/pytest/pull/1355
+.. _#1397: https://github.com/pytest-dev/pytest/issues/1397
+.. _@biern: https://github.com/biern
+.. _@MichaelAquilina: https://github.com/MichaelAquilina
+.. _@bukzor: https://github.com/bukzor
+.. _@hpk42: https://github.com/hpk42
+.. _@nicoddemus: https://github.com/nicoddemus
+.. _@jab: https://github.com/jab
+.. _@codewarrior0: https://github.com/codewarrior0
+.. _@jaraco: https://github.com/jaraco
+.. _@The-Compiler: https://github.com/The-Compiler
+.. _@Shinkenjoe: https://github.com/Shinkenjoe
+.. _@tomviner: https://github.com/tomviner
+.. _@RonnyPfannschmidt: https://github.com/RonnyPfannschmidt
+.. _@rabbbit: https://github.com/rabbbit
+.. _@hackebrot: https://github.com/hackebrot
+
 2.8.7
-----------
+=====
 
 - fix #1338: use predictable object resolution for monkeypatch
 
 2.8.6
------
+=====
 
 - fix #1259: allow for double nodeids in junitxml,
   this was a regression failing plugins combinations
@@ -36,7 +188,7 @@
 
 
 2.8.5
------
+=====
 
 - fix #1243: fixed issue where class attributes injected during collection could break pytest.
   PR by Alexei Kozlenok, thanks Ronny Pfannschmidt and Bruno Oliveira for the review and help.
@@ -50,7 +202,7 @@
 
 
 2.8.4
------
+=====
 
 - fix #1190: ``deprecated_call()`` now works when the deprecated
   function has been already called by another test in the same
@@ -74,7 +226,7 @@
   Thanks Bruno Oliveira for the PR.
 
 2.8.3
------
+=====
 
 - fix #1169: add __name__ attribute to testcases in TestCaseFunction to
   support the @unittest.skip decorator on functions and methods.
@@ -101,10 +253,8 @@
   system integrity protection (thanks Florian)
 
 
-
-
 2.8.2
------
+=====
 
 - fix #1085: proper handling of encoding errors when passing encoded byte
   strings to pytest.parametrize in Python 2.
@@ -124,7 +274,7 @@
   Oliveira for the PR.
 
 2.8.1
------
+=====
 
 - fix #1034: Add missing nodeid on pytest_logwarning call in
   addhook.  Thanks Simon Gomizelj for the PR.
@@ -163,6 +313,7 @@
 
 - Fix issue #411: Add __eq__ method to assertion comparison example.
   Thanks Ben Webb.
+- Fix issue #653: deprecated_call can be used as context manager.
 
 - fix issue 877: properly handle assertion explanations with non-ascii repr
   Thanks Mathieu Agopian for the report and Ronny Pfannschmidt for the PR.
@@ -170,7 +321,7 @@
 - fix issue 1029: transform errors when writing cache values into pytest-warnings
 
 2.8.0
------------------------------
+=====
 
 - new ``--lf`` and ``-ff`` options to run only the last failing tests or
   "failing tests first" from the last run.  This functionality is provided
@@ -227,10 +378,10 @@
 - fix issue768: docstrings found in python modules were not setting up session
   fixtures. Thanks Jason R. Coombs for reporting and Bruno Oliveira for the PR.
 
-- added `tmpdir_factory`, a session-scoped fixture that can be used to create
+- added ``tmpdir_factory``, a session-scoped fixture that can be used to create
   directories under the base temporary directory. Previously this object was
-  installed as a `_tmpdirhandler` attribute of the `config` object, but now it
-  is part of the official API and using `config._tmpdirhandler` is
+  installed as a ``_tmpdirhandler`` attribute of the ``config`` object, but now it
+  is part of the official API and using ``config._tmpdirhandler`` is
   deprecated.
   Thanks Bruno Oliveira for the PR.
 
@@ -259,7 +410,7 @@
   or no tests were run at all (related to issue500).
   Thanks Eric Siegerman.
 
-- New `testpaths` ini option: list of directories to search for tests
+- New ``testpaths`` ini option: list of directories to search for tests
   when executing pytest from the root directory. This can be used
   to speed up test collection when a project has well specified directories
   for tests, being usually more practical than configuring norecursedirs for
@@ -355,20 +506,20 @@
 - issue951: add new record_xml_property fixture, that supports logging
   additional information on xml output. Thanks David Diaz for the PR.
 
-- issue949: paths after normal options (for example `-s`, `-v`, etc) are now
-  properly used to discover `rootdir` and `ini` files.
+- issue949: paths after normal options (for example ``-s``, ``-v``, etc) are now
+  properly used to discover ``rootdir`` and ``ini`` files.
   Thanks Peter Lauri for the report and Bruno Oliveira for the PR.
 
 2.7.3 (compared to 2.7.2)
------------------------------
+=============================
 
-- Allow 'dev', 'rc', or other non-integer version strings in `importorskip`.
+- Allow 'dev', 'rc', or other non-integer version strings in ``importorskip``.
   Thanks to Eric Hunsberger for the PR.
 
 - fix issue856: consider --color parameter in all outputs (for example
   --fixtures). Thanks Barney Gale for the report and Bruno Oliveira for the PR.
 
-- fix issue855: passing str objects as `plugins` argument to pytest.main
+- fix issue855: passing str objects as ``plugins`` argument to pytest.main
   is now interpreted as a module name to be imported and registered as a
   plugin, instead of silently having no effect.
   Thanks xmo-odoo for the report and Bruno Oliveira for the PR.
@@ -403,7 +554,7 @@
   Thanks Bruno Oliveira for the PR.
 
 2.7.2 (compared to 2.7.1)
------------------------------
+=============================
 
 - fix issue767: pytest.raises value attribute does not contain the exception
   instance on Python 2.6. Thanks Eric Siegerman for providing the test
@@ -432,7 +583,7 @@
 
 
 2.7.1 (compared to 2.7.0)
------------------------------
+=============================
 
 - fix issue731: do not get confused by the braces which may be present
   and unbalanced in an object's repr while collapsing False
@@ -465,7 +616,7 @@
   at least by pytest-xdist.
 
 2.7.0 (compared to 2.6.4)
------------------------------
+=============================
 
 - fix issue435: make reload() work when assert rewriting is active.
   Thanks Daniel Hahler.
@@ -524,7 +675,7 @@
   it from the "decorator" case.  Thanks Tom Viner.
 
 - "python_classes" and "python_functions" options now support glob-patterns
- for test discovery, as discussed in issue600. Thanks Ldiary Translations.
+  for test discovery, as discussed in issue600. Thanks Ldiary Translations.
 
 - allow to override parametrized fixtures with non-parametrized ones and vice versa (bubenkoff).
 
@@ -535,7 +686,7 @@
   via postmortem debugging (almarklein).
 
 2.6.4
-----------
+=====
 
 - Improve assertion failure reporting on iterables, by using ndiff and
   pprint.
@@ -564,7 +715,7 @@
 - fix issue614: fixed pastebin support.
 
 2.6.3
------------
+=====
 
 - fix issue575: xunit-xml was reporting collection errors as failures
   instead of errors, thanks Oleg Sinyavskiy.
@@ -591,7 +742,7 @@
   Floris Bruynooghe.
 
 2.6.2
------------
+=====
 
 - Added function pytest.freeze_includes(), which makes it easy to embed
   pytest into executables using tools like cx_freeze.
@@ -620,7 +771,7 @@
   to them.
 
 2.6.1
------------------------------------
+=====
 
 - No longer show line numbers in the --verbose output, the output is now
   purely the nodeid.  The line number is still shown in failure reports.
@@ -652,7 +803,7 @@
   Thanks Bruno Oliveira.
 
 2.6
------------------------------------
+===
 
 - Cache exceptions from fixtures according to their scope (issue 467).
 
@@ -757,7 +908,7 @@
 
 
 2.5.2
------------------------------------
+=====
 
 - fix issue409 -- better interoperate with cx_freeze by not
   trying to import from collections.abc which causes problems
@@ -785,7 +936,7 @@
 
 
 2.5.1
------------------------------------
+=====
 
 - merge new documentation styling PR from Tobias Bieniek.
 
@@ -806,7 +957,7 @@
 
 
 2.5.0
------------------------------------
+=====
 
 - dropped python2.5 from automated release testing of pytest itself
   which means it's probably going to break soon (but still works
@@ -941,8 +1092,8 @@
 
 - fix verbose reporting for @mock'd test functions
 
-v2.4.2
------------------------------------
+2.4.2
+=====
 
 - on Windows require colorama and a newer py lib so that py.io.TerminalWriter()
   now uses colorama instead of its own ctypes hacks. (fixes issue365)
@@ -972,8 +1123,8 @@ v2.4.2
 - add pluginmanager.do_configure(config) as a link to
   config.do_configure() for plugin-compatibility
 
-v2.4.1
------------------------------------
+2.4.1
+=====
 
 - When using parser.addoption() unicode arguments to the
   "type" keyword should also be converted to the respective types.
@@ -988,8 +1139,8 @@ v2.4.1
 
 - merge doc typo fixes, thanks Andy Dirnberger
 
-v2.4
------------------------------------
+2.4
+===
 
 known incompatibilities:
 
@@ -1157,8 +1308,8 @@ Bug fixes:
   ".section(title)" and ".line(msg)" methods to print extra
   information at the end of a test run.
 
-v2.3.5
------------------------------------
+2.3.5
+=====
 
 - fix issue169: respect --tb=style with setup/teardown errors as well.
 
@@ -1222,8 +1373,8 @@ v2.3.5
 
 - fix issue266 - accept unicode in MarkEvaluator expressions
 
-v2.3.4
------------------------------------
+2.3.4
+=====
 
 - yielded test functions will now have autouse-fixtures active but
   cannot accept fixtures as funcargs - it's anyway recommended to
@@ -1242,8 +1393,8 @@ v2.3.4
   need to write as -k "TestClass and test_method" to match a certain
   method in a certain test class.
 
-v2.3.3
------------------------------------
+2.3.3
+=====
 
 - fix issue214 - parse modules that contain special objects like e. g.
   flask's request object which blows up on getattr access if no request
@@ -1274,8 +1425,8 @@ v2.3.3
 - fix issue127 - improve documentation for pytest_addoption() and
   add a ``config.getoption(name)`` helper function for consistency.
 
-v2.3.2
------------------------------------
+2.3.2
+=====
 
 - fix issue208 and fix issue29 use new py version to avoid long pauses
   when printing tracebacks in long modules
@@ -1307,8 +1458,8 @@ v2.3.2
   - add tox.ini to pytest distribution so that ignore-dirs and others config
     bits are properly distributed for maintainers who run pytest-own tests
 
-v2.3.1
------------------------------------
+2.3.1
+=====
 
 - fix issue202 - fix regression: using "self" from fixture functions now
   works as expected (it's the same "self" instance that a test method
@@ -1320,8 +1471,8 @@ v2.3.1
 - link to web pages from --markers output which provides help for
   pytest.mark.* usage.
 
-v2.3.0
------------------------------------
+2.3.0
+=====
 
 - fix issue202 - better automatic names for parametrized test functions
 - fix issue139 - introduce @pytest.fixture which allows direct scoping
@@ -1399,8 +1550,8 @@ v2.3.0
 
   - py.test -vv will show all of assert comparisations instead of truncating
 
-v2.2.4
------------------------------------
+2.2.4
+=====
 
 - fix error message for rewritten assertions involving the % operator
 - fix issue 126: correctly match all invalid xml characters for junitxml
@@ -1416,13 +1567,13 @@ v2.2.4
 - fix issue #144: better mangle test ids to junitxml classnames
 - upgrade distribute_setup.py to 0.6.27
 
-v2.2.3
-----------------------------------------
+2.2.3
+=====
 
 - fix uploaded package to only include neccesary files
 
-v2.2.2
-----------------------------------------
+2.2.2
+=====
 
 - fix issue101: wrong args to unittest.TestCase test function now
   produce better output
@@ -1441,8 +1592,8 @@ v2.2.2
 - allow adding of attributes to test reports such that it also works
   with distributed testing (no upgrade of pytest-xdist needed)
 
-v2.2.1
-----------------------------------------
+2.2.1
+=====
 
 - fix issue99 (in pytest and py) internallerrors with resultlog now
   produce better output - fixed by normalizing pytest_internalerror
@@ -1458,8 +1609,8 @@ v2.2.1
 - fix collection crash due to unknown-source collected items, thanks
   to Ralf Schmitt (fixed by depending on a more recent pylib)
 
-v2.2.0
-----------------------------------------
+2.2.0
+=====
 
 - fix issue90: introduce eager tearing down of test items so that
   teardown function are called earlier.
@@ -1493,8 +1644,8 @@ v2.2.0
 - simplify junitxml output code by relying on py.xml
 - add support for skip properties on unittest classes and functions
 
-v2.1.3
-----------------------------------------
+2.1.3
+=====
 
 - fix issue79: assertion rewriting failed on some comparisons in boolops
 - correctly handle zero length arguments (a la pytest '')
@@ -1502,8 +1653,8 @@ v2.1.3
 - fix issue75 / skipping test failure on jython
 - fix issue77 / Allow assertrepr_compare hook to apply to a subset of tests
 
-v2.1.2
-----------------------------------------
+2.1.2
+=====
 
 - fix assertion rewriting on files with windows newlines on some Python versions
 - refine test discovery by package/module name (--pyargs), thanks Florian Mayer
@@ -1512,8 +1663,8 @@ v2.1.2
 - fix issue66: use different assertion rewriting caches when the -O option is passed
 - don't try assertion rewriting on Jython, use reinterp
 
-v2.1.1
-----------------------------------------------
+2.1.1
+=====
 
 - fix issue64 / pytest.set_trace now works within pytest_generate_tests hooks
 - fix issue60 / fix error conditions involving the creation of __pycache__
@@ -1525,8 +1676,8 @@ v2.1.1
 - fix issue61: assertion rewriting on boolean operations with 3 or more operands
 - you can now build a man page with "cd doc ; make man"
 
-v2.1.0
-----------------------------------------------
+2.1.0
+=====
 
 - fix issue53 call nosestyle setup functions with correct ordering
 - fix issue58 and issue59: new assertion code fixes
@@ -1545,8 +1696,8 @@ v2.1.0
 - report KeyboardInterrupt even if interrupted during session startup
 - fix issue 35 - provide PDF doc version and download link from index page
 
-v2.0.3
-----------------------------------------------
+2.0.3
+=====
 
 - fix issue38: nicer tracebacks on calls to hooks, particularly early
   configure/sessionstart ones
@@ -1565,8 +1716,8 @@ v2.0.3
 
 - fix issue37: avoid invalid characters in junitxml's output
 
-v2.0.2
-----------------------------------------------
+2.0.2
+=====
 
 - tackle issue32 - speed up test runs of very quick test functions
   by reducing the relative overhead
@@ -1617,8 +1768,8 @@ v2.0.2
 
 - avoid std unittest assertion helper code in tracebacks (thanks Ronny)
 
-v2.0.1
-----------------------------------------------
+2.0.1
+=====
 
 - refine and unify initial capturing so that it works nicely
   even if the logging module is used on an early-loaded conftest.py
@@ -1666,8 +1817,8 @@ v2.0.1
   parametraization remains the "pytest_generate_tests"
   mechanism, see the docs.
 
-v2.0.0
-----------------------------------------------
+2.0.0
+=====
 
 - pytest-2.0 is now its own package and depends on pylib-2.0
 - new ability: python -m pytest / python -m pytest.main ability
@@ -1711,8 +1862,8 @@ v2.0.0
 - add ability to use "class" level for cached_setup helper
 - fix strangeness: mark.* objects are now immutable, create new instances
 
-v1.3.4
-----------------------------------------------
+1.3.4
+=====
 
 - fix issue111: improve install documentation for windows
 - fix issue119: fix custom collectability of __init__.py as a module
@@ -1720,8 +1871,8 @@ v1.3.4
 - fix issue115: unify internal exception passthrough/catching/GeneratorExit
 - fix issue118: new --tb=native for presenting cpython-standard exceptions
 
-v1.3.3
-----------------------------------------------
+1.3.3
+=====
 
 - fix issue113: assertion representation problem with triple-quoted strings
   (and possibly other cases)
@@ -1735,11 +1886,10 @@ v1.3.3
   (thanks Armin Ronacher for reporting)
 - remove trailing whitespace in all py/text distribution files
 
-v1.3.2
-----------------------------------------------
+1.3.2
+=====
 
-New features
-++++++++++++++++++
+**New features**
 
 - fix issue103:  introduce py.test.raises as context manager, examples::
 
@@ -1774,8 +1924,7 @@ New features
 - introduce '--junitprefix=STR' option to prepend a prefix
   to all reports in the junitxml file.
 
-Bug fixes / Maintenance
-++++++++++++++++++++++++++
+**Bug fixes**
 
 - make tests and the ``pytest_recwarn`` plugin in particular fully compatible
   to Python2.7 (if you use the ``recwarn`` funcarg warnings will be enabled so that
@@ -1810,11 +1959,10 @@ Bug fixes / Maintenance
 - fix homedir detection on Windows
 - ship distribute_setup.py version 0.6.13
 
-v1.3.1
----------------------------------------------
+1.3.1
+=====
 
-New features
-++++++++++++++++++
+**New features**
 
 - issue91: introduce new py.test.xfail(reason) helper
   to imperatively mark a test as expected to fail. Can
@@ -1852,8 +2000,7 @@ New features
   course requires that your application and tests are properly teared
   down and don't have global state.
 
-Fixes / Maintenance
-++++++++++++++++++++++
+**Bug Fixes**
 
 - improved traceback presentation:
   - improved and unified reporting for "--tb=short" option
@@ -1882,8 +2029,8 @@ Fixes / Maintenance
   (and internally be more careful when presenting unexpected byte sequences)
 
 
-v1.3.0
----------------------------------------------
+1.3.0
+=====
 
 - deprecate --report option in favour of a new shorter and easier to
   remember -r option: it takes a string argument consisting of any
@@ -1947,8 +2094,8 @@ v1.3.0
 - added links to the new capturelog and coverage plugins
 
 
-v1.2.0
----------------------------------------------
+1.2.0
+=====
 
 - refined usage and options for "py.cleanup"::
 
@@ -1986,8 +2133,8 @@ v1.2.0
 
 - fix plugin links
 
-v1.1.1
----------------------------------------------
+1.1.1
+=====
 
 - moved dist/looponfailing from py.test core into a new
   separately released pytest-xdist plugin.
@@ -2007,7 +2154,7 @@ v1.1.1
 - new funcarg: "pytestconfig" is the pytest config object for access
   to command line args and can now be easily used in a test.
 
-- install 'py.test' and `py.which` with a ``-$VERSION`` suffix to
+- install ``py.test`` and ``py.which`` with a ``-$VERSION`` suffix to
   disambiguate between Python3, python2.X, Jython and PyPy installed versions.
 
 - new "pytestconfig" funcarg allows access to test config object
@@ -2070,8 +2217,8 @@ v1.1.1
 - fix docs, fix internal bin/ script generation
 
 
-v1.1.0
----------------------------------------------
+1.1.0
+=====
 
 - introduce automatic plugin registration via 'pytest11'
   entrypoints via setuptools' pkg_resources.iter_entry_points
@@ -2089,8 +2236,8 @@ v1.1.0
 - try harder to have deprecation warnings for py.compat.* accesses
   report a correct location
 
-v1.0.2
----------------------------------------------
+1.0.3
+=====
 
 * adjust and improve docs
 
@@ -2174,16 +2321,16 @@ v1.0.2
 
 * simplified internal localpath implementation
 
-v1.0.2
--------------------------------------------
+1.0.2
+=====
 
 * fixing packaging issues, triggered by fedora redhat packaging,
   also added doc, examples and contrib dirs to the tarball.
 
 * added a documentation link to the new django plugin.
 
-v1.0.1
--------------------------------------------
+1.0.1
+=====
 
 * added a 'pytest_nose' plugin which handles nose.SkipTest,
   nose-style function/method/generator setup/teardown and
@@ -2216,14 +2363,14 @@ v1.0.1
 * simplified multicall mechanism and plugin architecture,
   renamed some internal methods and argnames
 
-v1.0.0
--------------------------------------------
+1.0.0
+=====
 
 * more terse reporting try to show filesystem path relatively to current dir
 * improve xfail output a bit
 
-v1.0.0b9
--------------------------------------------
+1.0.0b9
+=======
 
 * cleanly handle and report final teardown of test setup
 
@@ -2256,8 +2403,8 @@ v1.0.0b9
 * item.repr_failure(excinfo) instead of item.repr_failure(excinfo, outerr)
 
 
-v1.0.0b8
--------------------------------------------
+1.0.0b8
+=======
 
 * pytest_unittest-plugin is now enabled by default
 
@@ -2285,8 +2432,8 @@ v1.0.0b8
 * tweaked doctest output for docstrings in py modules,
   thanks Radomir.
 
-v1.0.0b7
--------------------------------------------
+1.0.0b7
+=======
 
 * renamed py.test.xfail back to py.test.mark.xfail to avoid
   two ways to decorate for xfail
@@ -2310,8 +2457,8 @@ v1.0.0b7
 
 * make __name__ == "__channelexec__" for remote_exec code
 
-v1.0.0b3
--------------------------------------------
+1.0.0b3
+=======
 
 * plugin classes are removed: one now defines
   hooks directly in conftest.py or global pytest_*.py
@@ -2327,8 +2474,8 @@ v1.0.0b3
   well with function arguments.
 
 
-v1.0.0b1
--------------------------------------------
+1.0.0b1
+=======
 
 * introduced new "funcarg" setup method,
   see doc/test/funcarg.txt
@@ -2351,8 +2498,8 @@ v1.0.0b1
 
 XXX lots of things missing here XXX
 
-v0.9.2
--------------------------------------------
+0.9.2
+=====
 
 * refined installation and metadata, created new setup.py,
   now based on setuptools/ez_setup (thanks to Ralf Schmitt
@@ -2384,8 +2531,8 @@ v0.9.2
 
 * there now is a py.__version__ attribute
 
-v0.9.1
--------------------------------------------
+0.9.1
+=====
 
 This is a fairly complete list of v0.9.1, which can
 serve as a reference for developers.

CONTRIBUTING.rst

@@ -9,46 +9,18 @@ so do not hesitate!
    :depth: 2
 
 
-.. _submitplugin:
+.. _submitfeedback:
 
-Submit a plugin, co-develop pytest
-----------------------------------
+Feature requests and feedback
+-----------------------------
 
-Pytest development of the core, some plugins and support code happens
-in repositories living under:
+Do you like pytest?  Share some love on Twitter or in your blog posts!
 
-- `the pytest-dev github organisation <https://github.com/pytest-dev>`_
+We'd also like to hear about your propositions and suggestions.  Feel free to
+`submit them as issues <https://github.com/pytest-dev/pytest/issues>`_ and:
 
-- `the pytest-dev bitbucket team <https://bitbucket.org/pytest-dev>`_
-
-All pytest-dev Contributors team members have write access to all contained
-repositories.  pytest core and plugins are generally developed
-using `pull requests`_ to respective repositories.
-
-You can submit your plugin by subscribing to the `pytest-dev mail list
-<https://mail.python.org/mailman/listinfo/pytest-dev>`_ and writing a
-mail pointing to your existing pytest plugin repository which must have
-the following:
-
-- PyPI presence with a ``setup.py`` that contains a license, ``pytest-``
-  prefixed, version number, authors, short and long description.
-
-- a ``tox.ini`` for running tests using `tox <http://tox.testrun.org>`_.
-
-- a ``README.txt`` describing how to use the plugin and on which
-  platforms it runs.
-
-- a ``LICENSE.txt`` file or equivalent containing the licensing
-  information, with matching info in ``setup.py``.
-
-- an issue tracker unless you rather want to use the core ``pytest``
-  issue tracker.
-
-If no contributor strongly objects and two agree, the repo will be
-transferred to the ``pytest-dev`` organisation and you'll become a
-member of the ``pytest-dev Contributors`` team, with commit rights
-to all projects. We recommend that each plugin has at least three
-people who have the right to release to pypi.
+* Explain in detail how they should work.
+* Keep the scope as narrow as possible.  This will make it easier to implement.
 
 
 .. _reportbugs:
@@ -56,7 +28,7 @@ people who have the right to release to pypi.
 Report bugs
 -----------
 
-Report bugs for pytest at https://github.com/pytest-dev/pytest/issues
+Report bugs for pytest in the `issue tracker <https://github.com/pytest-dev/pytest/issues>`_.
 
 If you are reporting a bug, please include:
 
@@ -70,22 +42,6 @@ If you can write a demonstration test that currently fails but should pass (xfai
 that is a very useful commit to make as well, even if you can't find how
 to fix the bug yet.
 
-.. _submitfeedback:
-
-Submit feedback for developers
-------------------------------
-
-Do you like pytest?  Share some love on Twitter or in your blog posts!
-
-We'd also like to hear about your propositions and suggestions.  Feel free to
-`submit them as issues <https://github.com/pytest-dev/pytest/issues>`__ and:
-
-* Set the "kind" to "enhancement" or "proposal" so that we can quickly find
-  about them.
-* Explain in detail how they should work.
-* Keep the scope as narrow as possible.  This will make it easier to implement.
-* If you have required skills and/or knowledge, we are very happy for
-  :ref:`pull requests <pull-requests>`.
 
 .. _fixbugs:
 
@@ -125,12 +81,88 @@ You can also edit documentation files directly in the Github web interface
 without needing to make a fork and local copy. This can be convenient for
 small fixes.
 
+
+.. _submitplugin:
+
+Submitting Plugins to pytest-dev
+--------------------------------
+
+Pytest development of the core, some plugins and support code happens
+in repositories living under the ``pytest-dev`` organisations:
+
+- `pytest-dev on GitHub <https://github.com/pytest-dev>`_
+
+- `pytest-dev on Bitbucket <https://bitbucket.org/pytest-dev>`_
+
+All pytest-dev Contributors team members have write access to all contained
+repositories.  pytest core and plugins are generally developed
+using `pull requests`_ to respective repositories.
+
+The objectives of the ``pytest-dev`` organisation are:
+
+* Having a central location for popular pytest plugins
+* Sharing some of the maintenance responsibility (in case a maintainer no longer whishes to maintain a plugin)
+
+You can submit your plugin by subscribing to the `pytest-dev mail list
+<https://mail.python.org/mailman/listinfo/pytest-dev>`_ and writing a
+mail pointing to your existing pytest plugin repository which must have
+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 ``README.txt`` describing how to use the plugin and on which
+  platforms it runs.
+
+- a ``LICENSE.txt`` file or equivalent containing the licensing
+  information, with matching info in ``setup.py``.
+
+- an issue tracker for bug reports and enhancement requests.
+
+If no contributor strongly objects and two agree, the repository can then be
+transferred to the ``pytest-dev`` organisation.
+
+Here's a rundown of how a repository transfer usually proceeds
+(using a repository named ``joedoe/pytest-xyz`` as example):
+
+* One of the ``pytest-dev`` administrators creates:
+
+  - ``pytest-xyz-admin`` team, with full administration rights to
+    ``pytest-dev/pytest-xyz``.
+  - ``pytest-xyz-developers`` team, with write access to
+    ``pytest-dev/pytest-xyz``.
+
+* ``joedoe`` is invited to the ``pytest-xyz-admin`` team;
+
+* After accepting the invitation, ``joedoe`` transfers the repository from its
+  original location to ``pytest-dev/pytest-xyz`` (A nice feature is that GitHub handles URL redirection from
+  the old to the new location automatically).
+
+* ``joedoe`` is free to add any other collaborators to the
+  ``pytest-xyz-admin`` or ``pytest-xyz-developers`` team as desired.
+
+The ``pytest-dev/Contributors`` team has write access to all projects, and
+every project administrator is in it. We recommend that each plugin has at least three
+people who have the right to release to PyPI.
+
+Repository owners can be assured that no ``pytest-dev`` administrator will ever make
+releases of your repository or take ownership in any way, except in rare cases
+where someone becomes unresponsive after months of contact attempts.
+As stated, the objective is to share maintenance and avoid "plugin-abandon".
+
+
 .. _`pull requests`:
 .. _pull-requests:
 
 Preparing Pull Requests on GitHub
 ---------------------------------
 
+There's an excellent tutorial on how Pull Requests work in the
+`GitHub Help Center <https://help.github.com/articles/using-pull-requests/>`_
+
+
 .. note::
   What is a "pull request"?  It informs project's core developers about the
   changes you want to review and merge.  Pull requests are stored on
@@ -179,10 +211,10 @@ but here is a simple overview:
    You need to have Python 2.7 and 3.5 available in your system.  Now
    running tests is as simple as issuing this command::
 
-    $ python runtox.py -e py27,py35,flakes
+    $ python runtox.py -e linting,py27,py35
 
    This command will run tests via the "tox" tool against Python 2.7 and 3.5
-   and also perform "flakes" coding-style checks.  ``runtox.py`` is
+   and also perform "lint" coding-style checks.  ``runtox.py`` is
    a thin wrapper around ``tox`` which installs from a development package
    index where newer (not yet released to pypi) versions of dependencies
    (especially ``py``) might be present.

HOWTORELEASE.rst

@@ -3,6 +3,10 @@ How to release pytest
 
 Note: this assumes you have already registered on pypi.
 
+0. create the branch release-VERSION
+   use features as base for minor/major releases
+   and master as base for bugfix releases
+
 1. Bump version numbers in _pytest/__init__.py (setup.py reads it)
 
 2. Check and finalize CHANGELOG
@@ -84,4 +88,5 @@ Note: this assumes you have already registered on pypi.
     to the next Minor release version (i.e. if you released ``pytest-2.8.0``,
     set it to ``pytest-2.9.0.dev1``).
 
-14. merge the actual release into the features branch and do a pull request against it
+14. merge the actual release into the master branch and do a pull request against it
+15. merge from master to features

ISSUES.txt

@@ -18,6 +18,7 @@ Unlike mock, "args.path" acts on the parsed auto-spec'ed ``os.path.abspath``
 so it's independent from if the client side called "os.path.abspath(path=...)"
 or "os.path.abspath('positional')".
 
+
 refine parametrize API
 -------------------------------------------------------------
 tags: critical feature 

LICENSE

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

MANIFEST.in

@@ -1,4 +1,4 @@
-include CHANGELOG
+include CHANGELOG.rst
 include LICENSE
 include AUTHORS
 

README.rst

@@ -71,7 +71,7 @@ Features
 
 - Python2.6+, Python3.2+, PyPy-2.3, Jython-2.5 (untested);
 
-- Rich plugin architecture, with over 150+ `external plugins <http://pytest.org/latest/plugins.html#installing-external-plugins-searching>`_ and thriving comminity;
+- Rich plugin architecture, with over 150+ `external plugins <http://pytest.org/latest/plugins.html#installing-external-plugins-searching>`_ and thriving community;
 
 
 Documentation
@@ -96,4 +96,7 @@ License
 -------
 
 Copyright Holger Krekel and others, 2004-2016.
-Licensed under the MIT license.
+
+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

_pytest/__init__.py

@@ -1,2 +1,2 @@
 #
-__version__ = '2.8.7'
+__version__ = '2.9.1'

_pytest/_argcomplete.py

@@ -88,9 +88,6 @@ class FastFilesCompleter:
         return completion
 
 if os.environ.get('_ARGCOMPLETE'):
-    # argcomplete 0.5.6 is not compatible with python 2.5.6: print/with/format
-    if sys.version_info[:2] < (2, 6):
-        sys.exit(1)
     try:
         import argcomplete.completers
     except ImportError:

_pytest/_code/__init__.py

@@ -0,0 +1,12 @@
+""" python inspection/code generation API """
+from .code import Code  # noqa
+from .code import ExceptionInfo  # noqa
+from .code import Frame  # noqa
+from .code import Traceback  # noqa
+from .code import getrawcode  # noqa
+from .code import patch_builtins  # noqa
+from .code import unpatch_builtins  # noqa
+from .source import Source  # noqa
+from .source import compile_ as compile  # noqa
+from .source import getfslineno  # noqa
+

_pytest/_code/_py2traceback.py

@@ -0,0 +1,81 @@
+# copied from python-2.7.3's traceback.py
+# CHANGES:
+# - some_str is replaced, trying to create unicode strings
+#
+import types
+
+def format_exception_only(etype, value):
+    """Format the exception part of a traceback.
+
+    The arguments are the exception type and value such as given by
+    sys.last_type and sys.last_value. The return value is a list of
+    strings, each ending in a newline.
+
+    Normally, the list contains a single string; however, for
+    SyntaxError exceptions, it contains several lines that (when
+    printed) display detailed information about where the syntax
+    error occurred.
+
+    The message indicating which exception occurred is always the last
+    string in the list.
+
+    """
+
+    # An instance should not have a meaningful value parameter, but
+    # sometimes does, particularly for string exceptions, such as
+    # >>> raise string1, string2  # deprecated
+    #
+    # Clear these out first because issubtype(string1, SyntaxError)
+    # 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):
+        return [_format_final_exc_line(etype, value)]
+
+    stype = etype.__name__
+
+    if not issubclass(etype, SyntaxError):
+        return [_format_final_exc_line(stype, value)]
+
+    # It was a syntax error; show exactly where the problem was found.
+    lines = []
+    try:
+        msg, (filename, lineno, offset, badline) = value.args
+    except Exception:
+        pass
+    else:
+        filename = filename or "<string>"
+        lines.append('  File "%s", line %d\n' % (filename, lineno))
+        if badline is not None:
+            if isinstance(badline, bytes):  # python 2 only
+                badline = badline.decode('utf-8', 'replace')
+            lines.append(u'    %s\n' % badline.strip())
+            if offset is not None:
+                caretspace = badline.rstrip('\n')[:offset].lstrip()
+                # non-space whitespace (likes tabs) must be kept for alignment
+                caretspace = ((c.isspace() and c or ' ') for c in caretspace)
+                # only three spaces to account for offset1 == pos 0
+                lines.append('   %s^\n' % ''.join(caretspace))
+        value = msg
+
+    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)
+    if value is None or not valuestr:
+        line = "%s\n" % etype
+    else:
+        line = "%s: %s\n" % (etype, valuestr)
+    return line
+
+def _some_str(value):
+    try:
+        return unicode(value)
+    except Exception:
+        try:
+            return str(value)
+        except Exception:
+            pass
+    return '<unprintable %s object>' % type(value).__name__

_pytest/_code/code.py

@@ -0,0 +1,795 @@
+import sys
+from inspect import CO_VARARGS, CO_VARKEYWORDS
+
+import py
+
+builtin_repr = repr
+
+reprlib = py.builtin._tryimport('repr', 'reprlib')
+
+if sys.version_info[0] >= 3:
+    from traceback import format_exception_only
+else:
+    from ._py2traceback import format_exception_only
+
+class Code(object):
+    """ wrapper around Python code objects """
+    def __init__(self, rawcode):
+        if not hasattr(rawcode, "co_filename"):
+            rawcode = getrawcode(rawcode)
+        try:
+            self.filename = rawcode.co_filename
+            self.firstlineno = rawcode.co_firstlineno - 1
+            self.name = rawcode.co_name
+        except AttributeError:
+            raise TypeError("not a code object: %r" %(rawcode,))
+        self.raw = rawcode
+
+    def __eq__(self, other):
+        return self.raw == other.raw
+
+    def __ne__(self, other):
+        return not self == other
+
+    @property
+    def path(self):
+        """ return a path object pointing to source code (note that it
+        might not point to an actually existing file). """
+        p = py.path.local(self.raw.co_filename)
+        # maybe don't try this checking
+        if not p.check():
+            # XXX maybe try harder like the weird logic
+            # in the standard lib [linecache.updatecache] does?
+            p = self.raw.co_filename
+        return p
+
+    @property
+    def fullsource(self):
+        """ return a _pytest._code.Source object for the full source file of the code
+        """
+        from _pytest._code import source
+        full, _ = source.findsource(self.raw)
+        return full
+
+    def source(self):
+        """ return a _pytest._code.Source object for the code object's source only
+        """
+        # return source only for that part of code
+        import _pytest._code
+        return _pytest._code.Source(self.raw)
+
+    def getargs(self, var=False):
+        """ return a tuple with the argument names for the code object
+
+            if 'var' is set True also return the names of the variable and
+            keyword arguments when present
+        """
+        # handfull shortcut for getting args
+        raw = self.raw
+        argcount = raw.co_argcount
+        if var:
+            argcount += raw.co_flags & CO_VARARGS
+            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."""
+
+    def __init__(self, frame):
+        self.lineno = frame.f_lineno - 1
+        self.f_globals = frame.f_globals
+        self.f_locals = frame.f_locals
+        self.raw = frame
+        self.code = Code(frame.f_code)
+
+    @property
+    def statement(self):
+        """ statement this frame is at """
+        import _pytest._code
+        if self.code.fullsource is None:
+            return _pytest._code.Source("")
+        return self.code.fullsource.getstatement(self.lineno)
+
+    def eval(self, code, **vars):
+        """ evaluate 'code' in the frame
+
+            'vars' are optional additional local variables
+
+            returns the result of the evaluation
+        """
+        f_locals = self.f_locals.copy()
+        f_locals.update(vars)
+        return eval(code, self.f_globals, f_locals)
+
+    def exec_(self, code, **vars):
+        """ exec 'code' in the frame
+
+            'vars' are optiona; additional local variables
+        """
+        f_locals = self.f_locals.copy()
+        f_locals.update(vars)
+        py.builtin.exec_(code, self.f_globals, f_locals )
+
+    def repr(self, object):
+        """ return a 'safe' (non-recursive, one-line) string repr for 'object'
+        """
+        return py.io.saferepr(object)
+
+    def is_true(self, object):
+        return object
+
+    def getargs(self, var=False):
+        """ return a list of tuples (name, value) for all arguments
+
+            if 'var' is set True also include the variable and keyword
+            arguments when present
+        """
+        retval = []
+        for arg in self.code.getargs(var):
+            try:
+                retval.append((arg, self.f_locals[arg]))
+            except KeyError:
+                pass     # this can occur when using Psyco
+        return retval
+
+class TracebackEntry(object):
+    """ a single entry in a traceback """
+
+    _repr_style = None
+    exprinfo = None
+
+    def __init__(self, rawentry):
+        self._rawentry = rawentry
+        self.lineno = rawentry.tb_lineno - 1
+
+    def set_repr_style(self, mode):
+        assert mode in ("short", "long")
+        self._repr_style = mode
+
+    @property
+    def frame(self):
+        import _pytest._code
+        return _pytest._code.Frame(self._rawentry.tb_frame)
+
+    @property
+    def relline(self):
+        return self.lineno - self.frame.code.firstlineno
+
+    def __repr__(self):
+        return "<TracebackEntry %s:%d>" %(self.frame.code.path, self.lineno+1)
+
+    @property
+    def statement(self):
+        """ _pytest._code.Source object for the current statement """
+        source = self.frame.code.fullsource
+        return source.getstatement(self.lineno)
+
+    @property
+    def path(self):
+        """ path to the source code """
+        return self.frame.code.path
+
+    def getlocals(self):
+        return self.frame.f_locals
+    locals = property(getlocals, None, None, "locals of underlaying frame")
+
+    def reinterpret(self):
+        """Reinterpret the failing statement and returns a detailed information
+           about what operations are performed."""
+        from _pytest.assertion.reinterpret import reinterpret
+        if self.exprinfo is None:
+            source = py.builtin._totext(self.statement).strip()
+            x = reinterpret(source, self.frame, should_fail=True)
+            if not py.builtin._istext(x):
+                raise TypeError("interpret returned non-string %r" % (x,))
+            self.exprinfo = x
+        return self.exprinfo
+
+    def getfirstlinesource(self):
+        # on Jython this firstlineno can be -1 apparently
+        return max(self.frame.code.firstlineno, 0)
+
+    def getsource(self, astcache=None):
+        """ return failing source code. """
+        # we use the passed in astcache to not reparse asttrees
+        # within exception info printing
+        from _pytest._code.source import getstatementrange_ast
+        source = self.frame.code.fullsource
+        if source is None:
+            return None
+        key = astnode = None
+        if astcache is not None:
+            key = self.frame.code.path
+            if key is not None:
+                astnode = astcache.get(key, None)
+        start = self.getfirstlinesource()
+        try:
+            astnode, _, end = getstatementrange_ast(self.lineno, source,
+                                                    astnode=astnode)
+        except SyntaxError:
+            end = self.lineno + 1
+        else:
+            if key is not None:
+                astcache[key] = astnode
+        return source[start:end]
+
+    source = property(getsource)
+
+    def ishidden(self):
+        """ return True if the current frame has a var __tracebackhide__
+            resolving to True
+
+            mostly for internal use
+        """
+        try:
+            return self.frame.f_locals['__tracebackhide__']
+        except KeyError:
+            try:
+                return self.frame.f_globals['__tracebackhide__']
+            except KeyError:
+                return False
+
+    def __str__(self):
+        try:
+            fn = str(self.path)
+        except py.error.Error:
+            fn = '???'
+        name = self.frame.code.name
+        try:
+            line = str(self.statement).lstrip()
+        except KeyboardInterrupt:
+            raise
+        except:
+            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):
+        """ initialize from given python traceback object. """
+        if hasattr(tb, 'tb_next'):
+            def f(cur):
+                while cur is not None:
+                    yield self.Entry(cur)
+                    cur = cur.tb_next
+            list.__init__(self, f(tb))
+        else:
+            list.__init__(self, tb)
+
+    def cut(self, path=None, lineno=None, firstlineno=None, excludepath=None):
+        """ return a Traceback instance wrapping part of this Traceback
+
+            by provding any combination of path, lineno and firstlineno, the
+            first frame to start the to-be-returned traceback is determined
+
+            this allows cutting the first part of a Traceback instance e.g.
+            for formatting reasons (removing some uninteresting bits that deal
+            with handling of the exception/traceback)
+        """
+        for x in self:
+            code = x.frame.code
+            codepath = code.path
+            if ((path is None or codepath == path) and
+                (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)):
+                return Traceback(x._rawentry)
+        return self
+
+    def __getitem__(self, key):
+        val = super(Traceback, self).__getitem__(key)
+        if isinstance(key, type(slice(0))):
+            val = self.__class__(val)
+        return val
+
+    def filter(self, fn=lambda x: not x.ishidden()):
+        """ return a Traceback instance with certain items removed
+
+            fn is a function that gets a single argument, a TracebackItem
+            instance, and should return True when the item should be added
+            to the Traceback, False when not
+
+            by default this removes all the TracebackItems which are hidden
+            (see ishidden() above)
+        """
+        return Traceback(filter(fn, self))
+
+    def getcrashentry(self):
+        """ return last non-hidden traceback entry that lead
+        to the exception of a traceback.
+        """
+        for i in range(-1, -len(self)-1, -1):
+            entry = self[i]
+            if not entry.ishidden():
+                return entry
+        return self[-1]
+
+    def recursionindex(self):
+        """ return the index of the frame/TracebackItem where recursion
+            originates if appropriate, None if no recursion occurred
+        """
+        cache = {}
+        for i, entry in enumerate(self):
+            # 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
+            key = entry.frame.code.path, id(entry.frame.code.raw), entry.lineno
+            #print "checking for recursion at", key
+            l = cache.setdefault(key, [])
+            if l:
+                f = entry.frame
+                loc = f.f_locals
+                for otherloc in l:
+                    if f.is_true(f.eval(co_equal,
+                        __recursioncache_locals_1=loc,
+                        __recursioncache_locals_2=otherloc)):
+                        return i
+            l.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.
+    """
+    _striptext = ''
+    def __init__(self, tup=None, exprinfo=None):
+        import _pytest._code
+        if tup is None:
+            tup = sys.exc_info()
+            if exprinfo is None and isinstance(tup[1], AssertionError):
+                exprinfo = getattr(tup[1], 'msg', None)
+                if exprinfo is None:
+                    exprinfo = str(tup[1])
+                if exprinfo and exprinfo.startswith('assert '):
+                    self._striptext = 'AssertionError: '
+        self._excinfo = tup
+        #: the exception class
+        self.type = tup[0]
+        #: the exception instance
+        self.value = tup[1]
+        #: the exception raw traceback
+        self.tb = tup[2]
+        #: the exception type name
+        self.typename = self.type.__name__
+        #: the exception traceback (_pytest._code.Traceback instance)
+        self.traceback = _pytest._code.Traceback(self.tb)
+
+    def __repr__(self):
+        return "<ExceptionInfo %s tblen=%d>" % (self.typename, len(self.traceback))
+
+    def exconly(self, tryshort=False):
+        """ return the exception as a string
+
+            when 'tryshort' resolves to True, and the exception is a
+            _pytest._code._AssertionError, only the actual exception part of
+            the exception representation is returned (so 'AssertionError: ' is
+            removed from the beginning)
+        """
+        lines = format_exception_only(self.type, self.value)
+        text = ''.join(lines)
+        text = text.rstrip()
+        if tryshort:
+            if text.startswith(self._striptext):
+                text = text[len(self._striptext):]
+        return text
+
+    def errisinstance(self, exc):
+        """ return True if the exception is an instance of exc """
+        return isinstance(self.value, exc)
+
+    def _getreprcrash(self):
+        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)
+
+    def getrepr(self, showlocals=False, style="long",
+            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
+            tbfilter: hide entries (where __tracebackhide__ is true)
+
+            in case of style==native, tbfilter and showlocals is ignored.
+        """
+        if style == 'native':
+            return ReprExceptionInfo(ReprTracebackNative(
+                py.std.traceback.format_exception(
+                    self.type,
+                    self.value,
+                    self.traceback[0]._rawentry,
+                )), self._getreprcrash())
+
+        fmt = FormattedExcinfo(showlocals=showlocals, style=style,
+            abspath=abspath, tbfilter=tbfilter, funcargs=funcargs)
+        return fmt.repr_excinfo(self)
+
+    def __str__(self):
+        entry = self.traceback[-1]
+        loc = ReprFileLocation(entry.path, entry.lineno + 1, self.exconly())
+        return str(loc)
+
+    def __unicode__(self):
+        entry = self.traceback[-1]
+        loc = ReprFileLocation(entry.path, entry.lineno + 1, self.exconly())
+        return unicode(loc)
+
+
+class FormattedExcinfo(object):
+    """ presenting information about failing Functions and Generators. """
+    # for traceback entries
+    flow_marker = ">"
+    fail_marker = "E"
+
+    def __init__(self, showlocals=False, style="long", abspath=True, tbfilter=True, funcargs=False):
+        self.showlocals = showlocals
+        self.style = style
+        self.tbfilter = tbfilter
+        self.funcargs = funcargs
+        self.abspath = abspath
+        self.astcache = {}
+
+    def _getindent(self, source):
+        # figure out indent for given source
+        try:
+            s = str(source.getstatement(len(source)-1))
+        except KeyboardInterrupt:
+            raise
+        except:
+            try:
+                s = str(source[-1])
+            except KeyboardInterrupt:
+                raise
+            except:
+                return 0
+        return 4 + (len(s) - len(s.lstrip()))
+
+    def _getentrysource(self, entry):
+        source = entry.getsource(self.astcache)
+        if source is not None:
+            source = source.deindent()
+        return source
+
+    def _saferepr(self, obj):
+        return py.io.saferepr(obj)
+
+    def repr_args(self, entry):
+        if self.funcargs:
+            args = []
+            for argname, argvalue in entry.frame.getargs(var=True):
+                args.append((argname, self._saferepr(argvalue)))
+            return ReprFuncArgs(args)
+
+    def get_source(self, source, line_index=-1, excinfo=None, short=False):
+        """ return formatted and marked up source lines. """
+        import _pytest._code
+        lines = []
+        if source is None or line_index >= len(source.lines):
+            source = _pytest._code.Source("???")
+            line_index = 0
+        if line_index < 0:
+            line_index += len(source)
+        space_prefix = "    "
+        if short:
+            lines.append(space_prefix + source.lines[line_index].strip())
+        else:
+            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:]:
+                lines.append(space_prefix + line)
+        if excinfo is not None:
+            indent = 4 if short else self._getindent(source)
+            lines.extend(self.get_exconly(excinfo, indent=indent, markall=True))
+        return lines
+
+    def get_exconly(self, excinfo, indent=4, markall=False):
+        lines = []
+        indent = " " * indent
+        # get the real exception information out
+        exlines = excinfo.exconly(tryshort=True).split('\n')
+        failindent = self.fail_marker + indent[1:]
+        for line in exlines:
+            lines.append(failindent + line)
+            if not markall:
+                failindent = indent
+        return lines
+
+    def repr_locals(self, locals):
+        if self.showlocals:
+            lines = []
+            keys = [loc for loc in locals if loc[0] != "@"]
+            keys.sort()
+            for name in keys:
+                value = locals[name]
+                if name == '__builtins__':
+                    lines.append("__builtins__ = <builtins>")
+                else:
+                    # This formatting could all be handled by the
+                    # _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,
+                    #                            (list, tuple, dict)):
+                    lines.append("%-10s = %s" %(name, str_repr))
+                    #else:
+                    #    self._line("%-10s =\\" % (name,))
+                    #    # XXX
+                    #    py.std.pprint.pprint(value, stream=self.excinfowriter)
+            return ReprLocals(lines)
+
+    def repr_traceback_entry(self, entry, excinfo=None):
+        import _pytest._code
+        source = self._getentrysource(entry)
+        if source is None:
+            source = _pytest._code.Source("???")
+            line_index = 0
+        else:
+            # entry.getfirstlinesource() can be -1, should be 0 on jython
+            line_index = entry.lineno - max(entry.getfirstlinesource(), 0)
+
+        lines = []
+        style = entry._repr_style
+        if style is None:
+            style = self.style
+        if style in ("short", "long"):
+            short = style == "short"
+            reprargs = self.repr_args(entry) if not short else None
+            s = self.get_source(source, line_index, excinfo, short=short)
+            lines.extend(s)
+            if short:
+                message = "in %s" %(entry.name)
+            else:
+                message = excinfo and excinfo.typename or ""
+            path = self._makepath(entry.path)
+            filelocrepr = ReprFileLocation(path, entry.lineno+1, message)
+            localsrepr = None
+            if not short:
+                localsrepr =  self.repr_locals(entry.locals)
+            return ReprEntry(lines, reprargs, localsrepr, filelocrepr, style)
+        if excinfo:
+            lines.extend(self.get_exconly(excinfo, indent=4))
+        return ReprEntry(lines, None, None, None, style)
+
+    def _makepath(self, path):
+        if not self.abspath:
+            try:
+                np = py.path.local().bestrelpath(path)
+            except OSError:
+                return path
+            if len(np) < len(str(path)):
+                path = np
+        return path
+
+    def repr_traceback(self, excinfo):
+        traceback = excinfo.traceback
+        if self.tbfilter:
+            traceback = traceback.filter()
+        recursionindex = None
+        if excinfo.errisinstance(RuntimeError):
+            if "maximum recursion depth exceeded" in str(excinfo.value):
+                recursionindex = traceback.recursionindex()
+        last = traceback[-1]
+        entries = []
+        extraline = None
+        for index, entry in enumerate(traceback):
+            einfo = (last == entry) and excinfo or None
+            reprentry = self.repr_traceback_entry(entry, einfo)
+            entries.append(reprentry)
+            if index == recursionindex:
+                extraline = "!!! Recursion detected (same locals & position)"
+                break
+        return ReprTraceback(entries, extraline, style=self.style)
+
+    def repr_excinfo(self, excinfo):
+        reprtraceback = self.repr_traceback(excinfo)
+        reprcrash = excinfo._getreprcrash()
+        return ReprExceptionInfo(reprtraceback, reprcrash)
+
+class TerminalRepr:
+    def __str__(self):
+        s = self.__unicode__()
+        if sys.version_info[0] < 3:
+            s = s.encode('utf-8')
+        return s
+
+    def __unicode__(self):
+        # FYI this is called from pytest-xdist's serialization of exception
+        # information.
+        io = py.io.TextIO()
+        tw = py.io.TerminalWriter(file=io)
+        self.toterminal(tw)
+        return io.getvalue().strip()
+
+    def __repr__(self):
+        return "<%s instance at %0x>" %(self.__class__, id(self))
+
+
+class ReprExceptionInfo(TerminalRepr):
+    def __init__(self, reprtraceback, reprcrash):
+        self.reprtraceback = reprtraceback
+        self.reprcrash = reprcrash
+        self.sections = []
+
+    def addsection(self, name, content, sep="-"):
+        self.sections.append((name, content, sep))
+
+    def toterminal(self, tw):
+        self.reprtraceback.toterminal(tw)
+        for name, content, sep in self.sections:
+            tw.sep(sep, name)
+            tw.line(content)
+
+class ReprTraceback(TerminalRepr):
+    entrysep = "_ "
+
+    def __init__(self, reprentries, extraline, style):
+        self.reprentries = reprentries
+        self.extraline = extraline
+        self.style = style
+
+    def toterminal(self, tw):
+        # the entries might have different styles
+        for i, entry in enumerate(self.reprentries):
+            if entry.style == "long":
+                tw.line("")
+            entry.toterminal(tw)
+            if i < len(self.reprentries) - 1:
+                next_entry = self.reprentries[i+1]
+                if entry.style == "long" or \
+                   entry.style == "short" and next_entry.style == "long":
+                    tw.sep(self.entrysep)
+
+        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"
+
+    def __init__(self, tblines):
+        self.lines = tblines
+
+    def toterminal(self, tw):
+        tw.write("".join(self.lines))
+
+class ReprEntry(TerminalRepr):
+    localssep = "_ "
+
+    def __init__(self, lines, reprfuncargs, reprlocals, filelocrepr, style):
+        self.lines = lines
+        self.reprfuncargs = reprfuncargs
+        self.reprlocals = reprlocals
+        self.reprfileloc = filelocrepr
+        self.style = style
+
+    def toterminal(self, tw):
+        if self.style == "short":
+            self.reprfileloc.toterminal(tw)
+            for line in self.lines:
+                red = line.startswith("E   ")
+                tw.line(line, bold=True, red=red)
+            #tw.line("")
+            return
+        if self.reprfuncargs:
+            self.reprfuncargs.toterminal(tw)
+        for line in self.lines:
+            red = line.startswith("E   ")
+            tw.line(line, bold=True, red=red)
+        if self.reprlocals:
+            #tw.sep(self.localssep, "Locals")
+            tw.line("")
+            self.reprlocals.toterminal(tw)
+        if self.reprfileloc:
+            if self.lines:
+                tw.line("")
+            self.reprfileloc.toterminal(tw)
+
+    def __str__(self):
+        return "%s\n%s\n%s" % ("\n".join(self.lines),
+                               self.reprlocals,
+                               self.reprfileloc)
+
+class ReprFileLocation(TerminalRepr):
+    def __init__(self, path, lineno, message):
+        self.path = str(path)
+        self.lineno = lineno
+        self.message = message
+
+    def toterminal(self, tw):
+        # filename and lineno output for each entry,
+        # using an output format that most editors unterstand
+        msg = self.message
+        i = msg.find("\n")
+        if i != -1:
+            msg = msg[:i]
+        tw.line("%s:%s: %s" %(self.path, self.lineno, msg))
+
+class ReprLocals(TerminalRepr):
+    def __init__(self, lines):
+        self.lines = lines
+
+    def toterminal(self, tw):
+        for line in self.lines:
+            tw.line(line)
+
+class ReprFuncArgs(TerminalRepr):
+    def __init__(self, args):
+        self.args = args
+
+    def toterminal(self, tw):
+        if self.args:
+            linesofar = ""
+            for name, value in self.args:
+                ns = "%s = %s" %(name, value)
+                if len(ns) + len(linesofar) + 2 > tw.fullwidth:
+                    if linesofar:
+                        tw.line(linesofar)
+                    linesofar =  ns
+                else:
+                    if linesofar:
+                        linesofar += ", " + ns
+                    else:
+                        linesofar = ns
+            if linesofar:
+                tw.line(linesofar)
+            tw.line("")
+
+
+
+oldbuiltins = {}
+
+def patch_builtins(assertion=True, compile=True):
+    """ put compile and AssertionError builtins to Python's builtins. """
+    if assertion:
+        from _pytest.assertion import reinterpret
+        l = oldbuiltins.setdefault('AssertionError', [])
+        l.append(py.builtin.builtins.AssertionError)
+        py.builtin.builtins.AssertionError = reinterpret.AssertionError
+    if compile:
+        import _pytest._code
+        l = oldbuiltins.setdefault('compile', [])
+        l.append(py.builtin.builtins.compile)
+        py.builtin.builtins.compile = _pytest._code.compile
+
+def unpatch_builtins(assertion=True, compile=True):
+    """ remove compile and AssertionError builtins from Python builtins. """
+    if assertion:
+        py.builtin.builtins.AssertionError = oldbuiltins['AssertionError'].pop()
+    if compile:
+        py.builtin.builtins.compile = oldbuiltins['compile'].pop()
+
+def getrawcode(obj, trycall=True):
+    """ return code object for given function. """
+    try:
+        return obj.__code__
+    except AttributeError:
+        obj = getattr(obj, 'im_func', obj)
+        obj = getattr(obj, 'func_code', obj)
+        obj = getattr(obj, 'f_code', obj)
+        obj = getattr(obj, '__code__', obj)
+        if trycall and not hasattr(obj, 'co_firstlineno'):
+            if hasattr(obj, '__call__') and not py.std.inspect.isclass(obj):
+                x = getrawcode(obj.__call__, trycall=False)
+                if hasattr(x, 'co_firstlineno'):
+                    return x
+        return obj
+

_pytest/_code/source.py

@@ -0,0 +1,421 @@
+from __future__ import generators
+
+from bisect import bisect_right
+import sys
+import inspect, tokenize
+import py
+from types import ModuleType
+cpy_compile = compile
+
+try:
+    import _ast
+    from _ast import PyCF_ONLY_AST as _AST_FLAG
+except ImportError:
+    _AST_FLAG = 0
+    _ast = None
+
+
+class Source(object):
+    """ a immutable object holding a source code fragment,
+        possibly deindenting it.
+    """
+    _compilecounter = 0
+    def __init__(self, *parts, **kwargs):
+        self.lines = lines = []
+        de = kwargs.get('deindent', True)
+        rstrip = kwargs.get('rstrip', True)
+        for part in parts:
+            if not part:
+                partlines = []
+            if isinstance(part, Source):
+                partlines = part.lines
+            elif isinstance(part, (tuple, list)):
+                partlines = [x.rstrip("\n") for x in part]
+            elif isinstance(part, py.builtin._basestring):
+                partlines = part.split('\n')
+                if rstrip:
+                    while partlines:
+                        if partlines[-1].strip():
+                            break
+                        partlines.pop()
+            else:
+                partlines = getsource(part, deindent=de).lines
+            if de:
+                partlines = deindent(partlines)
+            lines.extend(partlines)
+
+    def __eq__(self, other):
+        try:
+            return self.lines == other.lines
+        except AttributeError:
+            if isinstance(other, str):
+                return str(self) == other
+            return False
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            return self.lines[key]
+        else:
+            if key.step not in (None, 1):
+                raise IndexError("cannot slice a Source with a step")
+            return self.__getslice__(key.start, key.stop)
+
+    def __len__(self):
+        return len(self.lines)
+
+    def __getslice__(self, start, end):
+        newsource = Source()
+        newsource.lines = self.lines[start:end]
+        return newsource
+
+    def strip(self):
+        """ return new source object with trailing
+            and leading blank lines removed.
+        """
+        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():
+            end -= 1
+        source = Source()
+        source.lines[:] = self.lines[start:end]
+        return source
+
+    def putaround(self, before='', after='', indent=' ' * 4):
+        """ return a copy of the source object with
+            'before' and 'after' wrapped around it.
+        """
+        before = Source(before)
+        after = Source(after)
+        newsource = Source()
+        lines = [ (indent + line) for line in self.lines]
+        newsource.lines = before.lines + lines +  after.lines
+        return newsource
+
+    def indent(self, indent=' ' * 4):
+        """ return a copy of the source object with
+            all lines indented by the given indent-string.
+        """
+        newsource = Source()
+        newsource.lines = [(indent+line) for line in self.lines]
+        return newsource
+
+    def getstatement(self, lineno, assertion=False):
+        """ return Source statement which contains the
+            given linenumber (counted from 0).
+        """
+        start, end = self.getstatementrange(lineno, assertion)
+        return self[start:end]
+
+    def getstatementrange(self, lineno, assertion=False):
+        """ return (start, end) tuple which spans the minimal
+            statement region which containing the given lineno.
+        """
+        if not (0 <= lineno < len(self)):
+            raise IndexError("lineno out of range")
+        ast, start, end = getstatementrange_ast(lineno, self)
+        return start, end
+
+    def deindent(self, offset=None):
+        """ return a new source object deindented by offset.
+            If offset is None then guess an indentation offset from
+            the first non-blank line.  Subsequent lines which have a
+            lower indentation offset will be copied verbatim as
+            they are assumed to be part of multilines.
+        """
+        # XXX maybe use the tokenizer to properly handle multiline
+        #     strings etc.pp?
+        newsource = Source()
+        newsource.lines[:] = deindent(self.lines, offset)
+        return newsource
+
+    def isparseable(self, deindent=True):
+        """ return True if source is parseable, heuristically
+            deindenting it by default.
+        """
+        try:
+            import parser
+        except ImportError:
+            syntax_checker = lambda x: compile(x, 'asd', 'exec')
+        else:
+            syntax_checker = parser.suite
+
+        if deindent:
+            source = str(self.deindent())
+        else:
+            source = str(self)
+        try:
+            #compile(source+'\n', "x", "exec")
+            syntax_checker(source+'\n')
+        except KeyboardInterrupt:
+            raise
+        except Exception:
+            return False
+        else:
+            return True
+
+    def __str__(self):
+        return "\n".join(self.lines)
+
+    def compile(self, filename=None, mode='exec',
+                flag=generators.compiler_flag,
+                dont_inherit=0, _genframe=None):
+        """ return compiled code object. if filename is None
+            invent an artificial filename which displays
+            the source/line position of the caller frame.
+        """
+        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
+            base = "<%d-codegen " % self._compilecounter
+            self.__class__._compilecounter += 1
+            if not filename:
+                filename = base + '%s:%d>' % (fn, lineno)
+            else:
+                filename = base + '%r %s:%d>' % (filename, fn, lineno)
+        source = "\n".join(self.lines) + '\n'
+        try:
+            co = cpy_compile(source, filename, mode, flag)
+        except SyntaxError:
+            ex = sys.exc_info()[1]
+            # re-represent syntax errors from parsing python strings
+            msglines = self.lines[:ex.lineno]
+            if 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
+            newex.lineno = ex.lineno
+            newex.text = ex.text
+            raise newex
+        else:
+            if flag & _AST_FLAG:
+                return co
+            lines = [(x + "\n") for x in self.lines]
+            if sys.version_info[0] >= 3:
+                # XXX py3's inspect.getsourcefile() checks for a module
+                # and a pep302 __loader__ ... we don't have a module
+                # at code compile-time so we need to fake it here
+                m = ModuleType("_pycodecompile_pseudo_module")
+                py.std.inspect.modulesbyfile[filename] = None
+                py.std.sys.modules[None] = m
+                m.__loader__ = 1
+            py.std.linecache.cache[filename] = (1, None, lines, filename)
+            return co
+
+#
+# public API shortcut functions
+#
+
+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
+        and any recursively created code objects.
+    """
+    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
+    s = Source(source)
+    co = s.compile(filename, mode, flags, _genframe=_genframe)
+    return co
+
+
+def getfslineno(obj):
+    """ Return source location (path, lineno) for the given object.
+    If the source cannot be determined return ("", -1)
+    """
+    import _pytest._code
+    try:
+        code = _pytest._code.Code(obj)
+    except TypeError:
+        try:
+            fn = (py.std.inspect.getsourcefile(obj) or
+                  py.std.inspect.getfile(obj))
+        except TypeError:
+            return "", -1
+
+        fspath = fn and py.path.local(fn) or None
+        lineno = -1
+        if fspath:
+            try:
+                _, lineno = findsource(obj)
+            except IOError:
+                pass
+    else:
+        fspath = code.path
+        lineno = code.firstlineno
+    assert isinstance(lineno, int)
+    return fspath, lineno
+
+#
+# helper functions
+#
+
+def findsource(obj):
+    try:
+        sourcelines, lineno = py.std.inspect.findsource(obj)
+    except py.builtin._sysex:
+        raise
+    except:
+        return None, -1
+    source = Source()
+    source.lines = [line.rstrip() for line in sourcelines]
+    return source, lineno
+
+def getsource(obj, **kwargs):
+    import _pytest._code
+    obj = _pytest._code.getrawcode(obj)
+    try:
+        strsrc = inspect.getsource(obj)
+    except IndentationError:
+        strsrc = "\"Buggy python version consider upgrading, cannot get source\""
+    assert isinstance(strsrc, str)
+    return Source(strsrc, **kwargs)
+
+def deindent(lines, offset=None):
+    if offset is None:
+        for line in lines:
+            line = line.expandtabs()
+            s = line.lstrip()
+            if s:
+                offset = len(line)-len(s)
+                break
+        else:
+            offset = 0
+    if offset == 0:
+        return list(lines)
+    newlines = []
+    def readline_generator(lines):
+        for line in lines:
+            yield line + '\n'
+        while True:
+            yield ''
+
+    it = readline_generator(lines)
+
+    try:
+        for _, _, (sline, _), (eline, _), _ in tokenize.generate_tokens(lambda: next(it)):
+            if sline > len(lines):
+                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
+                newlines.append(line)
+
+            for i in range(sline, eline):
+                # Don't deindent continuing lines of
+                # multiline tokens (i.e. multiline strings)
+                newlines.append(lines[i])
+    except (IndentationError, tokenize.TokenError):
+        pass
+    # Add any lines we didn't see. E.g. if an exception was raised.
+    newlines.extend(lines[len(newlines):])
+    return newlines
+
+
+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 = []
+    for x in ast.walk(node):
+        if isinstance(x, _ast.stmt) or isinstance(x, _ast.ExceptHandler):
+            l.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):
+        end = None
+    else:
+        end = l[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):
+            content += "\n"
+        try:
+            astnode = compile(content, "source", "exec", 1024)  # 1024 for AST
+        except ValueError:
+            start, end = getstatementrange_old(lineno, source, assertion)
+            return None, start, end
+    start, end = get_statement_startend2(lineno, astnode)
+    # we need to correct the end:
+    # - ast-parsing strips comments
+    # - there might be empty lines
+    # - we might have lesser indented code blocks at the end
+    if end is None:
+        end = len(source.lines)
+
+    if end > start + 1:
+        # make sure we don't span differently indented code blocks
+        # by using the BlockFinder helper used which inspect.getsource() uses itself
+        block_finder = inspect.BlockFinder()
+        # if we start with an indented line, put blockfinder to "started" mode
+        block_finder.started = source.lines[start][0].isspace()
+        it = ((x + "\n") for x in source.lines[start:end])
+        try:
+            for tok in tokenize.generate_tokens(lambda: next(it)):
+                block_finder.tokeneater(*tok)
+        except (inspect.EndOfBlock, IndentationError):
+            end = block_finder.last + start
+        except Exception:
+            pass
+
+    # the end might still point to a comment or empty line, correct it
+    while end:
+        line = source.lines[end - 1].lstrip()
+        if line.startswith("#") or not line:
+            end -= 1
+        else:
+            break
+    return astnode, start, end
+
+
+def getstatementrange_old(lineno, source, assertion=False):
+    """ return (start, end) tuple which spans the minimal
+        statement region which containing the given lineno.
+        raise an IndexError if no such statementrange can be found.
+    """
+    # XXX this logic is only used on python2.4 and below
+    # 1. find the start of the statement
+    from codeop import compile_command
+    for start in range(lineno, -1, -1):
+        if assertion:
+            line = source.lines[start]
+            # the following lines are not fully tested, change with care
+            if 'super' in line and 'self' in line and '__init__' in line:
+                raise IndexError("likely a subclass")
+            if "assert" not in line and "raise" not in line:
+                continue
+        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():')
+        trysource = '\n '.join(trylines)
+        #              ^ space here
+        try:
+            compile_command(trysource)
+        except (SyntaxError, OverflowError, ValueError):
+            continue
+
+        # 2. find the end of the statement
+        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

@@ -2,6 +2,7 @@
 support for presenting detailed information in failing assertions.
 """
 import py
+import os
 import sys
 from _pytest.monkeypatch import monkeypatch
 from _pytest.assertion import util
@@ -86,6 +87,12 @@ def pytest_collection(session):
         hook.set_session(session)
 
 
+def _running_on_ci():
+    """Check if we're currently running on a CI system."""
+    env_vars = ['CI', 'BUILD_NUMBER']
+    return any(var in os.environ for var in env_vars)
+
+
 def pytest_runtest_setup(item):
     """Setup the pytest_assertrepr_compare hook
 
@@ -99,7 +106,8 @@ def pytest_runtest_setup(item):
 
         This uses the first result from the hook and then ensures the
         following:
-        * Overly verbose explanations are dropped unles -vv was used.
+        * Overly verbose explanations are dropped unless -vv was used or
+          running on a CI.
         * Embedded newlines are escaped to help util.format_explanation()
           later.
         * If the rewrite mode is used embedded %-characters are replaced
@@ -113,7 +121,8 @@ def pytest_runtest_setup(item):
         for new_expl in hook_result:
             if new_expl:
                 if (sum(len(p) for p in new_expl[1:]) > 80*8 and
-                        item.config.option.verbose < 2):
+                        item.config.option.verbose < 2 and
+                        not _running_on_ci()):
                     show_max = 10
                     truncated_lines = len(new_expl) - show_max
                     new_expl[show_max:] = [py.builtin._totext(

_pytest/assertion/newinterpret.py

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

_pytest/assertion/oldinterpret.py

@@ -1,566 +0,0 @@
-import traceback
-import types
-import py
-import sys, inspect
-from compiler import parse, ast, pycodegen
-from _pytest.assertion.util import format_explanation, BuiltinAssertionError
-
-passthroughex = py.builtin._sysex
-
-class Failure:
-    def __init__(self, node):
-        self.exc, self.value, self.tb = sys.exc_info()
-        self.node = node
-
-class View(object):
-    """View base class.
-
-    If C is a subclass of View, then C(x) creates a proxy object around
-    the object x.  The actual class of the proxy is not C in general,
-    but a *subclass* of C determined by the rules below.  To avoid confusion
-    we call view class the class of the proxy (a subclass of C, so of View)
-    and object class the class of x.
-
-    Attributes and methods not found in the proxy are automatically read on x.
-    Other operations like setting attributes are performed on the proxy, as
-    determined by its view class.  The object x is available from the proxy
-    as its __obj__ attribute.
-
-    The view class selection is determined by the __view__ tuples and the
-    optional __viewkey__ method.  By default, the selected view class is the
-    most specific subclass of C whose __view__ mentions the class of x.
-    If no such subclass is found, the search proceeds with the parent
-    object classes.  For example, C(True) will first look for a subclass
-    of C with __view__ = (..., bool, ...) and only if it doesn't find any
-    look for one with __view__ = (..., int, ...), and then ..., object,...
-    If everything fails the class C itself is considered to be the default.
-
-    Alternatively, the view class selection can be driven by another aspect
-    of the object x, instead of the class of x, by overriding __viewkey__.
-    See last example at the end of this module.
-    """
-
-    _viewcache = {}
-    __view__ = ()
-
-    def __new__(rootclass, obj, *args, **kwds):
-        self = object.__new__(rootclass)
-        self.__obj__ = obj
-        self.__rootclass__ = rootclass
-        key = self.__viewkey__()
-        try:
-            self.__class__ = self._viewcache[key]
-        except KeyError:
-            self.__class__ = self._selectsubclass(key)
-        return self
-
-    def __getattr__(self, attr):
-        # attributes not found in the normal hierarchy rooted on View
-        # are looked up in the object's real class
-        return getattr(object.__getattribute__(self, '__obj__'), attr)
-
-    def __viewkey__(self):
-        return self.__obj__.__class__
-
-    def __matchkey__(self, key, subclasses):
-        if inspect.isclass(key):
-            keys = inspect.getmro(key)
-        else:
-            keys = [key]
-        for key in keys:
-            result = [C for C in subclasses if key in C.__view__]
-            if result:
-                return result
-        return []
-
-    def _selectsubclass(self, key):
-        subclasses = list(enumsubclasses(self.__rootclass__))
-        for C in subclasses:
-            if not isinstance(C.__view__, tuple):
-                C.__view__ = (C.__view__,)
-        choices = self.__matchkey__(key, subclasses)
-        if not choices:
-            return self.__rootclass__
-        elif len(choices) == 1:
-            return choices[0]
-        else:
-            # combine the multiple choices
-            return type('?', tuple(choices), {})
-
-    def __repr__(self):
-        return '%s(%r)' % (self.__rootclass__.__name__, self.__obj__)
-
-
-def enumsubclasses(cls):
-    for subcls in cls.__subclasses__():
-        for subsubclass in enumsubclasses(subcls):
-            yield subsubclass
-    yield cls
-
-
-class Interpretable(View):
-    """A parse tree node with a few extra methods."""
-    explanation = None
-
-    def is_builtin(self, frame):
-        return False
-
-    def eval(self, frame):
-        # fall-back for unknown expression nodes
-        try:
-            expr = ast.Expression(self.__obj__)
-            expr.filename = '<eval>'
-            self.__obj__.filename = '<eval>'
-            co = pycodegen.ExpressionCodeGenerator(expr).getCode()
-            result = frame.eval(co)
-        except passthroughex:
-            raise
-        except:
-            raise Failure(self)
-        self.result = result
-        self.explanation = self.explanation or frame.repr(self.result)
-
-    def run(self, frame):
-        # fall-back for unknown statement nodes
-        try:
-            expr = ast.Module(None, ast.Stmt([self.__obj__]))
-            expr.filename = '<run>'
-            co = pycodegen.ModuleCodeGenerator(expr).getCode()
-            frame.exec_(co)
-        except passthroughex:
-            raise
-        except:
-            raise Failure(self)
-
-    def nice_explanation(self):
-        return format_explanation(self.explanation)
-
-
-class Name(Interpretable):
-    __view__ = ast.Name
-
-    def is_local(self, frame):
-        source = '%r in locals() is not globals()' % self.name
-        try:
-            return frame.is_true(frame.eval(source))
-        except passthroughex:
-            raise
-        except:
-            return False
-
-    def is_global(self, frame):
-        source = '%r in globals()' % self.name
-        try:
-            return frame.is_true(frame.eval(source))
-        except passthroughex:
-            raise
-        except:
-            return False
-
-    def is_builtin(self, frame):
-        source = '%r not in locals() and %r not in globals()' % (
-            self.name, self.name)
-        try:
-            return frame.is_true(frame.eval(source))
-        except passthroughex:
-            raise
-        except:
-            return False
-
-    def eval(self, frame):
-        super(Name, self).eval(frame)
-        if not self.is_local(frame):
-            self.explanation = self.name
-
-class Compare(Interpretable):
-    __view__ = ast.Compare
-
-    def eval(self, frame):
-        expr = Interpretable(self.expr)
-        expr.eval(frame)
-        for operation, expr2 in self.ops:
-            if hasattr(self, 'result'):
-                # shortcutting in chained expressions
-                if not frame.is_true(self.result):
-                    break
-            expr2 = Interpretable(expr2)
-            expr2.eval(frame)
-            self.explanation = "%s %s %s" % (
-                expr.explanation, operation, expr2.explanation)
-            source = "__exprinfo_left %s __exprinfo_right" % operation
-            try:
-                self.result = frame.eval(source,
-                                         __exprinfo_left=expr.result,
-                                         __exprinfo_right=expr2.result)
-            except passthroughex:
-                raise
-            except:
-                raise Failure(self)
-            expr = expr2
-
-class And(Interpretable):
-    __view__ = ast.And
-
-    def eval(self, frame):
-        explanations = []
-        for expr in self.nodes:
-            expr = Interpretable(expr)
-            expr.eval(frame)
-            explanations.append(expr.explanation)
-            self.result = expr.result
-            if not frame.is_true(expr.result):
-                break
-        self.explanation = '(' + ' and '.join(explanations) + ')'
-
-class Or(Interpretable):
-    __view__ = ast.Or
-
-    def eval(self, frame):
-        explanations = []
-        for expr in self.nodes:
-            expr = Interpretable(expr)
-            expr.eval(frame)
-            explanations.append(expr.explanation)
-            self.result = expr.result
-            if frame.is_true(expr.result):
-                break
-        self.explanation = '(' + ' or '.join(explanations) + ')'
-
-
-# == Unary operations ==
-keepalive = []
-for astclass, astpattern in {
-    ast.Not    : 'not __exprinfo_expr',
-    ast.Invert : '(~__exprinfo_expr)',
-    }.items():
-
-    class UnaryArith(Interpretable):
-        __view__ = astclass
-
-        def eval(self, frame, astpattern=astpattern):
-            expr = Interpretable(self.expr)
-            expr.eval(frame)
-            self.explanation = astpattern.replace('__exprinfo_expr',
-                                                  expr.explanation)
-            try:
-                self.result = frame.eval(astpattern,
-                                         __exprinfo_expr=expr.result)
-            except passthroughex:
-                raise
-            except:
-                raise Failure(self)
-
-    keepalive.append(UnaryArith)
-
-# == Binary operations ==
-for astclass, astpattern in {
-    ast.Add    : '(__exprinfo_left + __exprinfo_right)',
-    ast.Sub    : '(__exprinfo_left - __exprinfo_right)',
-    ast.Mul    : '(__exprinfo_left * __exprinfo_right)',
-    ast.Div    : '(__exprinfo_left / __exprinfo_right)',
-    ast.Mod    : '(__exprinfo_left % __exprinfo_right)',
-    ast.Power  : '(__exprinfo_left ** __exprinfo_right)',
-    }.items():
-
-    class BinaryArith(Interpretable):
-        __view__ = astclass
-
-        def eval(self, frame, astpattern=astpattern):
-            left = Interpretable(self.left)
-            left.eval(frame)
-            right = Interpretable(self.right)
-            right.eval(frame)
-            self.explanation = (astpattern
-                                .replace('__exprinfo_left',  left .explanation)
-                                .replace('__exprinfo_right', right.explanation))
-            try:
-                self.result = frame.eval(astpattern,
-                                         __exprinfo_left=left.result,
-                                         __exprinfo_right=right.result)
-            except passthroughex:
-                raise
-            except:
-                raise Failure(self)
-
-    keepalive.append(BinaryArith)
-
-
-class CallFunc(Interpretable):
-    __view__ = ast.CallFunc
-
-    def is_bool(self, frame):
-        source = 'isinstance(__exprinfo_value, bool)'
-        try:
-            return frame.is_true(frame.eval(source,
-                                            __exprinfo_value=self.result))
-        except passthroughex:
-            raise
-        except:
-            return False
-
-    def eval(self, frame):
-        node = Interpretable(self.node)
-        node.eval(frame)
-        explanations = []
-        vars = {'__exprinfo_fn': node.result}
-        source = '__exprinfo_fn('
-        for a in self.args:
-            if isinstance(a, ast.Keyword):
-                keyword = a.name
-                a = a.expr
-            else:
-                keyword = None
-            a = Interpretable(a)
-            a.eval(frame)
-            argname = '__exprinfo_%d' % len(vars)
-            vars[argname] = a.result
-            if keyword is None:
-                source += argname + ','
-                explanations.append(a.explanation)
-            else:
-                source += '%s=%s,' % (keyword, argname)
-                explanations.append('%s=%s' % (keyword, a.explanation))
-        if self.star_args:
-            star_args = Interpretable(self.star_args)
-            star_args.eval(frame)
-            argname = '__exprinfo_star'
-            vars[argname] = star_args.result
-            source += '*' + argname + ','
-            explanations.append('*' + star_args.explanation)
-        if self.dstar_args:
-            dstar_args = Interpretable(self.dstar_args)
-            dstar_args.eval(frame)
-            argname = '__exprinfo_kwds'
-            vars[argname] = dstar_args.result
-            source += '**' + argname + ','
-            explanations.append('**' + dstar_args.explanation)
-        self.explanation = "%s(%s)" % (
-            node.explanation, ', '.join(explanations))
-        if source.endswith(','):
-            source = source[:-1]
-        source += ')'
-        try:
-            self.result = frame.eval(source, **vars)
-        except passthroughex:
-            raise
-        except:
-            raise Failure(self)
-        if not node.is_builtin(frame) or not self.is_bool(frame):
-            r = frame.repr(self.result)
-            self.explanation = '%s\n{%s = %s\n}' % (r, r, self.explanation)
-
-class Getattr(Interpretable):
-    __view__ = ast.Getattr
-
-    def eval(self, frame):
-        expr = Interpretable(self.expr)
-        expr.eval(frame)
-        source = '__exprinfo_expr.%s' % self.attrname
-        try:
-            try:
-                self.result = frame.eval(source, __exprinfo_expr=expr.result)
-            except AttributeError:
-                # Maybe the attribute name needs to be mangled?
-                if (not self.attrname.startswith("__") or
-                    self.attrname.endswith("__")):
-                    raise
-                source = "getattr(__exprinfo_expr.__class__, '__name__', '')"
-                class_name = frame.eval(source, __exprinfo_expr=expr.result)
-                mangled_attr = "_" + class_name +  self.attrname
-                source = "__exprinfo_expr.%s" % (mangled_attr,)
-                self.result = frame.eval(source, __exprinfo_expr=expr.result)
-        except passthroughex:
-            raise
-        except:
-            raise Failure(self)
-        self.explanation = '%s.%s' % (expr.explanation, self.attrname)
-        # if the attribute comes from the instance, its value is interesting
-        source = ('hasattr(__exprinfo_expr, "__dict__") and '
-                  '%r in __exprinfo_expr.__dict__' % self.attrname)
-        try:
-            from_instance = frame.is_true(
-                frame.eval(source, __exprinfo_expr=expr.result))
-        except passthroughex:
-            raise
-        except:
-            from_instance = True
-        if from_instance:
-            r = frame.repr(self.result)
-            self.explanation = '%s\n{%s = %s\n}' % (r, r, self.explanation)
-
-# == Re-interpretation of full statements ==
-
-class Assert(Interpretable):
-    __view__ = ast.Assert
-
-    def run(self, frame):
-        test = Interpretable(self.test)
-        test.eval(frame)
-        # print the result as  'assert <explanation>'
-        self.result = test.result
-        self.explanation = 'assert ' + test.explanation
-        if not frame.is_true(test.result):
-            try:
-                raise BuiltinAssertionError
-            except passthroughex:
-                raise
-            except:
-                raise Failure(self)
-
-class Assign(Interpretable):
-    __view__ = ast.Assign
-
-    def run(self, frame):
-        expr = Interpretable(self.expr)
-        expr.eval(frame)
-        self.result = expr.result
-        self.explanation = '... = ' + expr.explanation
-        # fall-back-run the rest of the assignment
-        ass = ast.Assign(self.nodes, ast.Name('__exprinfo_expr'))
-        mod = ast.Module(None, ast.Stmt([ass]))
-        mod.filename = '<run>'
-        co = pycodegen.ModuleCodeGenerator(mod).getCode()
-        try:
-            frame.exec_(co, __exprinfo_expr=expr.result)
-        except passthroughex:
-            raise
-        except:
-            raise Failure(self)
-
-class Discard(Interpretable):
-    __view__ = ast.Discard
-
-    def run(self, frame):
-        expr = Interpretable(self.expr)
-        expr.eval(frame)
-        self.result = expr.result
-        self.explanation = expr.explanation
-
-class Stmt(Interpretable):
-    __view__ = ast.Stmt
-
-    def run(self, frame):
-        for stmt in self.nodes:
-            stmt = Interpretable(stmt)
-            stmt.run(frame)
-
-
-def report_failure(e):
-    explanation = e.node.nice_explanation()
-    if explanation:
-        explanation = ", in: " + explanation
-    else:
-        explanation = ""
-    sys.stdout.write("%s: %s%s\n" % (e.exc.__name__, e.value, explanation))
-
-def check(s, frame=None):
-    if frame is None:
-        frame = sys._getframe(1)
-        frame = py.code.Frame(frame)
-    expr = parse(s, 'eval')
-    assert isinstance(expr, ast.Expression)
-    node = Interpretable(expr.node)
-    try:
-        node.eval(frame)
-    except passthroughex:
-        raise
-    except Failure:
-        e = sys.exc_info()[1]
-        report_failure(e)
-    else:
-        if not frame.is_true(node.result):
-            sys.stderr.write("assertion failed: %s\n" % node.nice_explanation())
-
-
-###########################################################
-# API / Entry points
-# #########################################################
-
-def interpret(source, frame, should_fail=False):
-    module = Interpretable(parse(source, 'exec').node)
-    #print "got module", module
-    if isinstance(frame, types.FrameType):
-        frame = py.code.Frame(frame)
-    try:
-        module.run(frame)
-    except Failure:
-        e = sys.exc_info()[1]
-        return getfailure(e)
-    except passthroughex:
-        raise
-    except:
-        traceback.print_exc()
-    if should_fail:
-        return ("(assertion failed, but when it was re-run for "
-                "printing intermediate values, it did not fail.  Suggestions: "
-                "compute assert expression before the assert or use --assert=plain)")
-    else:
-        return None
-
-def getmsg(excinfo):
-    if isinstance(excinfo, tuple):
-        excinfo = py.code.ExceptionInfo(excinfo)
-    #frame, line = gettbline(tb)
-    #frame = py.code.Frame(frame)
-    #return interpret(line, frame)
-
-    tb = excinfo.traceback[-1]
-    source = str(tb.statement).strip()
-    x = interpret(source, tb.frame, should_fail=True)
-    if not isinstance(x, str):
-        raise TypeError("interpret returned non-string %r" % (x,))
-    return x
-
-def getfailure(e):
-    explanation = e.node.nice_explanation()
-    if str(e.value):
-        lines = explanation.split('\n')
-        lines[0] += "  << %s" % (e.value,)
-        explanation = '\n'.join(lines)
-    text = "%s: %s" % (e.exc.__name__, explanation)
-    if text.startswith('AssertionError: assert '):
-        text = text[16:]
-    return text
-
-def run(s, frame=None):
-    if frame is None:
-        frame = sys._getframe(1)
-        frame = py.code.Frame(frame)
-    module = Interpretable(parse(s, 'exec').node)
-    try:
-        module.run(frame)
-    except Failure:
-        e = sys.exc_info()[1]
-        report_failure(e)
-
-
-if __name__ == '__main__':
-    # example:
-    def f():
-        return 5
-
-    def g():
-        return 3
-
-    def h(x):
-        return 'never'
-
-    check("f() * g() == 5")
-    check("not f()")
-    check("not (f() and g() or 0)")
-    check("f() == g()")
-    i = 4
-    check("i == f()")
-    check("len(f()) == 0")
-    check("isinstance(2+3+4, float)")
-
-    run("x = i")
-    check("x == 5")
-
-    run("assert not f(), 'oops'")
-    run("a, b, c = 1, 2")
-    run("a, b, c = f()")
-
-    check("max([f(),g()]) == 4")
-    check("'hello'[g()] == 'h'")
-    run("'guk%d' % h(f())")

_pytest/assertion/reinterpret.py

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

_pytest/assertion/rewrite.py

@@ -453,6 +453,11 @@ binop_map = {
     ast.In: "in",
     ast.NotIn: "not in"
 }
+# Python 3.5+ compatibility
+try:
+    binop_map[ast.MatMult] = "@"
+except AttributeError:
+    pass
 
 # Python 3.4+ compatibility
 if hasattr(ast, "NameConstant"):

_pytest/assertion/util.py

@@ -1,6 +1,7 @@
 """Utilities for assertion debugging"""
 import pprint
 
+import _pytest._code
 import py
 try:
     from collections import Sequence
@@ -17,6 +18,15 @@ u = py.builtin._totext
 _reprcompare = None
 
 
+# the re-encoding is needed for python2 repr
+# with non-ascii characters (see issue 877 and 1379)
+def ecu(s):
+    try:
+        return u(s, 'utf-8', 'replace')
+    except TypeError:
+        return s
+
+
 def format_explanation(explanation):
     """This formats an explanation
 
@@ -27,6 +37,7 @@ def format_explanation(explanation):
     for when one explanation needs to span multiple lines, e.g. when
     displaying diffs.
     """
+    explanation = ecu(explanation)
     explanation = _collapse_false(explanation)
     lines = _split_explanation(explanation)
     result = _format_lines(lines)
@@ -130,14 +141,6 @@ def assertrepr_compare(config, op, left, right):
     left_repr = py.io.saferepr(left, maxsize=int(width/2))
     right_repr = py.io.saferepr(right, maxsize=width-len(left_repr))
 
-    # the re-encoding is needed for python2 repr
-    # with non-ascii characters (see issue 877)
-    def ecu(s):
-        try:
-            return u(s, 'utf-8', 'replace')
-        except TypeError:
-            return s
-
     summary = u('%s %s %s') % (ecu(left_repr), op, ecu(right_repr))
 
     issequence = lambda x: (isinstance(x, (list, tuple, Sequence)) and
@@ -179,7 +182,7 @@ def assertrepr_compare(config, op, left, right):
         explanation = [
             u('(pytest_assertion plugin: representation of details failed.  '
               'Probably an object has a faulty __repr__.)'),
-            u(py.code.ExceptionInfo())]
+            u(_pytest._code.ExceptionInfo())]
 
     if not explanation:
         return None

_pytest/cacheprovider.py

@@ -149,17 +149,19 @@ class LFPlugin:
         config = self.config
         if config.getvalue("cacheshow") or hasattr(config, "slaveinput"):
             return
-        config.cache.set("cache/lastfailed", self.lastfailed)
+        prev_failed = config.cache.get("cache/lastfailed", None) is not None
+        if (session.testscollected and prev_failed) or self.lastfailed:
+            config.cache.set("cache/lastfailed", self.lastfailed)
 
 
 def pytest_addoption(parser):
     group = parser.getgroup("general")
     group.addoption(
-        '--lf', action='store_true', dest="lf",
+        '--lf', '--last-failed', action='store_true', dest="lf",
         help="rerun only the tests that failed "
              "at the last run (or all if none failed)")
     group.addoption(
-        '--ff', action='store_true', dest="failedfirst",
+        '--ff', '--failed-first', action='store_true', dest="failedfirst",
         help="run all tests but run the last failures first.  "
              "This may re-order tests and thus lead to "
              "repeated fixture setup/teardown")

_pytest/config.py

@@ -8,6 +8,7 @@ import warnings
 import py
 # DON't import pytest here because it causes import cycle troubles
 import sys, os
+import _pytest._code
 import _pytest.hookspec  # the extension point definitions
 from _pytest._pluggy import PluginManager, HookimplMarker, HookspecMarker
 
@@ -158,7 +159,7 @@ class PytestPluginManager(PluginManager):
         Use :py:meth:`pluggy.PluginManager.add_hookspecs` instead.
         """
         warning = dict(code="I2",
-                       fslocation=py.code.getfslineno(sys._getframe(1)),
+                       fslocation=_pytest._code.getfslineno(sys._getframe(1)),
                        nodeid=None,
                        message="use pluginmanager.add_hookspecs instead of "
                                "deprecated addhooks() method.")
@@ -195,7 +196,7 @@ class PytestPluginManager(PluginManager):
     def _verify_hook(self, hook, hookmethod):
         super(PytestPluginManager, self)._verify_hook(hook, hookmethod)
         if "__multicall__" in hookmethod.argnames:
-            fslineno = py.code.getfslineno(hookmethod.function)
+            fslineno = _pytest._code.getfslineno(hookmethod.function)
             warning = dict(code="I1",
                            fslocation=fslineno,
                            nodeid=None,
@@ -382,8 +383,13 @@ class PytestPluginManager(PluginManager):
             importspec = modname
         try:
             __import__(importspec)
-        except ImportError:
-            raise
+        except ImportError as e:
+            new_exc = ImportError('Error importing plugin "%s": %s' % (modname, e))
+            # copy over name and path attributes
+            for attr in ('name', 'path'):
+                if hasattr(e, attr):
+                    setattr(new_exc, attr, getattr(e, attr))
+            raise new_exc
         except Exception as e:
             import pytest
             if not hasattr(pytest, 'skip') or not isinstance(e, pytest.skip.Exception):
@@ -455,11 +461,11 @@ class Parser:
         """
         self._anonymous.addoption(*opts, **attrs)
 
-    def parse(self, args):
+    def parse(self, args, namespace=None):
         from _pytest._argcomplete import try_argcomplete
         self.optparser = self._getparser()
         try_argcomplete(self.optparser)
-        return self.optparser.parse_args([str(x) for x in args])
+        return self.optparser.parse_args([str(x) for x in args], namespace=namespace)
 
     def _getparser(self):
         from _pytest._argcomplete import filescompleter
@@ -477,37 +483,38 @@ class Parser:
         optparser.add_argument(FILE_OR_DIR, nargs='*').completer=filescompleter
         return optparser
 
-    def parse_setoption(self, args, option):
-        parsedoption = self.parse(args)
+    def parse_setoption(self, args, option, namespace=None):
+        parsedoption = self.parse(args, namespace=namespace)
         for name, value in parsedoption.__dict__.items():
             setattr(option, name, value)
         return getattr(parsedoption, FILE_OR_DIR)
 
-    def parse_known_args(self, args):
+    def parse_known_args(self, args, namespace=None):
         """parses and returns a namespace object with known arguments at this
         point.
         """
-        return self.parse_known_and_unknown_args(args)[0]
+        return self.parse_known_and_unknown_args(args, namespace=namespace)[0]
 
-    def parse_known_and_unknown_args(self, args):
+    def parse_known_and_unknown_args(self, args, namespace=None):
         """parses and returns a namespace object with known arguments, and
         the remaining arguments unknown at this point.
         """
         optparser = self._getparser()
         args = [str(x) for x in args]
-        return optparser.parse_known_args(args)
+        return optparser.parse_known_args(args, namespace=namespace)
 
     def addini(self, name, help, type=None, default=None):
         """ register an ini-file option.
 
         :name: name of the ini-variable
-        :type: type of the variable, can be ``pathlist``, ``args`` or ``linelist``.
+        :type: type of the variable, can be ``pathlist``, ``args``, ``linelist``
+               or ``bool``.
         :default: default value if no ini-file option exists but is queried.
 
         The value of ini-variables can be retrieved via a call to
         :py:func:`config.getini(name) <_pytest.config.Config.getini>`.
         """
-        assert type in (None, "pathlist", "args", "linelist")
+        assert type in (None, "pathlist", "args", "linelist", "bool")
         self._inidict[name] = (help, type, default)
         self._ininames.append(name)
 
@@ -779,10 +786,12 @@ def _ensure_removed_sysmodule(modname):
 
 class CmdOptions(object):
     """ holds cmdline options as attributes."""
-    def __init__(self, **kwargs):
-        self.__dict__.update(kwargs)
+    def __init__(self, values=()):
+        self.__dict__.update(values)
     def __repr__(self):
         return "<CmdOptions %r>" %(self.__dict__,)
+    def copy(self):
+        return CmdOptions(self.__dict__)
 
 class Notset:
     def __repr__(self):
@@ -879,8 +888,8 @@ class Config(object):
     def fromdictargs(cls, option_dict, args):
         """ constructor useable for subprocesses. """
         config = get_config()
-        config._preparse(args, addopts=False)
         config.option.__dict__.update(option_dict)
+        config.parse(args, addopts=False)
         for x in config.option.plugins:
             config.pluginmanager.consider_pluginarg(x)
         return config
@@ -898,7 +907,7 @@ class Config(object):
         self.pluginmanager._set_initial_conftests(early_config.known_args_namespace)
 
     def _initini(self, args):
-        ns, unknown_args = self._parser.parse_known_and_unknown_args(args)
+        ns, unknown_args = self._parser.parse_known_and_unknown_args(args, namespace=self.option.copy())
         r = determine_setup(ns.inifilename, ns.file_or_dir + unknown_args)
         self.rootdir, self.inifile, self.inicfg = r
         self._parser.extra_info['rootdir'] = self.rootdir
@@ -919,7 +928,7 @@ class Config(object):
         except ImportError as e:
             self.warn("I2", "could not load setuptools entry import: %s" % (e,))
         self.pluginmanager.consider_env()
-        self.known_args_namespace = ns = self._parser.parse_known_args(args)
+        self.known_args_namespace = ns = self._parser.parse_known_args(args, namespace=self.option.copy())
         if self.known_args_namespace.confcutdir is None and self.inifile:
             confcutdir = py.path.local(self.inifile).dirname
             self.known_args_namespace.confcutdir = confcutdir
@@ -947,17 +956,17 @@ class Config(object):
                     self.inicfg.config.path, self.inicfg.lineof('minversion'),
                     minver, pytest.__version__))
 
-    def parse(self, args):
+    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")
         self._origargs = args
         self.hook.pytest_addhooks.call_historic(
                                   kwargs=dict(pluginmanager=self.pluginmanager))
-        self._preparse(args)
+        self._preparse(args, addopts=addopts)
         # XXX deprecated hook:
         self.hook.pytest_cmdline_preparse(config=self, args=args)
-        args = self._parser.parse_setoption(args, self.option)
+        args = self._parser.parse_setoption(args, self.option, namespace=self.option)
         if not args:
             cwd = os.getcwd()
             if cwd == self.rootdir:
@@ -1008,6 +1017,8 @@ class Config(object):
             return shlex.split(value)
         elif type == "linelist":
             return [t for t in map(lambda x: x.strip(), value.split("\n")) if t]
+        elif type == "bool":
+            return bool(_strtobool(value.strip()))
         else:
             assert type is None
             return value
@@ -1161,3 +1172,21 @@ def create_terminal_writer(config, *args, **kwargs):
     if config.option.color == 'no':
         tw.hasmarkup = False
     return tw
+
+
+def _strtobool(val):
+    """Convert a string representation of truth to true (1) or false (0).
+
+    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
+    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
+    'val' is anything else.
+
+    .. note:: copied from distutils.util
+    """
+    val = val.lower()
+    if val in ('y', 'yes', 't', 'true', 'on', '1'):
+        return 1
+    elif val in ('n', 'no', 'f', 'false', 'off', '0'):
+        return 0
+    else:
+        raise ValueError("invalid truth value %r" % (val,))

_pytest/doctest.py

@@ -1,9 +1,12 @@
 """ discover and run doctests in modules and test files."""
 from __future__ import absolute_import
+
 import traceback
-import pytest, py
+
+import pytest
+from _pytest._code.code import TerminalRepr, ReprFileLocation, ExceptionInfo
 from _pytest.python import FixtureRequest
-from py._code.code import TerminalRepr, ReprFileLocation
+
 
 
 def pytest_addoption(parser):
@@ -15,7 +18,7 @@ def pytest_addoption(parser):
         help="run doctests in all .py modules",
         dest="doctestmodules")
     group.addoption("--doctest-glob",
-        action="store", default="test*.txt", metavar="pat",
+        action="append", default=[], metavar="pat",
         help="doctests file matching pattern, default: test*.txt",
         dest="doctestglob")
     group.addoption("--doctest-ignore-import-errors",
@@ -29,11 +32,20 @@ def pytest_collect_file(path, parent):
     if path.ext == ".py":
         if config.option.doctestmodules:
             return DoctestModule(path, parent)
-    elif (path.ext in ('.txt', '.rst') and parent.session.isinitpath(path)) or \
-        path.check(fnmatch=config.getvalue("doctestglob")):
+    elif _is_doctest(config, path, parent):
         return DoctestTextfile(path, parent)
 
 
+def _is_doctest(config, path, parent):
+    if path.ext in ('.txt', '.rst') and parent.session.isinitpath(path):
+        return True
+    globs = config.getoption("doctestglob") or ['test*.txt']
+    for glob in globs:
+        if path.check(fnmatch=glob):
+            return True
+    return False
+
+
 class ReprFailDoctest(TerminalRepr):
 
     def __init__(self, reprlocation, lines):
@@ -79,7 +91,7 @@ class DoctestItem(pytest.Item):
                 lineno = test.lineno + example.lineno + 1
             message = excinfo.type.__name__
             reprlocation = ReprFileLocation(filename, lineno, message)
-            checker = _get_unicode_checker()
+            checker = _get_checker()
             REPORT_UDIFF = doctest.REPORT_UDIFF
             if lineno is not None:
                 lines = doctestfailure.test.docstring.splitlines(False)
@@ -98,7 +110,7 @@ class DoctestItem(pytest.Item):
                 lines += checker.output_difference(example,
                         doctestfailure.got, REPORT_UDIFF).split("\n")
             else:
-                inner_excinfo = py.code.ExceptionInfo(excinfo.value.exc_info)
+                inner_excinfo = ExceptionInfo(excinfo.value.exc_info)
                 lines += ["UNEXPECTED EXCEPTION: %s" %
                             repr(inner_excinfo.value)]
                 lines += traceback.format_exception(*excinfo.value.exc_info)
@@ -118,7 +130,9 @@ def _get_flag_lookup():
                 ELLIPSIS=doctest.ELLIPSIS,
                 IGNORE_EXCEPTION_DETAIL=doctest.IGNORE_EXCEPTION_DETAIL,
                 COMPARISON_FLAGS=doctest.COMPARISON_FLAGS,
-                ALLOW_UNICODE=_get_allow_unicode_flag())
+                ALLOW_UNICODE=_get_allow_unicode_flag(),
+                ALLOW_BYTES=_get_allow_bytes_flag(),
+                )
 
 
 def get_optionflags(parent):
@@ -147,7 +161,7 @@ class DoctestTextfile(DoctestItem, pytest.Module):
 
         optionflags = get_optionflags(self)
         runner = doctest.DebugRunner(verbose=0, optionflags=optionflags,
-                                     checker=_get_unicode_checker())
+                                     checker=_get_checker())
 
         parser = doctest.DocTestParser()
         test = parser.get_doctest(text, globs, name, filename, 0)
@@ -182,7 +196,7 @@ class DoctestModule(pytest.Module):
         finder = doctest.DocTestFinder()
         optionflags = get_optionflags(self)
         runner = doctest.DebugRunner(verbose=0, optionflags=optionflags,
-                                     checker=_get_unicode_checker())
+                                     checker=_get_checker())
         for test in finder.find(module, module.__name__):
             if test.examples:  # skip empty doctests
                 yield DoctestItem(test.name, self, runner, test)
@@ -204,28 +218,32 @@ def _setup_fixtures(doctest_item):
     return fixture_request
 
 
-def _get_unicode_checker():
+def _get_checker():
     """
     Returns a doctest.OutputChecker subclass that takes in account the
-    ALLOW_UNICODE option to ignore u'' prefixes in strings. Useful
-    when the same doctest should run in Python 2 and Python 3.
+    ALLOW_UNICODE option to ignore u'' prefixes in strings and ALLOW_BYTES
+    to strip b'' prefixes.
+    Useful when the same doctest should run in Python 2 and Python 3.
 
     An inner class is used to avoid importing "doctest" at the module
     level.
     """
-    if hasattr(_get_unicode_checker, 'UnicodeOutputChecker'):
-        return _get_unicode_checker.UnicodeOutputChecker()
+    if hasattr(_get_checker, 'LiteralsOutputChecker'):
+        return _get_checker.LiteralsOutputChecker()
 
     import doctest
     import re
 
-    class UnicodeOutputChecker(doctest.OutputChecker):
+    class LiteralsOutputChecker(doctest.OutputChecker):
         """
         Copied from doctest_nose_plugin.py from the nltk project:
             https://github.com/nltk/nltk
+
+        Further extended to also support byte literals.
         """
 
-        _literal_re = re.compile(r"(\W|^)[uU]([rR]?[\'\"])", re.UNICODE)
+        _unicode_literal_re = re.compile(r"(\W|^)[uU]([rR]?[\'\"])", re.UNICODE)
+        _bytes_literal_re = re.compile(r"(\W|^)[bB]([rR]?[\'\"])", re.UNICODE)
 
         def check_output(self, want, got, optionflags):
             res = doctest.OutputChecker.check_output(self, want, got,
@@ -233,23 +251,27 @@ def _get_unicode_checker():
             if res:
                 return True
 
-            if not (optionflags & _get_allow_unicode_flag()):
+            allow_unicode = optionflags & _get_allow_unicode_flag()
+            allow_bytes = optionflags & _get_allow_bytes_flag()
+            if not allow_unicode and not allow_bytes:
                 return False
 
             else:  # pragma: no cover
-                # the code below will end up executed only in Python 2 in
-                # our tests, and our coverage check runs in Python 3 only
-                def remove_u_prefixes(txt):
-                    return re.sub(self._literal_re, r'\1\2', txt)
+                def remove_prefixes(regex, txt):
+                    return re.sub(regex, r'\1\2', txt)
 
-                want = remove_u_prefixes(want)
-                got = remove_u_prefixes(got)
+                if allow_unicode:
+                    want = remove_prefixes(self._unicode_literal_re, want)
+                    got = remove_prefixes(self._unicode_literal_re, got)
+                if allow_bytes:
+                    want = remove_prefixes(self._bytes_literal_re, want)
+                    got = remove_prefixes(self._bytes_literal_re, got)
                 res = doctest.OutputChecker.check_output(self, want, got,
                                                          optionflags)
                 return res
 
-    _get_unicode_checker.UnicodeOutputChecker = UnicodeOutputChecker
-    return _get_unicode_checker.UnicodeOutputChecker()
+    _get_checker.LiteralsOutputChecker = LiteralsOutputChecker
+    return _get_checker.LiteralsOutputChecker()
 
 
 def _get_allow_unicode_flag():
@@ -258,3 +280,11 @@ def _get_allow_unicode_flag():
     """
     import doctest
     return doctest.register_optionflag('ALLOW_UNICODE')
+
+
+def _get_allow_bytes_flag():
+    """
+    Registers and returns the ALLOW_BYTES flag.
+    """
+    import doctest
+    return doctest.register_optionflag('ALLOW_BYTES')

_pytest/hookspec.py

@@ -28,17 +28,14 @@ def pytest_plugin_registered(plugin, manager):
 
 @hookspec(historic=True)
 def pytest_addoption(parser):
-    """register argparse-style options and ini-style config values.
+    """register argparse-style options and ini-style config values,
+    called once at the beginning of a test run.
 
-    .. warning::
+    .. note::
 
-        This function must be implemented in a :ref:`plugin <pluginorder>`
-        and is called once at the beginning of a test run.
-
-        Implementing this hook from ``conftest.py`` files is **strongly**
-        discouraged because ``conftest.py`` files are lazily loaded and
-        may give strange *unknown option* errors depending on the directory
-        ``py.test`` is invoked from.
+        This function should be implemented only in plugins or ``conftest.py``
+        files situated at the tests root directory due to how py.test
+        :ref:`discovers plugins during startup <pluginorder>`.
 
     :arg parser: To add command line options, call
         :py:func:`parser.addoption(...) <_pytest.config.Parser.addoption>`.
@@ -84,7 +81,7 @@ def pytest_cmdline_main(config):
     """ called for performing the main command line action. The default
     implementation will invoke the configure hooks and runtest_mainloop. """
 
-def pytest_load_initial_conftests(args, early_config, parser):
+def pytest_load_initial_conftests(early_config, parser, args):
     """ implements the loading of initial conftest files ahead
     of command line option parsing. """
 
@@ -289,7 +286,10 @@ def pytest_exception_interact(node, call, report):
     that is not an internal exception like ``skip.Exception``.
     """
 
-def pytest_enter_pdb():
+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.
+
+    :arg config: pytest config object
+    :type config: _pytest.config.Config
     """

_pytest/junitxml.py

@@ -46,6 +46,8 @@ del _legal_chars
 del _legal_ranges
 del _legal_xml_re
 
+_py_ext_re = re.compile(r"\.py$")
+
 
 def bin_xml_escape(arg):
     def repl(matchobj):
@@ -65,8 +67,7 @@ class _NodeReporter(object):
         self.xml = xml
         self.add_stats = self.xml.add_stats
         self.duration = 0
-        self.properties = {}
-        self.property_insert_order = []
+        self.properties = []
         self.nodes = []
         self.testcase = None
         self.attrs = {}
@@ -76,24 +77,21 @@ class _NodeReporter(object):
         self.nodes.append(node)
 
     def add_property(self, name, value):
-        name = str(name)
-        if name not in self.property_insert_order:
-            self.property_insert_order.append(name)
-        self.properties[name] = bin_xml_escape(value)
+        self.properties.append((str(name), bin_xml_escape(value)))
 
     def make_properties_node(self):
         """Return a Junit node containing custom properties, if any.
         """
         if self.properties:
             return Junit.properties([
-                Junit.property(name=name, value=self.properties[name])
-                for name in self.property_insert_order
+                Junit.property(name=name, value=value)
+                for name, value in self.properties
             ])
         return ''
 
     def record_testreport(self, testreport):
         assert not self.testcase
-        names = mangle_testnames(testreport.nodeid.split("::"))
+        names = mangle_test_address(testreport.nodeid)
         classnames = names[:-1]
         if self.xml.prefix:
             classnames.insert(0, self.xml.prefix)
@@ -239,9 +237,18 @@ def pytest_unconfigure(config):
         config.pluginmanager.unregister(xml)
 
 
-def mangle_testnames(names):
-    names = [x.replace(".py", "") for x in names if x != '()']
+def mangle_test_address(address):
+    path, possible_open_bracket, params = address.partition('[')
+    names = path.split("::")
+    try:
+        names.remove('()')
+    except ValueError:
+        pass
+    # convert file path to dotted path
     names[0] = names[0].replace("/", '.')
+    names[0] = _py_ext_re.sub("", names[0])
+    # put any params back
+    names[-1] += possible_open_bracket + params
     return names
 
 

_pytest/main.py

@@ -1,9 +1,13 @@
 """ core implementation of testing process: init, session, runtest loop. """
+import imp
+import os
 import re
+import sys
 
+import _pytest
+import _pytest._code
 import py
-import pytest, _pytest
-import os, sys, imp
+import pytest
 try:
     from collections import MutableMapping as MappingMixin
 except ImportError:
@@ -91,11 +95,11 @@ def wrap_session(config, doit):
         except pytest.UsageError:
             raise
         except KeyboardInterrupt:
-            excinfo = py.code.ExceptionInfo()
+            excinfo = _pytest._code.ExceptionInfo()
             config.hook.pytest_keyboard_interrupt(excinfo=excinfo)
             session.exitstatus = EXIT_INTERRUPTED
         except:
-            excinfo = py.code.ExceptionInfo()
+            excinfo = _pytest._code.ExceptionInfo()
             config.notify_exception(excinfo, config.option)
             session.exitstatus = EXIT_INTERNALERROR
             if excinfo.errisinstance(SystemExit):
@@ -714,7 +718,8 @@ class Session(FSCollector):
             if rep.passed:
                 has_matched = False
                 for x in rep.result:
-                    if x.name == name:
+                    # TODO: remove parametrized workaround once collection structure contains parametrization
+                    if x.name == name or x.name.split("[")[0] == name:
                         resultnodes.extend(self.matchnodes([x], nextnames))
                         has_matched = True
                 # XXX accept IDs that don't have "()" for class instances

_pytest/mark.py

@@ -169,7 +169,7 @@ class MarkGenerator:
     """ Factory for :class:`MarkDecorator` objects - exposed as
     a ``pytest.mark`` singleton instance.  Example::
 
-         import py
+         import pytest
          @pytest.mark.slowtest
          def test_function():
             pass

_pytest/pdb.py

@@ -37,7 +37,6 @@ class pytestPDB:
         """ invoke PDB set_trace debugging, dropping any IO capturing. """
         import _pytest.config
         frame = sys._getframe().f_back
-        capman = None
         if self._pluginmanager is not None:
             capman = self._pluginmanager.getplugin("capturemanager")
             if capman:
@@ -45,7 +44,7 @@ class pytestPDB:
             tw = _pytest.config.create_terminal_writer(self._config)
             tw.line()
             tw.sep(">", "PDB set_trace (IO-capturing turned off)")
-            self._pluginmanager.hook.pytest_enter_pdb()
+            self._pluginmanager.hook.pytest_enter_pdb(config=self._config)
         pdb.Pdb().set_trace(frame)
 
 

_pytest/pytester.py

@@ -1,19 +1,20 @@
 """ (disabled by default) support for testing pytest and pytest plugins. """
-import gc
-import sys
-import traceback
-import os
 import codecs
-import re
-import time
+import gc
+import os
 import platform
-from fnmatch import fnmatch
+import re
 import subprocess
+import sys
+import time
+import traceback
+from fnmatch import fnmatch
 
-import py
-import pytest
 from py.builtin import print_
 
+from _pytest._code import Source
+import py
+import pytest
 from _pytest.main import Session, EXIT_OK
 
 
@@ -472,7 +473,7 @@ class Testdir:
         ret = None
         for name, value in items:
             p = self.tmpdir.join(name).new(ext=ext)
-            source = py.code.Source(value)
+            source = Source(value)
             def my_totext(s, encoding="utf-8"):
                 if py.builtin._isbytes(s):
                     s = py.builtin._totext(s, encoding=encoding)
@@ -835,7 +836,7 @@ class Testdir:
            to the temporarly directory to ensure it is a package.
 
         """
-        kw = {self.request.function.__name__: py.code.Source(source).strip()}
+        kw = {self.request.function.__name__: Source(source).strip()}
         path = self.makepyfile(**kw)
         if withinit:
             self.makepyfile(__init__ = "#")
@@ -1041,8 +1042,8 @@ class LineMatcher:
 
     def _getlines(self, lines2):
         if isinstance(lines2, str):
-            lines2 = py.code.Source(lines2)
-        if isinstance(lines2, py.code.Source):
+            lines2 = Source(lines2)
+        if isinstance(lines2, Source):
             lines2 = lines2.strip().lines
         return lines2
 

_pytest/python.py

@@ -1,14 +1,15 @@
 """ Python test discovery, setup and run of test functions. """
-import re
 import fnmatch
 import functools
-import py
 import inspect
+import re
 import types
 import sys
+
+import py
 import pytest
+from _pytest._code.code import TerminalRepr
 from _pytest.mark import MarkDecorator, MarkerError
-from py._code.code import TerminalRepr
 
 try:
     import enum
@@ -86,7 +87,7 @@ def getfslineno(obj):
     obj = get_real_func(obj)
     if hasattr(obj, 'place_as'):
         obj = obj.place_as
-    fslineno = py.code.getfslineno(obj)
+    fslineno = _pytest._code.getfslineno(obj)
     assert isinstance(fslineno[1], int), obj
     return fslineno
 
@@ -331,7 +332,7 @@ def pytest_pycollect_makeitem(collector, name, obj):
 
 def is_generator(func):
     try:
-        return py.code.getrawcode(func).co_flags & 32 # generator function
+        return _pytest._code.getrawcode(func).co_flags & 32 # generator function
     except AttributeError: # builtin functions have no bytecode
         # assume them to not be generators
         return False
@@ -610,7 +611,7 @@ class Module(pytest.File, PyCollector):
             mod = self.fspath.pyimport(ensuresyspath=importmode)
         except SyntaxError:
             raise self.CollectError(
-                py.code.ExceptionInfo().getrepr(style="short"))
+                _pytest._code.ExceptionInfo().getrepr(style="short"))
         except self.fspath.ImportMismatchError:
             e = sys.exc_info()[1]
             raise self.CollectError(
@@ -716,7 +717,7 @@ class FunctionMixin(PyobjMixin):
 
     def _prunetraceback(self, excinfo):
         if hasattr(self, '_obj') and not self.config.option.fulltrace:
-            code = py.code.Code(get_real_func(self.obj))
+            code = _pytest._code.Code(get_real_func(self.obj))
             path, firstlineno = code.path, code.firstlineno
             traceback = excinfo.traceback
             ntraceback = traceback.cut(path=path, firstlineno=firstlineno)
@@ -739,7 +740,7 @@ class FunctionMixin(PyobjMixin):
     def _repr_failure_py(self, excinfo, style="long"):
         if excinfo.errisinstance(pytest.fail.Exception):
             if not excinfo.value.pytrace:
-                return str(excinfo.value)
+                return py._builtin._totext(excinfo.value)
         return super(FunctionMixin, self)._repr_failure_py(excinfo,
             style=style)
 
@@ -1114,7 +1115,7 @@ def _idval(val, argname, idx, idfn):
     elif isinstance(val, (float, int, str, bool, NoneType)):
         return str(val)
     elif isinstance(val, REGEX_TYPE):
-        return val.pattern
+        return _escape_bytes(val.pattern) if isinstance(val.pattern, bytes) else val.pattern
     elif enum is not None and isinstance(val, enum.Enum):
         return str(val)
     elif isclass(val) and hasattr(val, '__name__'):
@@ -1202,10 +1203,10 @@ def getlocation(function, curdir):
 # builtin pytest.raises helper
 
 def raises(expected_exception, *args, **kwargs):
-    """ assert that a code block/function call raises @expected_exception
+    """ assert that a code block/function call raises ``expected_exception``
     and raise a failure exception otherwise.
 
-    This helper produces a ``py.code.ExceptionInfo()`` object.
+    This helper produces a ``ExceptionInfo()`` object (see below).
 
     If using Python 2.5 or above, you may use this function as a
     context manager::
@@ -1221,19 +1222,19 @@ def raises(expected_exception, *args, **kwargs):
        Lines of code after that, within the scope of the context manager will
        not be executed. For example::
 
-           >>> with raises(OSError) as err:
+           >>> with raises(OSError) as exc_info:
                    assert 1 == 1  # this will execute as expected
                    raise OSError(errno.EEXISTS, 'directory exists')
-                   assert err.errno == errno.EEXISTS  # this will not execute
+                   assert exc_info.value.errno == errno.EEXISTS  # this will not execute
 
        Instead, the following approach must be taken (note the difference in
        scope)::
 
-           >>> with raises(OSError) as err:
+           >>> with raises(OSError) as exc_info:
                    assert 1 == 1  # this will execute as expected
                    raise OSError(errno.EEXISTS, 'directory exists')
 
-               assert err.errno == errno.EEXISTS  # this will now execute
+               assert exc_info.value.errno == errno.EEXISTS  # this will now execute
 
     Or you can specify a callable by passing a to-be-called lambda::
 
@@ -1254,21 +1255,22 @@ def raises(expected_exception, *args, **kwargs):
         >>> raises(ZeroDivisionError, "f(0)")
         <ExceptionInfo ...>
 
-    Performance note:
-    -----------------
+    .. autoclass:: _pytest._code.ExceptionInfo
+        :members:
 
-    Similar to caught exception objects in Python, explicitly clearing
-    local references to returned ``py.code.ExceptionInfo`` objects can
-    help the Python interpreter speed up its garbage collection.
+    .. 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.
+        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
@@ -1297,19 +1299,19 @@ def raises(expected_exception, *args, **kwargs):
         loc.update(kwargs)
         #print "raises frame scope: %r" % frame.f_locals
         try:
-            code = py.code.Source(code).compile()
+            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 py.code.ExceptionInfo()
+            return _pytest._code.ExceptionInfo()
     else:
         func = args[0]
         try:
             func(*args[1:], **kwargs)
         except expected_exception:
-            return py.code.ExceptionInfo()
-    pytest.fail("DID NOT RAISE")
+            return _pytest._code.ExceptionInfo()
+    pytest.fail("DID NOT RAISE {0}".format(expected_exception))
 
 class RaisesContext(object):
     def __init__(self, expected_exception):
@@ -1317,7 +1319,7 @@ class RaisesContext(object):
         self.excinfo = None
 
     def __enter__(self):
-        self.excinfo = object.__new__(py.code.ExceptionInfo)
+        self.excinfo = object.__new__(_pytest._code.ExceptionInfo)
         return self.excinfo
 
     def __exit__(self, *tp):
@@ -1768,12 +1770,11 @@ class FixtureLookupError(LookupError):
             # the last fixture raise an error, let's present
             # it at the requesting side
             stack = stack[:-1]
-                               
         for function in stack:
             fspath, lineno = getfslineno(function)
             try:
                 lines, _ = inspect.getsourcelines(get_real_func(function))
-            except IOError:
+            except (IOError, IndexError):
                 error_msg = "file %s, line %s: source code not available"
                 addline(error_msg % (fspath, lineno+1))
             else:
@@ -2025,7 +2026,7 @@ class FixtureManager:
 def fail_fixturefunc(fixturefunc, msg):
     fs, lineno = getfslineno(fixturefunc)
     location = "%s:%s" % (fs, lineno+1)
-    source = py.code.Source(fixturefunc)
+    source = _pytest._code.Source(fixturefunc)
     pytest.fail(msg + ":\n\n" + str(source.indent()) + "\n" + location,
                 pytrace=False)
 
@@ -2168,14 +2169,14 @@ def getfuncargnames(function, startindex=None):
         startindex += num_mock_patch_args(function)
         function = realfunction
     if isinstance(function, functools.partial):
-        argnames = inspect.getargs(py.code.getrawcode(function.func))[0]
+        argnames = inspect.getargs(_pytest._code.getrawcode(function.func))[0]
         partial = function
         argnames = argnames[len(partial.args):]
         if partial.keywords:
             for kw in partial.keywords:
                 argnames.remove(kw)
     else:
-        argnames = inspect.getargs(py.code.getrawcode(function))[0]
+        argnames = inspect.getargs(_pytest._code.getrawcode(function))[0]
     defaults = getattr(function, 'func_defaults',
                        getattr(function, '__defaults__', None)) or ()
     numdefaults = len(defaults)

_pytest/recwarn.py

@@ -1,6 +1,8 @@
 """ recording warnings during test function execution. """
 
 import inspect
+
+import _pytest._code
 import py
 import sys
 import warnings
@@ -28,14 +30,22 @@ def pytest_namespace():
             'warns': warns}
 
 
-def deprecated_call(func, *args, **kwargs):
+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::
+
+        >>> with deprecated_call():
+        ...    myobject.deprecated_method()
+
     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.
     """
+    if not func:
+        return WarningsChecker(expected_warning=DeprecationWarning)
+
     categories = []
 
     def warn_explicit(message, category, *args, **kwargs):
@@ -92,7 +102,7 @@ def warns(expected_warning, *args, **kwargs):
         loc.update(kwargs)
 
         with wcheck:
-            code = py.code.Source(code).compile()
+            code = _pytest._code.Source(code).compile()
             py.builtin.exec_(code, frame.f_globals, loc)
     else:
         func = args[0]
@@ -171,8 +181,8 @@ class WarningsRecorder(object):
         self._module.showwarning = showwarning
 
         # allow the same warning to be raised more than once
-        self._module.simplefilter('always', append=True)
 
+        self._module.simplefilter('always')
         return self
 
     def __exit__(self, *exc_info):

_pytest/runner.py

@@ -5,7 +5,8 @@ from time import time
 
 import py
 import pytest
-from py._code.code import TerminalRepr
+from _pytest._code.code import TerminalRepr, ExceptionInfo
+
 
 def pytest_namespace():
     return {
@@ -151,7 +152,7 @@ class CallInfo:
             self.stop = time()
             raise
         except:
-            self.excinfo = py.code.ExceptionInfo()
+            self.excinfo = ExceptionInfo()
         self.stop = time()
 
     def __repr__(self):
@@ -177,9 +178,13 @@ class BaseReport(object):
         self.__dict__.update(kw)
 
     def toterminal(self, out):
-        longrepr = self.longrepr
         if hasattr(self, 'node'):
             out.line(getslaveinfoline(self.node))
+
+        longrepr = self.longrepr
+        if longrepr is None:
+            return
+
         if hasattr(longrepr, 'toterminal'):
             longrepr.toterminal(out)
         else:
@@ -211,7 +216,7 @@ def pytest_runtest_makereport(item, call):
         outcome = "passed"
         longrepr = None
     else:
-        if not isinstance(excinfo, py.code.ExceptionInfo):
+        if not isinstance(excinfo, ExceptionInfo):
             outcome = "failed"
             longrepr = excinfo
         elif excinfo.errisinstance(pytest.skip.Exception):
@@ -430,7 +435,10 @@ class OutcomeException(Exception):
 
     def __repr__(self):
         if self.msg:
-            return str(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__
 

_pytest/skipping.py

@@ -5,6 +5,8 @@ import traceback
 
 import py
 import pytest
+from _pytest.mark import MarkInfo, MarkDecorator
+
 
 def pytest_addoption(parser):
     group = parser.getgroup("general")
@@ -12,6 +14,13 @@ def pytest_addoption(parser):
            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: "
+                                  "False)",
+                                  default=False,
+                                  type="bool")
+
+
 def pytest_configure(config):
     if config.option.runxfail:
         old = pytest.xfail
@@ -38,18 +47,22 @@ def pytest_configure(config):
         "See http://pytest.org/latest/skipping.html"
     )
 
+
 def pytest_namespace():
     return dict(xfail=xfail)
 
+
 class XFailed(pytest.fail.Exception):
     """ raised from an explicit call to pytest.xfail() """
 
+
 def xfail(reason=""):
     """ xfail an executing test or setup functions with the given reason."""
     __tracebackhide__ = True
     raise XFailed(reason)
 xfail.Exception = XFailed
 
+
 class MarkEvaluator:
     def __init__(self, item, name):
         self.item = item
@@ -147,23 +160,59 @@ class MarkEvaluator:
 
 @pytest.hookimpl(tryfirst=True)
 def pytest_runtest_setup(item):
-    evalskip = MarkEvaluator(item, 'skipif')
-    if evalskip.istrue():
-        item._evalskip = evalskip
-        pytest.skip(evalskip.getexplanation())
+    # Check if skip or skipif are specified as pytest marks
+
+    skipif_info = item.keywords.get('skipif')
+    if isinstance(skipif_info, (MarkInfo, MarkDecorator)):
+        eval_skipif = MarkEvaluator(item, 'skipif')
+        if eval_skipif.istrue():
+            item._evalskip = eval_skipif
+            pytest.skip(eval_skipif.getexplanation())
+
+    skip_info = item.keywords.get('skip')
+    if isinstance(skip_info, (MarkInfo, MarkDecorator)):
+        item._evalskip = True
+        if 'reason' in skip_info.kwargs:
+            pytest.skip(skip_info.kwargs['reason'])
+        elif skip_info.args:
+            pytest.skip(skip_info.args[0])
+        else:
+            pytest.skip("unconditional skip")
+
     item._evalxfail = MarkEvaluator(item, 'xfail')
     check_xfail_no_run(item)
 
+
+@pytest.mark.hookwrapper
 def pytest_pyfunc_call(pyfuncitem):
     check_xfail_no_run(pyfuncitem)
+    outcome = yield
+    passed = outcome.excinfo is None
+    if passed:
+        check_strict_xfail(pyfuncitem)
+
 
 def check_xfail_no_run(item):
+    """check xfail(run=False)"""
     if not item.config.option.runxfail:
         evalxfail = item._evalxfail
         if evalxfail.istrue():
             if not evalxfail.get('run', True):
                 pytest.xfail("[NOTRUN] " + evalxfail.getexplanation())
 
+
+def check_strict_xfail(pyfuncitem):
+    """check xfail(strict=True) for the given PASSING test"""
+    evalxfail = pyfuncitem._evalxfail
+    if evalxfail.istrue():
+        strict_default = pyfuncitem.config.getini('xfail_strict')
+        is_strict_xfail = evalxfail.get('strict', strict_default)
+        if is_strict_xfail:
+            del pyfuncitem._evalxfail
+            explanation = evalxfail.getexplanation()
+            pytest.fail('[XPASS(strict)] ' + explanation, pytrace=False)
+
+
 @pytest.hookimpl(hookwrapper=True)
 def pytest_runtest_makereport(item, call):
     outcome = yield
@@ -230,6 +279,9 @@ def pytest_terminal_summary(terminalreporter):
             show_skipped(terminalreporter, lines)
         elif char == "E":
             show_simple(terminalreporter, lines, 'error', "ERROR %s")
+        elif char == 'p':
+            show_simple(terminalreporter, lines, 'passed', "PASSED %s")
+
     if lines:
         tr._tw.sep("=", "short test summary info")
         for line in lines:
@@ -266,9 +318,8 @@ def cached_eval(config, expr, d):
     try:
         return config._evalcache[expr]
     except KeyError:
-        #import sys
-        #print >>sys.stderr, ("cache-miss: %r" % expr)
-        exprcode = py.code.compile(expr, mode="eval")
+        import _pytest._code
+        exprcode = _pytest._code.compile(expr, mode="eval")
         config._evalcache[expr] = x = eval(exprcode, d)
         return x
 

_pytest/terminal.py

@@ -22,7 +22,8 @@ def pytest_addoption(parser):
     group._addoption('-r',
          action="store", dest="reportchars", default=None, metavar="chars",
          help="show extra test summary info as specified by chars (f)ailed, "
-              "(E)error, (s)skipped, (x)failed, (X)passed (w)pytest-warnings (a)all.")
+              "(E)error, (s)skipped, (x)failed, (X)passed (w)pytest-warnings "
+              "(p)passed, (P)passed with output, (a)all except pP.")
     group._addoption('-l', '--showlocals',
          action="store_true", dest="showlocals", default=False,
          help="show locals in tracebacks (disabled by default).")
@@ -111,6 +112,7 @@ class TerminalReporter:
         self.currentfspath = None
         self.reportchars = getreportopt(config)
         self.hasmarkup = self._tw.hasmarkup
+        self.isatty = file.isatty()
 
     def hasopt(self, char):
         char = {'xfailed': 'x', 'skipped': 's'}.get(char, char)
@@ -233,7 +235,7 @@ class TerminalReporter:
                 self.currentfspath = -2
 
     def pytest_collection(self):
-        if not self.hasmarkup and self.config.option.verbose >= 1:
+        if not self.isatty and self.config.option.verbose >= 1:
             self.write("collecting ... ", bold=True)
 
     def pytest_collectreport(self, report):
@@ -243,7 +245,7 @@ class TerminalReporter:
             self.stats.setdefault("skipped", []).append(report)
         items = [x for x in report.result if isinstance(x, pytest.Item)]
         self._numcollected += len(items)
-        if self.hasmarkup:
+        if self.isatty:
             #self.write_fspath_result(report.nodeid, 'E')
             self.report_collect()
 
@@ -262,7 +264,7 @@ class TerminalReporter:
             line += " / %d errors" % errors
         if skipped:
             line += " / %d skipped" % skipped
-        if self.hasmarkup:
+        if self.isatty:
             if final:
                 line += " \n"
             self.rewrite(line, bold=True)
@@ -368,6 +370,7 @@ class TerminalReporter:
             self.summary_errors()
             self.summary_failures()
             self.summary_warnings()
+            self.summary_passes()
         if exitstatus == EXIT_INTERRUPTED:
             self._report_keyboardinterrupt()
             del self._keyboardinterrupt_memo
@@ -389,6 +392,7 @@ class TerminalReporter:
             if self.config.option.fulltrace:
                 excrepr.toterminal(self._tw)
             else:
+                self._tw.line("to show a full traceback on KeyboardInterrupt use --fulltrace", yellow=True)
                 excrepr.reprcrash.toterminal(self._tw)
 
     def _locationline(self, nodeid, fspath, lineno, domain):
@@ -446,6 +450,18 @@ class TerminalReporter:
                 self._tw.line("W%s %s %s" % (w.code,
                               w.fslocation, w.message))
 
+    def summary_passes(self):
+        if self.config.option.tbstyle != "no":
+            if self.hasopt("P"):
+                reports = self.getreports('passed')
+                if not reports:
+                    return
+                self.write_sep("=", "PASSES")
+                for rep in reports:
+                    msg = self._getfailureheadline(rep)
+                    self.write_sep("_", msg)
+                    self._outrep_summary(rep)
+
     def summary_failures(self):
         if self.config.option.tbstyle != "no":
             reports = self.getreports('failed')

_pytest/unittest.py

@@ -1,13 +1,12 @@
 """ discovery and running of std-library "unittest" style tests. """
 from __future__ import absolute_import
-import traceback
+
 import sys
+import traceback
 
 import pytest
-import py
-
-
 # for transfering markers
+import _pytest._code
 from _pytest.python import transfer_markers
 from _pytest.skipping import MarkEvaluator
 
@@ -101,7 +100,7 @@ class TestCaseFunction(pytest.Function):
         # unwrap potential exception info (see twisted trial support below)
         rawexcinfo = getattr(rawexcinfo, '_rawexcinfo', rawexcinfo)
         try:
-            excinfo = py.code.ExceptionInfo(rawexcinfo)
+            excinfo = _pytest._code.ExceptionInfo(rawexcinfo)
         except TypeError:
             try:
                 try:
@@ -117,7 +116,7 @@ class TestCaseFunction(pytest.Function):
             except KeyboardInterrupt:
                 raise
             except pytest.fail.Exception:
-                excinfo = py.code.ExceptionInfo()
+                excinfo = _pytest._code.ExceptionInfo()
         self.__dict__.setdefault('_excinfo', []).append(excinfo)
 
     def addError(self, testcase, rawexcinfo):

appveyor.yml

@@ -1,19 +1,28 @@
+environment:
+  COVERALLS_REPO_TOKEN:
+    secure: 2NJ5Ct55cHJ9WEg3xbSqCuv0rdgzzb6pnzOIG5OkMbTndw3wOBrXntWFoQrXiMFi
+    # this is pytest's token in coveralls.io, encrypted
+    # using pytestbot account as detailed here:
+    # https://www.appveyor.com/docs/build-configuration#secure-variables
+
 install:
   - echo Installed Pythons
   - dir c:\Python*
 
+  # install pypy using choco (redirect to a file and write to console in case
+  # choco install returns non-zero, because choco install python.pypy is too
+  # noisy)
+  - choco install python.pypy > pypy-inst.log 2>&1 || (type pypy-inst.log & exit /b 1)
+  - set PATH=C:\tools\pypy\pypy;%PATH% # so tox can find pypy
+  - echo PyPy installed
+  - pypy --version
+
   - C:\Python35\python -m pip install tox
 
 build: false  # Not a C# project, build stuff at the test step instead.
 
 test_script:
-  - 'set TESTENVS=
-          flakes,
-          py26,
-          py27,
-          py33,
-          py34,
-          py27-xdist,
-          py35-xdist
-    '
-  - C:\Python35\python -m tox -e "%TESTENVS%"
+  - C:\Python35\python -m tox
+  # coveralls is not in tox's envlist, plus for PRs the secure variable
+  # is not defined so we have to check for it
+  - if defined COVERALLS_REPO_TOKEN C:\Python35\python -m tox -e coveralls

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('license') }}">License</a></li>
 </ul>
 
 {%- if display_toc %}

doc/en/_templates/layout.html

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

doc/en/_templates/links.html

@@ -1,5 +1,10 @@
 <h3>Useful Links</h3>
 <ul>
+  <li>
+    <a href="https://www.indiegogo.com/projects/python-testing-sprint-mid-2016#/">
+      <b>Sprint funding campaign</b>
+    </a>
+  </li>
   <li><a href="{{ pathto('index') }}">The pytest Website</a></li>
   <li><a href="{{ pathto('contributing') }}">Contribution Guide</a></li>
   <li><a href="https://pypi.python.org/pypi/pytest">pytest @ PyPI</a></li>

doc/en/announce/index.rst

@@ -6,6 +6,9 @@ Release announcements
    :maxdepth: 2
 
 
+   sprint2016
+   release-2.9.0
+   release-2.8.7
    release-2.8.6
    release-2.8.5
    release-2.8.4

doc/en/announce/release-2.9.0.rst

@@ -0,0 +1,159 @@
+pytest-2.9.0
+============
+
+pytest is a mature Python testing tool with more than a 1100 tests
+against itself, passing on many different interpreters and platforms.
+
+See below for the changes and see docs at:
+
+    http://pytest.org
+
+As usual, you can upgrade from pypi via::
+
+    pip install -U pytest
+
+Thanks to all who contributed to this release, among them:
+
+    Anatoly Bubenkov                                                                                                                                                                                                         
+    Bruno Oliveira                                                                                                                                                                                                           
+    Buck Golemon                                                                                                                                                                                                             
+    David Vierra                                                                                                                                                                                                             
+    Florian Bruhin                                                                                                                                                                                                           
+    Galaczi Endre                                                                                                                                                                                                            
+    Georgy Dyuldin                                                                                                                                                                                                           
+    Lukas Bednar                                                                                                                                                                                                             
+    Luke Murphy                                                                                                                                                                                                              
+    Marcin Biernat                                                                                                                                                                                                           
+    Matt Williams                                                                                                                                                                                                            
+    Michael Aquilina                                                                                                                                                                                                         
+    Raphael Pierzina                                                                                                                                                                                                         
+    Ronny Pfannschmidt                                                                                                                                                                                                       
+    Ryan Wooden                                                                                                                                                                                                              
+    Tiemo Kieft                                                                                                                                                                                                              
+    TomV                                                                                                                                                                                                                     
+    holger krekel                                                                                                                                                                                                            
+    jab   
+
+
+Happy testing,
+The py.test Development Team
+
+
+2.9.0 (compared to 2.8.7)
+-------------------------
+
+**New Features**
+
+* New ``pytest.mark.skip`` mark, which unconditionally skips marked tests.
+  Thanks `@MichaelAquilina`_ for the complete PR (`#1040`_).
+
+* ``--doctest-glob`` may now be passed multiple times in the command-line.
+  Thanks `@jab`_ and `@nicoddemus`_ for the PR.
+
+* New ``-rp`` and ``-rP`` reporting options give the summary and full output
+  of passing tests, respectively. Thanks to `@codewarrior0`_ for the PR.
+
+* ``pytest.mark.xfail`` now has a ``strict`` option which makes ``XPASS``
+  tests to fail the test suite, defaulting to ``False``. There's also a
+  ``xfail_strict`` ini option that can be used to configure it project-wise.
+  Thanks `@rabbbit`_ for the request and `@nicoddemus`_ for the PR (`#1355`_).
+
+* ``Parser.addini`` now supports options of type ``bool``. Thanks
+  `@nicoddemus`_ for the PR.
+
+* New ``ALLOW_BYTES`` doctest option strips ``b`` prefixes from byte strings
+  in doctest output (similar to ``ALLOW_UNICODE``).
+  Thanks `@jaraco`_ for the request and `@nicoddemus`_ for the PR (`#1287`_).
+
+* give a hint on KeyboardInterrupt to use the --fulltrace option to show the errors,
+  this fixes `#1366`_.
+  Thanks to `@hpk42`_ for the report and `@RonnyPfannschmidt`_ for the PR.
+
+* catch IndexError exceptions when getting exception source location. This fixes
+  pytest internal error for dynamically generated code (fixtures and tests)
+  where source lines are fake by intention
+
+**Changes**
+
+* **Important**: `py.code <http://pylib.readthedocs.org/en/latest/code.html>`_ has been
+  merged into the ``pytest`` repository as ``pytest._code``. This decision 
+  was made because ``py.code`` had very few uses outside ``pytest`` and the 
+  fact that it was in a different repository made it difficult to fix bugs on 
+  its code in a timely manner. The team hopes with this to be able to better
+  refactor out and improve that code.
+  This change shouldn't affect users, but it is useful to let users aware
+  if they encounter any strange behavior.
+  
+  Keep in mind that the code for ``pytest._code`` is **private** and 
+  **experimental**, so you definitely should not import it explicitly!
+
+  Please note that the original ``py.code`` is still available in 
+  `pylib <http://pylib.readthedocs.org>`_.
+
+* ``pytest_enter_pdb`` now optionally receives the pytest config object.
+  Thanks `@nicoddemus`_ for the PR.
+
+* Removed code and documentation for Python 2.5 or lower versions,
+  including removal of the obsolete ``_pytest.assertion.oldinterpret`` module.
+  Thanks `@nicoddemus`_ for the PR (`#1226`_).
+
+* Comparisons now always show up in full when ``CI`` or ``BUILD_NUMBER`` is
+  found in the environment, even when -vv isn't used.
+  Thanks `@The-Compiler`_ for the PR.
+
+* ``--lf`` and ``--ff`` now support long names: ``--last-failed`` and
+  ``--failed-first`` respectively.
+  Thanks `@MichaelAquilina`_ for the PR.
+
+* Added expected exceptions to pytest.raises fail message
+
+* Collection only displays progress ("collecting X items") when in a terminal.
+  This avoids cluttering the output when using ``--color=yes`` to obtain
+  colors in CI integrations systems (`#1397`_).
+
+**Bug Fixes**
+
+* The ``-s`` and ``-c`` options should now work under ``xdist``;
+  ``Config.fromdictargs`` now represents its input much more faithfully.
+  Thanks to `@bukzor`_ for the complete PR (`#680`_).
+
+* Fix (`#1290`_): support Python 3.5's ``@`` operator in assertion rewriting.
+  Thanks `@Shinkenjoe`_ for report with test case and `@tomviner`_ for the PR.
+
+* Fix formatting utf-8 explanation messages (`#1379`_).
+  Thanks `@biern`_ for the PR.
+
+* Fix `traceback style docs`_ to describe all of the available options
+  (auto/long/short/line/native/no), with `auto` being the default since v2.6.
+  Thanks `@hackebrot`_ for the PR.
+
+* Fix (`#1422`_): junit record_xml_property doesn't allow multiple records
+  with same name.
+  
+  
+.. _`traceback style docs`: https://pytest.org/latest/usage.html#modifying-python-traceback-printing
+
+.. _#1422: https://github.com/pytest-dev/pytest/issues/1422
+.. _#1379: https://github.com/pytest-dev/pytest/issues/1379
+.. _#1366: https://github.com/pytest-dev/pytest/issues/1366
+.. _#1040: https://github.com/pytest-dev/pytest/pull/1040
+.. _#680: https://github.com/pytest-dev/pytest/issues/680
+.. _#1287: https://github.com/pytest-dev/pytest/pull/1287
+.. _#1226: https://github.com/pytest-dev/pytest/pull/1226
+.. _#1290: https://github.com/pytest-dev/pytest/pull/1290
+.. _#1355: https://github.com/pytest-dev/pytest/pull/1355
+.. _#1397: https://github.com/pytest-dev/pytest/issues/1397
+.. _@biern: https://github.com/biern
+.. _@MichaelAquilina: https://github.com/MichaelAquilina
+.. _@bukzor: https://github.com/bukzor
+.. _@hpk42: https://github.com/hpk42
+.. _@nicoddemus: https://github.com/nicoddemus
+.. _@jab: https://github.com/jab
+.. _@codewarrior0: https://github.com/codewarrior0
+.. _@jaraco: https://github.com/jaraco
+.. _@The-Compiler: https://github.com/The-Compiler
+.. _@Shinkenjoe: https://github.com/Shinkenjoe
+.. _@tomviner: https://github.com/tomviner
+.. _@RonnyPfannschmidt: https://github.com/RonnyPfannschmidt
+.. _@rabbbit: https://github.com/rabbbit
+.. _@hackebrot: https://github.com/hackebrot

doc/en/announce/release-2.9.1.rst

@@ -0,0 +1,65 @@
+pytest-2.9.1
+============
+
+pytest is a mature Python testing tool with more than a 1100 tests
+against itself, passing on many different interpreters and platforms.
+
+See below for the changes and see docs at:
+
+    http://pytest.org
+
+As usual, you can upgrade from pypi via::
+
+    pip install -U pytest
+
+Thanks to all who contributed to this release, among them:
+
+    Bruno Oliveira                                                                                                                                                                                                                            
+    Daniel Hahler                                                                                                                                                                                                                             
+    Dmitry Malinovsky                                                                                                                                                                                                                         
+    Florian Bruhin                                                                                                                                                                                                                            
+    Floris Bruynooghe                                                                                                                                                                                                                         
+    Matt Bachmann                                                                                                                                                                                                                             
+    Ronny Pfannschmidt                                                                                                                                                                                                                        
+    TomV                                                                                                                                                                                                                                      
+    Vladimir Bolshakov                                                                                                                                                                                                                        
+    Zearin                                                                                                                                                                                                                                     
+    palaviv   
+
+
+Happy testing,
+The py.test Development Team
+
+
+2.9.1 (compared to 2.9.0)
+-------------------------
+
+**Bug Fixes**
+
+* Improve error message when a plugin fails to load.
+  Thanks `@nicoddemus`_ for the PR.
+
+* Fix (`#1178 <https://github.com/pytest-dev/pytest/issues/1178>`_):
+  ``pytest.fail`` with non-ascii characters raises an internal pytest error.
+  Thanks `@nicoddemus`_ for the PR.
+
+* Fix (`#469`_): junit parses report.nodeid incorrectly, when params IDs
+  contain ``::``. Thanks `@tomviner`_ for the PR (`#1431`_).
+
+* Fix (`#578 <https://github.com/pytest-dev/pytest/issues/578>`_): SyntaxErrors
+  containing non-ascii lines at the point of failure generated an internal
+  py.test error.
+  Thanks `@asottile`_ for the report and `@nicoddemus`_ for the PR.
+
+* Fix (`#1437`_): When passing in a bytestring regex pattern to parameterize
+  attempt to decode it as utf-8 ignoring errors.
+
+* Fix (`#649`_): parametrized test nodes cannot be specified to run on the command line.
+
+
+.. _#1437: https://github.com/pytest-dev/pytest/issues/1437
+.. _#469: https://github.com/pytest-dev/pytest/issues/469
+.. _#1431: https://github.com/pytest-dev/pytest/pull/1431
+.. _#649: https://github.com/pytest-dev/pytest/issues/649
+
+.. _@asottile: https://github.com/asottile

doc/en/announce/sprint2016.rst

@@ -0,0 +1,105 @@
+python testing sprint June 20th-26th 2016
+======================================================
+
+.. image:: ../img/freiburg2.jpg
+   :width: 400
+
+The pytest core group is heading towards the biggest sprint
+in its history, to take place in the black forest town Freiburg
+in Germany.  As of February 2016 we have started a `funding
+campaign on Indiegogo to cover expenses
+<http://igg.me/at/pytest-sprint/x/4034848>`_ The page also mentions
+some preliminary topics:
+
+- improving pytest-xdist test scheduling to take into account
+  fixture setups and explicit user hints.
+
+- provide info on fixture dependencies during --collect-only
+
+- tying pytest-xdist to tox so that you can do "py.test -e py34"
+  to run tests in a particular tox-managed virtualenv.  Also
+  look into making pytest-xdist use tox environments on
+  remote ssh-sides so that remote dependency management becomes
+  easier.
+
+- refactoring the fixture system so more people understand it :)
+
+- integrating PyUnit setup methods as autouse fixtures.
+  possibly adding ways to influence ordering of same-scoped
+  fixtures (so you can make a choice of which fixtures come
+  before others)
+
+- fixing bugs and issues from the tracker, really an endless source :)
+
+
+Participants
+--------------
+
+Here are preliminary participants who said they are likely to come,
+given some expenses funding::
+
+    Anatoly Bubenkoff, Netherlands
+    Andreas Pelme, Personalkollen, Sweden
+    Anthony Wang, Splunk, US
+    Brianna Laugher, Australia
+    Bruno Oliveira, Brazil
+    Danielle Jenkins, Splunk, US
+    Dave Hunt, UK
+    Florian Bruhin, Switzerland
+    Floris Bruynooghe, Cobe.io, UK
+    Holger Krekel, merlinux, Germany
+    Oliver Bestwalter, Avira, Germany
+    Omar Kohl, Germany
+    Raphael Pierzina, FanDuel, UK
+    Tom Viner, UK
+
+    <your name here?>
+
+Other contributors and experienced newcomers are invited to join as well
+but please send a mail to the pytest-dev mailing list if you intend to
+do so somewhat soon, also how much funding you need if so.  And if you
+are working for a company and using pytest heavily you are welcome to
+join and we encourage your company to provide some funding for the
+sprint.  They may see it, and rightfully so, as a very cheap and deep
+training which brings you together with the experts in the field :)
+
+
+Sprint organisation, schedule
+-------------------------------
+
+tentative schedule:
+
+- 19/20th arrival in Freiburg
+- 20th social get together, initial hacking
+- 21/22th full sprint days
+- 23rd break day, hiking
+- 24/25th full sprint days
+- 26th departure
+
+We might adjust according to weather to make sure that if
+we do some hiking or excursion we'll have good weather.
+Freiburg is one of the sunniest places in Germany so
+it shouldn't be too much of a constraint.
+
+
+Accomodation
+----------------
+
+We'll see to arrange for renting a flat with multiple
+beds/rooms.  Hotels are usually below 100 per night.
+The earlier we book the better.
+
+Money / funding
+---------------
+
+The Indiegogo campaign asks for 11000 USD which should cover
+the costs for flights and accomodation, renting a sprint place
+and maybe a bit of food as well.
+
+If your organisation wants to support the sprint but prefers
+to give money according to an invoice, get in contact with
+holger at http://merlinux.eu who can invoice your organisation
+properly.
+
+If we have excess money we'll use for further sprint/travel
+funding for pytest/tox contributors.

doc/en/assert.rst

@@ -26,7 +26,7 @@ you will see the return value of the function call::
 
     $ py.test test_assert1.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     
@@ -81,13 +81,10 @@ and if you need to have access to the actual exception info you may use::
             f()
         assert 'maximum recursion' in str(excinfo.value)
 
-``excinfo`` is a `py.code.ExceptionInfo`_ instance, which is a wrapper around
+``excinfo`` is a ``ExceptionInfo`` instance, which is a wrapper around
 the actual exception raised.  The main attributes of interest are
 ``.type``, ``.value`` and ``.traceback``.
 
-.. _py.code.ExceptionInfo:
-    http://pylib.readthedocs.org/en/latest/code.html#py-code-exceptioninfo
-
 If you want to write test code that works on Python 2.4 as well,
 you may also use two other ways to test for an expected exception::
 
@@ -146,7 +143,7 @@ if you run this module::
 
     $ py.test test_assert2.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     
@@ -243,10 +240,9 @@ recording the intermediate values. Which technique is used depends on the
 location of the assert, ``pytest`` configuration, and Python version being used
 to run ``pytest``.
 
-By default, if the Python version is greater than or equal to 2.6, ``pytest``
-rewrites assert statements in test modules. Rewritten assert statements put
-introspection information into the assertion failure message. ``pytest`` only
-rewrites test modules directly discovered by its test collection process, so
+By default, ``pytest`` rewrites assert statements in test modules.
+Rewritten assert statements put introspection information into the assertion failure message.
+``pytest`` only rewrites test modules directly discovered by its test collection process, so
 asserts in supporting modules which are not themselves test modules will not be
 rewritten.
 

doc/en/cache.rst

@@ -17,8 +17,8 @@ Usage
 The plugin provides two command line options to rerun failures from the
 last ``py.test`` invocation:
 
-* ``--lf`` (last failures) - to only re-run the failures.
-* ``--ff`` (failures first) - to run the failures first and then the rest of
+* ``--lf``, ``--last-failed`` - to only re-run the failures.
+* ``--ff``, ``--failed-first`` - to run the failures first and then the rest of
   the tests.
 
 For cleanup (usually not needed), a ``--cache-clear`` option allows to remove
@@ -80,7 +80,7 @@ If you then run it with ``--lf``::
 
     $ py.test --lf
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     run-last-failure: rerun last 2 failures
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 50 items
@@ -121,7 +121,7 @@ of ``FF`` and dots)::
 
     $ py.test --ff
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     run-last-failure: rerun last 2 failures first
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 50 items
@@ -226,7 +226,7 @@ You can always peek at the content of the cache using the
 
     $ py.test --cache-clear
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     
@@ -262,7 +262,7 @@ than speed.
 config.cache API
 ------------------
 
-The `config.cache`` object allows other plugins,
+The ``config.cache`` object allows other plugins,
 including ``conftest.py`` files,
 to safely and flexibly store and retrieve values across
 test runs because the ``config`` object is available

doc/en/capture.rst

@@ -64,7 +64,7 @@ of the failing function and hide the other one::
 
     $ py.test
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     

doc/en/changelog.rst

@@ -4,4 +4,4 @@
 Changelog history
 =================================
 
-.. include:: ../../CHANGELOG
+.. include:: ../../CHANGELOG.rst

doc/en/contents.rst

@@ -13,8 +13,13 @@ Full pytest documentation
    overview
    apiref
    example/index
-   plugins
+   monkeypatch
+   tmpdir
+   capture
+   recwarn
    cache
+   plugins
+
    contributing
    talks
 

doc/en/doctest.rst

@@ -8,7 +8,10 @@ can change the pattern by issuing::
 
     py.test --doctest-glob='*.rst'
 
-on the command line.  You can also trigger running of doctests
+on the command line. Since version ``2.9``, ``--doctest-glob``
+can be given multiple times in the command-line.
+
+You can also trigger running of doctests
 from docstrings in all python modules (including regular
 python test modules)::
 
@@ -46,7 +49,7 @@ then you can just invoke ``py.test`` without command line options::
 
     $ py.test
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: pytest.ini
     collected 1 items
     
@@ -67,19 +70,32 @@ when executing text doctest files.
 The standard ``doctest`` module provides some setting flags to configure the
 strictness of doctest tests. In py.test You can enable those flags those flags
 using the configuration file. To make pytest ignore trailing whitespaces and
-ignore lengthy exception stack traces you can just write::
+ignore lengthy exception stack traces you can just write:
+
+.. code-block:: ini
 
-    # content of pytest.ini
     [pytest]
     doctest_optionflags= NORMALIZE_WHITESPACE IGNORE_EXCEPTION_DETAIL
 
+py.test also introduces new options to allow doctests to run in Python 2 and
+Python 3 unchanged:
 
-py.test also introduces a new ``ALLOW_UNICODE`` option flag: when enabled, the
-``u`` prefix is stripped from unicode strings in expected doctest output. This
-allows doctests which use unicode to run in Python 2 and 3 unchanged.
+* ``ALLOW_UNICODE``: when enabled, the ``u`` prefix is stripped from unicode
+  strings in expected doctest output.
 
-As with any other option flag, this flag can be enabled in ``pytest.ini`` using
-the ``doctest_optionflags`` ini option or by an inline comment in the doc test
+* ``ALLOW_BYTES``: when enabled, the ``b`` prefix is stripped from byte strings
+  in expected doctest output.
+
+As with any other option flag, these flags can be enabled in ``pytest.ini`` using
+the ``doctest_optionflags`` ini option:
+
+.. code-block:: ini
+
+    [pytest]
+    doctest_optionflags = ALLOW_UNICODE ALLOW_BYTES
+
+
+Alternatively, it can be enabled by an inline comment in the doc test
 itself::
 
     # content of example.rst

doc/en/example/assertion/failure_demo.py

@@ -1,4 +1,5 @@
 from pytest import raises
+import _pytest._code
 import py
 
 def otherfunc(a,b):
@@ -159,7 +160,7 @@ def test_dynamic_compile_shows_nicely():
     src = 'def foo():\n assert 1 == 0\n'
     name = 'abc-123'
     module = py.std.imp.new_module(name)
-    code = py.code.compile(src, name, 'exec')
+    code = _pytest._code.compile(src, name, 'exec')
     py.builtin.exec_(code, module.__dict__)
     py.std.sys.modules[name] = module
     module.foo()

doc/en/example/markers.rst

@@ -31,7 +31,7 @@ You can then restrict a test run to only run tests marked with ``webtest``::
 
     $ py.test -v -m webtest
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 4 items
@@ -45,7 +45,7 @@ Or the inverse, running all tests except the webtest ones::
 
     $ py.test -v -m "not webtest"
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 4 items
@@ -66,7 +66,7 @@ tests based on their module, class, method, or function name::
 
     $ py.test -v test_server.py::TestClass::test_method
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 5 items
@@ -79,7 +79,7 @@ You can also select on the class::
 
     $ py.test -v test_server.py::TestClass
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 4 items
@@ -92,7 +92,7 @@ Or select multiple nodes::
 
   $ py.test -v test_server.py::TestClass test_server.py::test_send_http
   ======= test session starts ========
-  platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
+  platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
   cachedir: .cache
   rootdir: $REGENDOC_TMPDIR, inifile: 
   collecting ... collected 8 items
@@ -130,7 +130,7 @@ select tests based on their names::
 
     $ py.test -v -k http  # running with the above defined example module
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 4 items
@@ -144,7 +144,7 @@ And you can also run all tests except the ones that match the keyword::
 
     $ py.test -k "not send_http" -v
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 4 items
@@ -160,7 +160,7 @@ Or to select "http" and "quick" tests::
 
     $ py.test -k "http or quick" -v
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 4 items
@@ -234,8 +234,8 @@ For an example on how to add and work with markers from a plugin, see
 Marking whole classes or modules
 ----------------------------------------------------
 
-If you are programming with Python 2.6 or later you may use ``pytest.mark``
-decorators with classes to apply markers to all of its test methods::
+You may use ``pytest.mark`` decorators with classes to apply markers to all of
+its test methods::
 
     # content of test_mark_classlevel.py
     import pytest
@@ -350,7 +350,7 @@ the test needs::
 
     $ py.test -E stage2
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     
@@ -362,7 +362,7 @@ and here is one that specifies exactly the environment needed::
 
     $ py.test -E stage1
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     
@@ -481,7 +481,7 @@ then you will see two test skipped and two executed tests as expected::
 
     $ py.test -rs # this option reports skip reasons
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 4 items
     
@@ -495,7 +495,7 @@ Note that if you specify a platform via the marker-command line option like this
 
     $ py.test -m linux2
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 4 items
     
@@ -547,7 +547,7 @@ We can now use the ``-m option`` to select one set::
 
   $ py.test -m interface --tb=short
   ======= test session starts ========
-  platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+  platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
   rootdir: $REGENDOC_TMPDIR, inifile: 
   collected 4 items
   
@@ -569,7 +569,7 @@ or to select both "event" and "interface" tests::
 
   $ py.test -m "interface or event" --tb=short
   ======= test session starts ========
-  platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+  platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
   rootdir: $REGENDOC_TMPDIR, inifile: 
   collected 4 items
   

doc/en/example/multipython.py

@@ -4,6 +4,7 @@ serialization via the pickle module.
 """
 import py
 import pytest
+import _pytest._code
 
 pythonlist = ['python2.6', 'python2.7', 'python3.3']
 @pytest.fixture(params=pythonlist)
@@ -23,7 +24,7 @@ class Python:
         self.picklefile = picklefile
     def dumps(self, obj):
         dumpfile = self.picklefile.dirpath("dump.py")
-        dumpfile.write(py.code.Source("""
+        dumpfile.write(_pytest._code.Source("""
             import pickle
             f = open(%r, 'wb')
             s = pickle.dump(%r, f, protocol=2)
@@ -33,7 +34,7 @@ class Python:
 
     def load_and_is_true(self, expression):
         loadfile = self.picklefile.dirpath("load.py")
-        loadfile.write(py.code.Source("""
+        loadfile.write(_pytest._code.Source("""
             import pickle
             f = open(%r, 'rb')
             obj = pickle.load(f)

doc/en/example/nonpython.rst

@@ -27,7 +27,7 @@ now execute the test specification::
 
     nonpython $ py.test test_simple.yml
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR/nonpython, inifile: 
     collected 2 items
     
@@ -59,7 +59,7 @@ consulted when reporting in ``verbose`` mode::
 
     nonpython $ py.test -v
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR/nonpython, inifile: 
     collecting ... collected 2 items
@@ -81,7 +81,7 @@ interesting to just look at the collection tree::
 
     nonpython $ py.test --collect-only
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR/nonpython, inifile: 
     collected 2 items
     <YamlFile 'test_simple.yml'>

doc/en/example/parametrize.rst

@@ -130,7 +130,7 @@ objects, they are still using the default pytest representation::
 
     $ py.test test_time.py --collect-only
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 6 items
     <Module 'test_time.py'>
@@ -181,7 +181,7 @@ this is a fully self-contained example which you can run with::
 
     $ py.test test_scenarios.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 4 items
     
@@ -194,7 +194,7 @@ If you just collect tests you'll also nicely see 'advanced' and 'basic' as varia
 
     $ py.test --collect-only test_scenarios.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 4 items
     <Module 'test_scenarios.py'>
@@ -259,7 +259,7 @@ Let's first see how it looks like at collection time::
 
     $ py.test test_backends.py --collect-only
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     <Module 'test_backends.py'>
@@ -320,7 +320,7 @@ The result of this test will be successful::
 
     $ py.test test_indirect_list.py --collect-only
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     <Module 'test_indirect_list.py'>
@@ -397,8 +397,11 @@ is to be run with different sets of arguments for its three arguments:
 Running it results in some skips if we don't have all the python interpreters installed and otherwise runs all combinations (5 interpreters times 5 interpreters times 3 objects to serialize/deserialize)::
 
    . $ py.test -rs -q multipython.py
-   ...........................
-   27 passed in 0.12 seconds
+   ssssssssssss...ssssssssssss
+   ======= short test summary info ========
+   SKIP [12] $REGENDOC_TMPDIR/CWD/multipython.py:23: 'python3.3' not found
+   SKIP [12] $REGENDOC_TMPDIR/CWD/multipython.py:23: 'python2.6' not found
+   3 passed, 24 skipped in 0.12 seconds
 
 Indirect parametrization of optional implementations/imports
 --------------------------------------------------------------------
@@ -445,7 +448,7 @@ If you run this with reporting for skips enabled::
 
     $ py.test -rs test_module.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     

doc/en/example/pythoncollection.rst

@@ -82,7 +82,7 @@ then the test collection looks like this::
 
     $ py.test --collect-only
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: setup.cfg
     collected 2 items
     <Module 'check_myapp.py'>
@@ -128,7 +128,7 @@ You can always peek at the collection tree without running tests like this::
 
     . $ py.test --collect-only pythoncollection.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: pytest.ini
     collected 3 items
     <Module 'CWD/pythoncollection.py'>
@@ -182,7 +182,7 @@ interpreters and will leave out the setup.py file::
 
     $ py.test --collect-only
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: pytest.ini
     collected 0 items
     

doc/en/example/reportingdemo.rst

@@ -13,7 +13,7 @@ get on the terminal - we are working on that):
 
     assertion $ py.test failure_demo.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR/assertion, inifile: 
     collected 42 items
     
@@ -28,7 +28,7 @@ get on the terminal - we are working on that):
     >       assert param1 * 2 < param2
     E       assert (3 * 2) < 6
     
-    failure_demo.py:15: AssertionError
+    failure_demo.py:16: AssertionError
     _______ TestFailing.test_simple ________
     
     self = <failure_demo.TestFailing object at 0xdeadbeef>
@@ -44,7 +44,7 @@ get on the terminal - we are working on that):
     E        +  where 42 = <function TestFailing.test_simple.<locals>.f at 0xdeadbeef>()
     E        +  and   43 = <function TestFailing.test_simple.<locals>.g at 0xdeadbeef>()
     
-    failure_demo.py:28: AssertionError
+    failure_demo.py:29: AssertionError
     _______ TestFailing.test_simple_multiline ________
     
     self = <failure_demo.TestFailing object at 0xdeadbeef>
@@ -54,7 +54,7 @@ get on the terminal - we are working on that):
                       42,
     >                 6*9)
     
-    failure_demo.py:33: 
+    failure_demo.py:34: 
     _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
     
     a = 42, b = 54
@@ -64,7 +64,7 @@ get on the terminal - we are working on that):
                     b)
     E       assert 42 == 54
     
-    failure_demo.py:11: AssertionError
+    failure_demo.py:12: AssertionError
     _______ TestFailing.test_not ________
     
     self = <failure_demo.TestFailing object at 0xdeadbeef>
@@ -76,7 +76,7 @@ get on the terminal - we are working on that):
     E       assert not 42
     E        +  where 42 = <function TestFailing.test_not.<locals>.f at 0xdeadbeef>()
     
-    failure_demo.py:38: AssertionError
+    failure_demo.py:39: AssertionError
     _______ TestSpecialisedExplanations.test_eq_text ________
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -87,7 +87,7 @@ get on the terminal - we are working on that):
     E         - spam
     E         + eggs
     
-    failure_demo.py:42: AssertionError
+    failure_demo.py:43: AssertionError
     _______ TestSpecialisedExplanations.test_eq_similar_text ________
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -100,7 +100,7 @@ get on the terminal - we are working on that):
     E         + foo 2 bar
     E         ?     ^
     
-    failure_demo.py:45: AssertionError
+    failure_demo.py:46: AssertionError
     _______ TestSpecialisedExplanations.test_eq_multiline_text ________
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -113,7 +113,7 @@ get on the terminal - we are working on that):
     E         + eggs
     E           bar
     
-    failure_demo.py:48: AssertionError
+    failure_demo.py:49: AssertionError
     _______ TestSpecialisedExplanations.test_eq_long_text ________
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -130,7 +130,7 @@ get on the terminal - we are working on that):
     E         + 1111111111b222222222
     E         ?           ^
     
-    failure_demo.py:53: AssertionError
+    failure_demo.py:54: AssertionError
     _______ TestSpecialisedExplanations.test_eq_long_text_multiline ________
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -154,7 +154,7 @@ get on the terminal - we are working on that):
     E           2
     E           2
     
-    failure_demo.py:58: AssertionError
+    failure_demo.py:59: AssertionError
     _______ TestSpecialisedExplanations.test_eq_list ________
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -165,7 +165,7 @@ get on the terminal - we are working on that):
     E         At index 2 diff: 2 != 3
     E         Use -v to get the full diff
     
-    failure_demo.py:61: AssertionError
+    failure_demo.py:62: AssertionError
     _______ TestSpecialisedExplanations.test_eq_list_long ________
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -178,7 +178,7 @@ get on the terminal - we are working on that):
     E         At index 100 diff: 1 != 2
     E         Use -v to get the full diff
     
-    failure_demo.py:66: AssertionError
+    failure_demo.py:67: AssertionError
     _______ TestSpecialisedExplanations.test_eq_dict ________
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -195,7 +195,7 @@ get on the terminal - we are working on that):
     E         {'d': 0}
     E         Use -v to get the full diff
     
-    failure_demo.py:69: AssertionError
+    failure_demo.py:70: AssertionError
     _______ TestSpecialisedExplanations.test_eq_set ________
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -212,7 +212,7 @@ get on the terminal - we are working on that):
     E         21
     E         Use -v to get the full diff
     
-    failure_demo.py:72: AssertionError
+    failure_demo.py:73: AssertionError
     _______ TestSpecialisedExplanations.test_eq_longer_list ________
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -223,7 +223,7 @@ get on the terminal - we are working on that):
     E         Right contains more items, first extra item: 3
     E         Use -v to get the full diff
     
-    failure_demo.py:75: AssertionError
+    failure_demo.py:76: AssertionError
     _______ TestSpecialisedExplanations.test_in_list ________
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -232,7 +232,7 @@ get on the terminal - we are working on that):
     >       assert 1 in [0, 2, 3, 4, 5]
     E       assert 1 in [0, 2, 3, 4, 5]
     
-    failure_demo.py:78: AssertionError
+    failure_demo.py:79: AssertionError
     _______ TestSpecialisedExplanations.test_not_in_text_multiline ________
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -250,7 +250,7 @@ get on the terminal - we are working on that):
     E           and a
     E           tail
     
-    failure_demo.py:82: AssertionError
+    failure_demo.py:83: AssertionError
     _______ TestSpecialisedExplanations.test_not_in_text_single ________
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -263,7 +263,7 @@ get on the terminal - we are working on that):
     E           single foo line
     E         ?        +++
     
-    failure_demo.py:86: AssertionError
+    failure_demo.py:87: AssertionError
     _______ TestSpecialisedExplanations.test_not_in_text_single_long ________
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -276,7 +276,7 @@ get on the terminal - we are working on that):
     E           head head foo tail tail tail tail tail tail tail tail tail tail tail tail tail tail tail tail tail tail tail tail 
     E         ?           +++
     
-    failure_demo.py:90: AssertionError
+    failure_demo.py:91: AssertionError
     ______ TestSpecialisedExplanations.test_not_in_text_single_long_term _______
     
     self = <failure_demo.TestSpecialisedExplanations object at 0xdeadbeef>
@@ -289,7 +289,7 @@ get on the terminal - we are working on that):
     E           head head fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffftail tail tail tail tail tail tail tail tail tail tail tail tail tail tail tail tail tail tail tail 
     E         ?           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     
-    failure_demo.py:94: AssertionError
+    failure_demo.py:95: AssertionError
     _______ test_attribute ________
     
         def test_attribute():
@@ -300,7 +300,7 @@ get on the terminal - we are working on that):
     E       assert 1 == 2
     E        +  where 1 = <failure_demo.test_attribute.<locals>.Foo object at 0xdeadbeef>.b
     
-    failure_demo.py:101: AssertionError
+    failure_demo.py:102: AssertionError
     _______ test_attribute_instance ________
     
         def test_attribute_instance():
@@ -311,7 +311,7 @@ get on the terminal - we are working on that):
     E        +  where 1 = <failure_demo.test_attribute_instance.<locals>.Foo object at 0xdeadbeef>.b
     E        +    where <failure_demo.test_attribute_instance.<locals>.Foo object at 0xdeadbeef> = <class 'failure_demo.test_attribute_instance.<locals>.Foo'>()
     
-    failure_demo.py:107: AssertionError
+    failure_demo.py:108: AssertionError
     _______ test_attribute_failure ________
     
         def test_attribute_failure():
@@ -322,7 +322,7 @@ get on the terminal - we are working on that):
             i = Foo()
     >       assert i.b == 2
     
-    failure_demo.py:116: 
+    failure_demo.py:117: 
     _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
     
     self = <failure_demo.test_attribute_failure.<locals>.Foo object at 0xdeadbeef>
@@ -331,7 +331,7 @@ get on the terminal - we are working on that):
     >       raise Exception('Failed to get attrib')
     E       Exception: Failed to get attrib
     
-    failure_demo.py:113: Exception
+    failure_demo.py:114: Exception
     _______ test_attribute_multiple ________
     
         def test_attribute_multiple():
@@ -346,7 +346,7 @@ get on the terminal - we are working on that):
     E        +  and   2 = <failure_demo.test_attribute_multiple.<locals>.Bar object at 0xdeadbeef>.b
     E        +    where <failure_demo.test_attribute_multiple.<locals>.Bar object at 0xdeadbeef> = <class 'failure_demo.test_attribute_multiple.<locals>.Bar'>()
     
-    failure_demo.py:124: AssertionError
+    failure_demo.py:125: AssertionError
     _______ TestRaises.test_raises ________
     
     self = <failure_demo.TestRaises object at 0xdeadbeef>
@@ -355,22 +355,22 @@ get on the terminal - we are working on that):
             s = 'qwe'
     >       raises(TypeError, "int(s)")
     
-    failure_demo.py:133: 
+    failure_demo.py:134: 
     _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
     
     >   int(s)
     E   ValueError: invalid literal for int() with base 10: 'qwe'
     
-    <0-codegen $PYTHON_PREFIX/lib/python3.4/site-packages/_pytest/python.py:1300>:1: ValueError
+    <0-codegen $PYTHON_PREFIX/lib/python3.4/site-packages/_pytest/python.py:1302>:1: ValueError
     _______ TestRaises.test_raises_doesnt ________
     
     self = <failure_demo.TestRaises object at 0xdeadbeef>
     
         def test_raises_doesnt(self):
     >       raises(IOError, "int('3')")
-    E       Failed: DID NOT RAISE
+    E       Failed: DID NOT RAISE <class 'OSError'>
     
-    failure_demo.py:136: Failed
+    failure_demo.py:137: Failed
     _______ TestRaises.test_raise ________
     
     self = <failure_demo.TestRaises object at 0xdeadbeef>
@@ -379,7 +379,7 @@ get on the terminal - we are working on that):
     >       raise ValueError("demo error")
     E       ValueError: demo error
     
-    failure_demo.py:139: ValueError
+    failure_demo.py:140: ValueError
     _______ TestRaises.test_tupleerror ________
     
     self = <failure_demo.TestRaises object at 0xdeadbeef>
@@ -388,7 +388,7 @@ get on the terminal - we are working on that):
     >       a,b = [1]
     E       ValueError: need more than 1 value to unpack
     
-    failure_demo.py:142: ValueError
+    failure_demo.py:143: ValueError
     ______ TestRaises.test_reinterpret_fails_with_print_for_the_fun_of_it ______
     
     self = <failure_demo.TestRaises object at 0xdeadbeef>
@@ -399,7 +399,7 @@ get on the terminal - we are working on that):
     >       a,b = l.pop()
     E       TypeError: 'int' object is not iterable
     
-    failure_demo.py:147: TypeError
+    failure_demo.py:148: TypeError
     --------------------------- Captured stdout call ---------------------------
     l is [1, 2, 3]
     _______ TestRaises.test_some_error ________
@@ -410,26 +410,26 @@ get on the terminal - we are working on that):
     >       if namenotexi:
     E       NameError: name 'namenotexi' is not defined
     
-    failure_demo.py:150: NameError
+    failure_demo.py:151: NameError
     _______ test_dynamic_compile_shows_nicely ________
     
         def test_dynamic_compile_shows_nicely():
             src = 'def foo():\n assert 1 == 0\n'
             name = 'abc-123'
             module = py.std.imp.new_module(name)
-            code = py.code.compile(src, name, 'exec')
+            code = _pytest._code.compile(src, name, 'exec')
             py.builtin.exec_(code, module.__dict__)
             py.std.sys.modules[name] = module
     >       module.foo()
     
-    failure_demo.py:165: 
+    failure_demo.py:166: 
     _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
     
         def foo():
     >    assert 1 == 0
     E    assert 1 == 0
     
-    <2-codegen 'abc-123' $REGENDOC_TMPDIR/assertion/failure_demo.py:162>:2: AssertionError
+    <2-codegen 'abc-123' $REGENDOC_TMPDIR/assertion/failure_demo.py:163>:2: AssertionError
     _______ TestMoreErrors.test_complex_error ________
     
     self = <failure_demo.TestMoreErrors object at 0xdeadbeef>
@@ -441,9 +441,9 @@ get on the terminal - we are working on that):
                 return 43
     >       somefunc(f(), g())
     
-    failure_demo.py:175: 
+    failure_demo.py:176: 
     _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
-    failure_demo.py:8: in somefunc
+    failure_demo.py:9: in somefunc
         otherfunc(x,y)
     _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
     
@@ -453,7 +453,7 @@ get on the terminal - we are working on that):
     >       assert a==b
     E       assert 44 == 43
     
-    failure_demo.py:5: AssertionError
+    failure_demo.py:6: AssertionError
     _______ TestMoreErrors.test_z1_unpack_error ________
     
     self = <failure_demo.TestMoreErrors object at 0xdeadbeef>
@@ -463,7 +463,7 @@ get on the terminal - we are working on that):
     >       a,b  = l
     E       ValueError: need more than 0 values to unpack
     
-    failure_demo.py:179: ValueError
+    failure_demo.py:180: ValueError
     _______ TestMoreErrors.test_z2_type_error ________
     
     self = <failure_demo.TestMoreErrors object at 0xdeadbeef>
@@ -473,7 +473,7 @@ get on the terminal - we are working on that):
     >       a,b  = l
     E       TypeError: 'int' object is not iterable
     
-    failure_demo.py:183: TypeError
+    failure_demo.py:184: TypeError
     _______ TestMoreErrors.test_startswith ________
     
     self = <failure_demo.TestMoreErrors object at 0xdeadbeef>
@@ -485,7 +485,7 @@ get on the terminal - we are working on that):
     E       assert <built-in method startswith of str object at 0xdeadbeef>('456')
     E        +  where <built-in method startswith of str object at 0xdeadbeef> = '123'.startswith
     
-    failure_demo.py:188: AssertionError
+    failure_demo.py:189: AssertionError
     _______ TestMoreErrors.test_startswith_nested ________
     
     self = <failure_demo.TestMoreErrors object at 0xdeadbeef>
@@ -501,7 +501,7 @@ get on the terminal - we are working on that):
     E        +    where '123' = <function TestMoreErrors.test_startswith_nested.<locals>.f at 0xdeadbeef>()
     E        +  and   '456' = <function TestMoreErrors.test_startswith_nested.<locals>.g at 0xdeadbeef>()
     
-    failure_demo.py:195: AssertionError
+    failure_demo.py:196: AssertionError
     _______ TestMoreErrors.test_global_func ________
     
     self = <failure_demo.TestMoreErrors object at 0xdeadbeef>
@@ -511,7 +511,7 @@ get on the terminal - we are working on that):
     E       assert isinstance(43, float)
     E        +  where 43 = globf(42)
     
-    failure_demo.py:198: AssertionError
+    failure_demo.py:199: AssertionError
     _______ TestMoreErrors.test_instance ________
     
     self = <failure_demo.TestMoreErrors object at 0xdeadbeef>
@@ -522,7 +522,7 @@ get on the terminal - we are working on that):
     E       assert 42 != 42
     E        +  where 42 = <failure_demo.TestMoreErrors object at 0xdeadbeef>.x
     
-    failure_demo.py:202: AssertionError
+    failure_demo.py:203: AssertionError
     _______ TestMoreErrors.test_compare ________
     
     self = <failure_demo.TestMoreErrors object at 0xdeadbeef>
@@ -532,7 +532,7 @@ get on the terminal - we are working on that):
     E       assert 11 < 5
     E        +  where 11 = globf(10)
     
-    failure_demo.py:205: AssertionError
+    failure_demo.py:206: AssertionError
     _______ TestMoreErrors.test_try_finally ________
     
     self = <failure_demo.TestMoreErrors object at 0xdeadbeef>
@@ -543,7 +543,7 @@ get on the terminal - we are working on that):
     >           assert x == 0
     E           assert 1 == 0
     
-    failure_demo.py:210: AssertionError
+    failure_demo.py:211: AssertionError
     _______ TestCustomAssertMsg.test_single_line ________
     
     self = <failure_demo.TestCustomAssertMsg object at 0xdeadbeef>
@@ -557,7 +557,7 @@ get on the terminal - we are working on that):
     E       assert 1 == 2
     E        +  where 1 = <class 'failure_demo.TestCustomAssertMsg.test_single_line.<locals>.A'>.a
     
-    failure_demo.py:221: AssertionError
+    failure_demo.py:222: AssertionError
     _______ TestCustomAssertMsg.test_multiline ________
     
     self = <failure_demo.TestCustomAssertMsg object at 0xdeadbeef>
@@ -574,7 +574,7 @@ get on the terminal - we are working on that):
     E       assert 1 == 2
     E        +  where 1 = <class 'failure_demo.TestCustomAssertMsg.test_multiline.<locals>.A'>.a
     
-    failure_demo.py:227: AssertionError
+    failure_demo.py:228: AssertionError
     _______ TestCustomAssertMsg.test_custom_repr ________
     
     self = <failure_demo.TestCustomAssertMsg object at 0xdeadbeef>
@@ -594,5 +594,5 @@ get on the terminal - we are working on that):
     E       assert 1 == 2
     E        +  where 1 = This is JSON\n{\n  'foo': 'bar'\n}.a
     
-    failure_demo.py:237: AssertionError
+    failure_demo.py:238: AssertionError
     ======= 42 failed in 0.12 seconds ========

doc/en/example/simple.rst

@@ -108,7 +108,7 @@ directory with the above conftest.py::
 
     $ py.test
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 0 items
     
@@ -156,7 +156,7 @@ and when running it will see a skipped "slow" test::
 
     $ py.test -rs    # "-rs" means report details on the little 's'
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     
@@ -170,7 +170,7 @@ Or run it including the ``slow`` marked test::
 
     $ py.test --runslow
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     
@@ -262,7 +262,7 @@ which will add the string to the test header accordingly::
 
     $ py.test
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     project deps: mylib-1.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 0 items
@@ -286,7 +286,7 @@ which will add info only when run with "--v"::
 
     $ py.test -v
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
     cachedir: .cache
     info1: did you know that ...
     did you?
@@ -299,7 +299,7 @@ and nothing when run plainly::
 
     $ py.test
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 0 items
     
@@ -332,7 +332,7 @@ Now we can profile which test functions execute the slowest::
 
     $ py.test --durations=3
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 3 items
     
@@ -341,7 +341,7 @@ Now we can profile which test functions execute the slowest::
     ======= slowest 3 test durations ========
     0.20s call     test_some_are_slow.py::test_funcslow2
     0.10s call     test_some_are_slow.py::test_funcslow1
-    0.00s setup    test_some_are_slow.py::test_funcslow2
+    0.00s setup    test_some_are_slow.py::test_funcfast
     ======= 3 passed in 0.12 seconds ========
 
 incremental testing - test steps
@@ -394,7 +394,7 @@ If we run this::
 
     $ py.test -rx
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 4 items
     
@@ -465,7 +465,7 @@ We can run this::
 
     $ py.test
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 7 items
     
@@ -479,7 +479,7 @@ We can run this::
     file $REGENDOC_TMPDIR/b/test_error.py, line 1
       def test_root(db):  # no db here, will error out
             fixture 'db' not found
-            available fixtures: record_xml_property, pytestconfig, cache, capsys, recwarn, monkeypatch, tmpdir, capfd, tmpdir_factory
+            available fixtures: record_xml_property, recwarn, cache, capsys, pytestconfig, tmpdir_factory, capfd, monkeypatch, tmpdir
             use 'py.test --fixtures [testpath]' for help on them.
     
     $REGENDOC_TMPDIR/b/test_error.py:1
@@ -569,7 +569,7 @@ and run them::
 
     $ py.test test_module.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     
@@ -660,7 +660,7 @@ and run it::
 
     $ py.test -s test_module.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 3 items
     
@@ -748,4 +748,4 @@ over to ``pytest`` instead. For example::
 This makes it convenient to execute your tests from within your frozen
 application, using standard ``py.test`` command-line options::
 
-    ./app_main --pytest --verbose --tb=long --junit-xml=results.xml test-suite/
+    ./app_main --pytest --verbose --tb=long --junitxml=results.xml test-suite/

doc/en/faq.rst

@@ -66,9 +66,8 @@ This completely avoids previous issues of confusing assertion-reporting.
 It also means, that you can use Python's ``-O`` optimization without losing
 assertions in test modules.
 
-``pytest`` contains a second, mostly obsolete, assert debugging technique,
-invoked via ``--assert=reinterpret``, activated by default on
-Python-2.5: When an ``assert`` statement fails, ``pytest`` re-interprets
+``pytest`` contains a second, mostly obsolete, assert debugging technique
+invoked via ``--assert=reinterpret``: When an ``assert`` statement fails, ``pytest`` re-interprets
 the expression part to show intermediate values.  This technique suffers
 from a caveat that the rewriting does not: If your expression has side
 effects (better to avoid them anyway!) the intermediate values may not

doc/en/fixture.rst

@@ -75,7 +75,7 @@ marked ``smtp`` fixture function.  Running the test looks like this::
 
     $ py.test test_smtpsimple.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     
@@ -193,7 +193,7 @@ inspect what is going on and can now run the tests::
 
     $ py.test test_module.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     
@@ -480,7 +480,7 @@ Running the above tests results in the following test IDs being used::
 
    $ py.test --collect-only
    ======= test session starts ========
-   platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+   platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
    rootdir: $REGENDOC_TMPDIR, inifile: 
    collected 10 items
    <Module 'test_anothersmtp.py'>
@@ -531,7 +531,7 @@ Here we declare an ``app`` fixture which receives the previously defined
 
     $ py.test -v test_appsetup.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 2 items
@@ -597,7 +597,7 @@ Let's run the tests in verbose mode and with looking at the print-output::
 
     $ py.test -v -s test_module.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1 -- $PYTHON_PREFIX/bin/python3.4
     cachedir: .cache
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collecting ... collected 8 items

doc/en/getting-started.rst

@@ -27,7 +27,7 @@ Installation options::
 To check your installation has installed the correct version::
 
     $ py.test --version
-    This is pytest version 2.8.7, imported from $PYTHON_PREFIX/lib/python3.4/site-packages/pytest.py
+    This is pytest version 2.9.1, imported from $PYTHON_PREFIX/lib/python3.4/site-packages/pytest.py
 
 If you get an error checkout :ref:`installation issues`.
 
@@ -49,7 +49,7 @@ That's it. You can execute the test function now::
 
     $ py.test
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     

doc/en/index.rst

@@ -7,6 +7,7 @@ pytest: helps you write better programs
 **a mature full-featured Python testing tool**
 
  - runs on Posix/Windows, Python 2.6-3.5, PyPy and (possibly still) Jython-2.5.1
+ - free and open source software, distributed under the terms of the :ref:`MIT license <license>`
  - **well tested** with more than a thousand tests against itself
  - **strict backward compatibility policy** for safe pytest upgrades
  - :ref:`comprehensive online <toc>` and `PDF documentation <pytest.pdf>`_

doc/en/license.rst

@@ -0,0 +1,32 @@
+.. _license:
+
+License
+-------
+
+Distributed under the terms of the `MIT`_ license, pytest is free and open source software.
+
+::
+
+    The MIT License (MIT)
+
+    Copyright (c) 2004-2016 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
+    the Software without restriction, including without limitation the rights to
+    use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+    of the Software, and to permit persons to whom the Software is furnished to do
+    so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+
+.. _`MIT`: https://github.com/pytest-dev/pytest/blob/master/LICENSE

doc/en/parametrize.rst

@@ -55,7 +55,7 @@ them in turn::
 
     $ py.test
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 3 items
     
@@ -103,7 +103,7 @@ Let's run this::
 
     $ py.test
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 3 items
     
@@ -142,7 +142,7 @@ Sometimes you may want to implement your own parametrization scheme
 or implement some dynamism for determining the parameters or scope
 of a fixture.   For this, you can use the ``pytest_generate_tests`` hook
 which is called when collecting a test function.  Through the passed in
-`metafunc` object you can inspect the requesting test context and, most
+``metafunc`` object you can inspect the requesting test context and, most
 importantly, you can call ``metafunc.parametrize()`` to cause
 parametrization.
 
@@ -201,7 +201,7 @@ list::
     $ py.test -q -rs test_strings.py
     s
     ======= short test summary info ========
-    SKIP [1] $PYTHON_PREFIX/lib/python3.4/site-packages/_pytest/python.py:1417: got empty parameter set, function test_valid_string at $REGENDOC_TMPDIR/test_strings.py:1
+    SKIP [1] $PYTHON_PREFIX/lib/python3.4/site-packages/_pytest/python.py:1419: got empty parameter set, function test_valid_string at $REGENDOC_TMPDIR/test_strings.py:1
     1 skipped in 0.12 seconds
 
 For further examples, you might want to look at :ref:`more

doc/en/recwarn.rst

@@ -122,3 +122,9 @@ command ``warnings.simplefilter('always')``::
         warnings.warn("deprecated", DeprecationWarning)
         assert len(recwarn) == 1
         assert recwarn.pop(DeprecationWarning)
+
+You can also use it as a contextmanager::
+
+    def test_global():
+        with pytest.deprecated_call():
+            myobject.deprecated_method()

doc/en/skipping.rst

@@ -29,8 +29,23 @@ corresponding to the "short" letters shown in the test progress::
 Marking a test function to be skipped
 -------------------------------------------
 
+.. versionadded:: 2.9
+
+The simplest way to skip a test function is to mark it with the ``skip`` decorator
+which may be passed an optional ``reason``:
+
+.. code-block:: python
+
+    @pytest.mark.skip(reason="no way of currently testing this")
+    def test_the_unknown():
+        ...
+
+``skipif``
+~~~~~~~~~~
+
 .. versionadded:: 2.0, 2.4
 
+If you wish to skip something conditionally then you can use ``skipif`` instead.
 Here is an example of marking a test function to be skipped
 when run on a Python3.3 interpreter::
 
@@ -79,9 +94,7 @@ between test modules so it's no longer advertised as the primary method.
 Skip all test functions of a class or module
 ---------------------------------------------
 
-As with all function :ref:`marking <mark>` you can skip test functions at the
-`whole class- or module level`_.  If your code targets python2.6 or above you
-use the skipif decorator (and any other marker) on classes::
+You can use the ``skipif`` decorator (and any other marker) on classes::
 
     @pytest.mark.skipif(sys.platform == 'win32',
                         reason="does not run on windows")
@@ -93,19 +106,6 @@ use the skipif decorator (and any other marker) on classes::
 If the condition is true, this marker will produce a skip result for
 each of the test methods.
 
-If your code targets python2.5 where class-decorators are not available,
-you can set the ``pytestmark`` attribute of a class::
-
-    class TestPosixCalls:
-        pytestmark = pytest.mark.skipif(sys.platform == 'win32',
-                                        reason="does not run on windows")
-
-        def test_function(self):
-            "will not be setup or run under 'win32' platform"
-
-As with the class-decorator, the ``pytestmark`` special name tells
-``pytest`` to apply it to each test function in the class.
-
 If you want to skip all test functions of a module, you must use
 the ``pytestmark`` name on the global level:
 
@@ -125,7 +125,7 @@ Mark a test function as expected to fail
 -------------------------------------------------------
 
 You can use the ``xfail`` marker to indicate that you
-expect the test to fail::
+expect a test to fail::
 
     @pytest.mark.xfail
     def test_function():
@@ -133,14 +133,36 @@ expect the test to fail::
 
 This test will be run but no traceback will be reported
 when it fails. Instead terminal reporting will list it in the
-"expected to fail" or "unexpectedly passing" sections.
+"expected to fail" (``XFAIL``) or "unexpectedly passing" (``XPASS``) sections.
 
-By specifying on the commandline::
+``strict`` parameter
+~~~~~~~~~~~~~~~~~~~~
 
-    pytest --runxfail
+.. versionadded:: 2.9
 
-you can force the running and reporting of an ``xfail`` marked test
-as if it weren't marked at all.
+Both ``XFAIL`` and ``XPASS`` don't fail the test suite, unless the ``strict`` keyword-only
+parameter is passed as ``True``:
+
+.. code-block:: python
+
+    @pytest.mark.xfail(strict=True)
+    def test_function():
+        ...
+
+
+This will make ``XPASS`` ("unexpectedly passing") results from this test to fail the test suite.
+
+You can change the default value of the ``strict`` parameter using the
+``xfail_strict`` ini option:
+
+.. code-block:: ini
+
+    [pytest]
+    xfail_strict=true
+
+
+``reason`` parameter
+~~~~~~~~~~~~~~~~~~~~
 
 As with skipif_ you can also mark your expectation of a failure
 on a particular platform::
@@ -150,14 +172,51 @@ on a particular platform::
     def test_function():
         ...
 
+
+``raises`` parameter
+~~~~~~~~~~~~~~~~~~~~
+
 If you want to be more specific as to why the test is failing, you can specify
-a single exception, or a list of exceptions, in the ``raises`` argument. Then
-the test will be reported as a regular failure if it fails with an
+a single exception, or a list of exceptions, in the ``raises`` argument.
+
+.. code-block:: python
+
+    @pytest.mark.xfail(raises=RuntimeError)
+    def test_function():
+        ...
+
+Then the test will be reported as a regular failure if it fails with an
 exception not mentioned in ``raises``.
 
-You can furthermore prevent the running of an "xfail" test or
-specify a reason such as a bug ID or similar.  Here is
-a simple test file with the several usages:
+``run`` parameter
+~~~~~~~~~~~~~~~~~
+
+If a test should be marked as xfail and reported as such but should not be
+even executed, use the ``run`` parameter as ``False``:
+
+.. code-block:: python
+
+    @pytest.mark.xfail(run=False)
+    def test_function():
+        ...
+
+This is specially useful for marking crashing tests for later inspection.
+
+
+Ignoring xfail marks
+~~~~~~~~~~~~~~~~~~~~
+
+By specifying on the commandline::
+
+    pytest --runxfail
+
+you can force the running and reporting of an ``xfail`` marked test
+as if it weren't marked at all.
+
+Examples
+~~~~~~~~
+
+Here is a simple test file with the several usages:
 
 .. literalinclude:: example/xfail_demo.py
 
@@ -165,7 +224,7 @@ Running it with the report-on-xfail option gives this output::
 
     example $ py.test -rx xfail_demo.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR/example, inifile: 
     collected 7 items
     
@@ -186,6 +245,18 @@ Running it with the report-on-xfail option gives this output::
     
     ======= 7 xfailed in 0.12 seconds ========
 
+xfail signature summary
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Here's the signature of the ``xfail`` marker, using Python 3 keyword-only
+arguments syntax:
+
+.. code-block:: python
+
+    def xfail(condition=None, *, reason=None, raises=None, run=True, strict=False):
+
+
+
 .. _`skip/xfail with parametrize`:
 
 Skip/xfail with parametrize
@@ -194,19 +265,19 @@ Skip/xfail with parametrize
 It is possible to apply markers like skip and xfail to individual
 test instances when using parametrize::
 
-     import pytest
+    import pytest
 
-     @pytest.mark.parametrize(("n", "expected"), [
-         (1, 2),
-	 pytest.mark.xfail((1, 0)),
-	 pytest.mark.xfail(reason="some bug")((1, 3)),
-         (2, 3),
-         (3, 4),
-         (4, 5),
-         pytest.mark.skipif("sys.version_info >= (3,0)")((10, 11)),
-     ])
-     def test_increment(n, expected):
-	 assert n + 1 == expected
+    @pytest.mark.parametrize(("n", "expected"), [
+        (1, 2),
+    pytest.mark.xfail((1, 0)),
+	pytest.mark.xfail(reason="some bug")((1, 3)),
+        (2, 3),
+        (3, 4),
+        (4, 5),
+        pytest.mark.skipif("sys.version_info >= (3,0)")((10, 11)),
+    ])
+    def test_increment(n, expected):
+        assert n + 1 == expected
 
 
 Imperative xfail from within a test or setup function

doc/en/talks.rst

@@ -4,7 +4,7 @@ Talks and Tutorials
 
 .. sidebar:: Next Open Trainings
 
-   `professional testing with pytest and tox <http://www.python-academy.com/courses/specialtopics/python_course_testing.html>`_, 24-26th November 2014, Freiburg, Germany
+   `professional testing with pytest and tox <http://www.python-academy.com/courses/specialtopics/python_course_testing.html>`_, 27-29th June 2016, Freiburg, Germany
 
 .. _`funcargs`: funcargs.html
 
@@ -14,6 +14,9 @@ Talks and blog postings
 .. _`tutorial1 repository`: http://bitbucket.org/pytest-dev/pytest-tutorial1/
 .. _`pycon 2010 tutorial PDF`: http://bitbucket.org/pytest-dev/pytest-tutorial1/raw/tip/pytest-basic.pdf
 
+- `pytest - Rapid Simple Testing, Florian Bruhin, Swiss Python Summit 2016
+  <https://www.youtube.com/watch?v=rCBHkQ_LVIs>`_.
+
 - `Improve your testing with Pytest and Mock, Gabe Hollombe, PyCon SG 2015
   <https://www.youtube.com/watch?v=RcN26hznmk4>`_.
 

doc/en/test/plugin/xdist.rst

@@ -126,7 +126,7 @@ Specifying test exec environments in a conftest.py
 Instead of specifying command line options, you can
 put options values in a ``conftest.py`` file like this::
 
-    option_tx = ['ssh=myhost//python=python2.5', 'popen//python=python2.5']
+    option_tx = ['ssh=myhost//python=python2.7', 'popen//python=python2.7']
     option_dist = True
 
 Any commandline ``--tx`` specifications  will add to the list of
@@ -163,7 +163,7 @@ command line options
 
     (default) no: run tests inprocess, don't distribute.
 ``--tx=xspec``
-    add a test execution environment. some examples: --tx popen//python=python2.5 --tx socket=192.168.1.102:8888 --tx ssh=user@codespeak.net//chdir=testcache
+    add a test execution environment. some examples: --tx popen//python=python2.7 --tx socket=192.168.1.102:8888 --tx ssh=user@codespeak.net//chdir=testcache
 ``-d``
     load-balance tests.  shortcut for '--dist=load'
 ``--rsyncdir=dir1``

doc/en/tmpdir.rst

@@ -29,7 +29,7 @@ Running this would result in a passed test except for the last
 
     $ py.test test_tmpdir.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 1 items
     

doc/en/unittest.rst

@@ -88,7 +88,7 @@ the ``self.db`` values in the traceback::
 
     $ py.test test_unittest_db.py
     ======= test session starts ========
-    platform linux -- Python 3.4.3, pytest-2.8.7, py-1.4.31, pluggy-0.3.1
+    platform linux -- Python 3.4.0, pytest-2.9.1, py-1.4.31, pluggy-0.3.1
     rootdir: $REGENDOC_TMPDIR, inifile: 
     collected 2 items
     

doc/en/usage.rst

@@ -12,8 +12,7 @@ Calling pytest through ``python -m pytest``
 
 .. versionadded:: 2.0
 
-If you use Python-2.5 or later you can invoke testing through the
-Python interpreter from the command line::
+You can invoke testing through the Python interpreter from the command line::
 
     python -m pytest [...]
 
@@ -67,10 +66,13 @@ Examples for modifying traceback printing::
     py.test --showlocals # show local variables in tracebacks
     py.test -l           # show local variables (shortcut)
 
-    py.test --tb=long    # the default informative traceback formatting
-    py.test --tb=native  # the Python standard library formatting
-    py.test --tb=short   # a shorter traceback format
+    py.test --tb=auto    # (default) 'long' tracebacks for the first and last
+                         # entry, but 'short' style for the other entries
+    py.test --tb=long    # exhaustive, informative traceback formatting
+    py.test --tb=short   # shorter traceback format
     py.test --tb=line    # only one line per failure
+    py.test --tb=native  # Python standard library formatting
+    py.test --tb=no      # no traceback at all
 
 Dropping to PDB_ (Python Debugger) on failures
 -----------------------------------------------

doc/en/writing_plugins.rst

@@ -109,7 +109,7 @@ If you want to write a plugin, there are many real-life examples
 you can copy from:
 
 * a custom collection example plugin: :ref:`yaml plugin`
-* around 20 doc:`builtin plugins` which provide pytest's own functionality
+* around 20 :ref:`builtin plugins` which provide pytest's own functionality
 * many `external plugins <http://plugincompat.herokuapp.com>`_ providing additional features
 
 All of these plugins implement the documented `well specified hooks`_
@@ -550,7 +550,7 @@ Reference of objects involved in hooks
 .. autoclass:: _pytest.runner.TestReport()
     :members:
 
-.. autoclass:: _pytest.core.CallOutcome()
+.. autoclass:: _pytest.vendored_packages.pluggy._CallOutcome()
     :members:
 
 .. autofunction:: _pytest.config.get_plugin_manager()

doc/en/xdist.rst

@@ -61,16 +61,16 @@ a lot of I/O this can lead to considerable speed ups.
 Running tests in a Python subprocess
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
-To instantiate a Python-2.4 subprocess and send tests to it, you may type::
+To instantiate a Python-2.7 subprocess and send tests to it, you may type::
 
-    py.test -d --tx popen//python=python2.4
+    py.test -d --tx popen//python=python2.7
 
-This will start a subprocess which is run with the "python2.4"
+This will start a subprocess which is run with the "python2.7"
 Python interpreter, found in your system binary lookup path.
 
 If you prefix the --tx option value like this::
 
-    py.test -d --tx 3*popen//python=python2.4
+    py.test -d --tx 3*popen//python=python2.7
 
 then three subprocesses would be created and the tests
 will be distributed to three subprocesses and run simultanously.
@@ -170,7 +170,7 @@ For example, you could make running with three subprocesses your default::
 You can also add default environments like this::
 
     [pytest]
-    addopts = --tx ssh=myhost//python=python2.5 --tx ssh=myhost//python=python2.6
+    addopts = --tx ssh=myhost//python=python2.7 --tx ssh=myhost//python=python2.6
 
 and then just type::
 

setup.py

@@ -75,7 +75,7 @@ def main():
         # the following should be enabled for release
         install_requires=install_requires,
         extras_require=extras_require,
-        packages=['_pytest', '_pytest.assertion', '_pytest.vendored_packages'],
+        packages=['_pytest', '_pytest.assertion', '_pytest._code', '_pytest.vendored_packages'],
         py_modules=['pytest'],
         zip_safe=False,
     )

testing/acceptance_test.py

@@ -1,5 +1,8 @@
 import sys
-import py, pytest
+
+import _pytest._code
+import py
+import pytest
 from _pytest.main import EXIT_NOTESTSCOLLECTED, EXIT_USAGEERROR
 
 
@@ -197,7 +200,7 @@ class TestGeneralUsage:
     def test_chdir(self, testdir):
         testdir.tmpdir.join("py").mksymlinkto(py._pydir)
         p = testdir.tmpdir.join("main.py")
-        p.write(py.code.Source("""
+        p.write(_pytest._code.Source("""
             import sys, os
             sys.path.insert(0, '')
             import py
@@ -389,6 +392,20 @@ class TestGeneralUsage:
         monkeypatch.setitem(sys.modules, 'myplugin', mod)
         assert pytest.main(args=[str(tmpdir)], plugins=['myplugin']) == 0
 
+    def test_parameterized_with_bytes_regex(self, testdir):
+        p = testdir.makepyfile("""
+            import re
+            import pytest
+            @pytest.mark.parametrize('r', [re.compile(b'foo')])
+            def test_stuff(r):
+                pass
+        """
+        )
+        res = testdir.runpytest(p)
+        res.stdout.fnmatch_lines([
+            '*1 passed*'
+        ])
+
 
 class TestInvocationVariants:
     def test_earlyinit(self, testdir):
@@ -450,19 +467,16 @@ class TestInvocationVariants:
             "*1 passed*",
         ])
 
-    @pytest.mark.skipif("sys.version_info < (2,5)")
     def test_python_minus_m_invocation_ok(self, testdir):
         p1 = testdir.makepyfile("def test_hello(): pass")
         res = testdir.run(py.std.sys.executable, "-m", "pytest", str(p1))
         assert res.ret == 0
 
-    @pytest.mark.skipif("sys.version_info < (2,5)")
     def test_python_minus_m_invocation_fail(self, testdir):
         p1 = testdir.makepyfile("def test_fail(): 0/0")
         res = testdir.run(py.std.sys.executable, "-m", "pytest", str(p1))
         assert res.ret == 1
 
-    @pytest.mark.skipif("sys.version_info < (2,5)")
     def test_python_pytest_package(self, testdir):
         p1 = testdir.makepyfile("def test_pass(): pass")
         res = testdir.run(py.std.sys.executable, "-m", "pytest", str(p1))

testing/code/test_code.py

@@ -0,0 +1,174 @@
+import sys
+
+import _pytest._code
+import py
+import pytest
+
+
+def test_ne():
+    code1 = _pytest._code.Code(compile('foo = "bar"', '', 'exec'))
+    assert code1 == code1
+    code2 = _pytest._code.Code(compile('foo = "baz"', '', 'exec'))
+    assert code2 != code1
+
+def test_code_gives_back_name_for_not_existing_file():
+    name = 'abc-123'
+    co_code = compile("pass\n", name, 'exec')
+    assert co_code.co_filename == name
+    code = _pytest._code.Code(co_code)
+    assert str(code.path) == name
+    assert code.fullsource is None
+
+def test_code_with_class():
+    class A:
+        pass
+    pytest.raises(TypeError, "_pytest._code.Code(A)")
+
+if True:
+    def x():
+        pass
+
+def test_code_fullsource():
+    code = _pytest._code.Code(x)
+    full = code.fullsource
+    assert 'test_code_fullsource()' in str(full)
+
+def test_code_source():
+    code = _pytest._code.Code(x)
+    src = code.source()
+    expected = """def x():
+    pass"""
+    assert str(src) == expected
+
+def test_frame_getsourcelineno_myself():
+    def func():
+        return sys._getframe(0)
+    f = func()
+    f = _pytest._code.Frame(f)
+    source, lineno = f.code.fullsource, f.lineno
+    assert source[lineno].startswith("        return sys._getframe(0)")
+
+def test_getstatement_empty_fullsource():
+    def func():
+        return sys._getframe(0)
+    f = func()
+    f = _pytest._code.Frame(f)
+    prop = f.code.__class__.fullsource
+    try:
+        f.code.__class__.fullsource = None
+        assert f.statement == _pytest._code.Source("")
+    finally:
+        f.code.__class__.fullsource = prop
+
+def test_code_from_func():
+    co = _pytest._code.Code(test_frame_getsourcelineno_myself)
+    assert co.firstlineno
+    assert co.path
+
+
+
+def test_builtin_patch_unpatch(monkeypatch):
+    cpy_builtin = py.builtin.builtins
+    comp = cpy_builtin.compile
+    def mycompile(*args, **kwargs):
+        return comp(*args, **kwargs)
+    class Sub(AssertionError):
+        pass
+    monkeypatch.setattr(cpy_builtin, 'AssertionError', Sub)
+    monkeypatch.setattr(cpy_builtin, 'compile', mycompile)
+    _pytest._code.patch_builtins()
+    assert cpy_builtin.AssertionError != Sub
+    assert cpy_builtin.compile != mycompile
+    _pytest._code.unpatch_builtins()
+    assert cpy_builtin.AssertionError is Sub
+    assert cpy_builtin.compile == mycompile
+
+
+def test_unicode_handling():
+    value = py.builtin._totext('\xc4\x85\xc4\x87\n', 'utf-8').encode('utf8')
+    def f():
+        raise Exception(value)
+    excinfo = pytest.raises(Exception, f)
+    str(excinfo)
+    if sys.version_info[0] < 3:
+        unicode(excinfo)
+
+
+@pytest.mark.skipif(sys.version_info[0] >= 3, reason='python 2 only issue')
+def test_unicode_handling_syntax_error():
+    value = py.builtin._totext('\xc4\x85\xc4\x87\n', 'utf-8').encode('utf8')
+    def f():
+        raise SyntaxError('invalid syntax', (None, 1, 3, value))
+    excinfo = pytest.raises(Exception, f)
+    str(excinfo)
+    if sys.version_info[0] < 3:
+        unicode(excinfo)
+
+def test_code_getargs():
+    def f1(x):
+        pass
+    c1 = _pytest._code.Code(f1)
+    assert c1.getargs(var=True) == ('x',)
+
+    def f2(x, *y):
+        pass
+    c2 = _pytest._code.Code(f2)
+    assert c2.getargs(var=True) == ('x', 'y')
+
+    def f3(x, **z):
+        pass
+    c3 = _pytest._code.Code(f3)
+    assert c3.getargs(var=True) == ('x', 'z')
+
+    def f4(x, *y, **z):
+        pass
+    c4 = _pytest._code.Code(f4)
+    assert c4.getargs(var=True) == ('x', 'y', 'z')
+
+
+def test_frame_getargs():
+    def f1(x):
+        return sys._getframe(0)
+    fr1 = _pytest._code.Frame(f1('a'))
+    assert fr1.getargs(var=True) == [('x', 'a')]
+
+    def f2(x, *y):
+        return sys._getframe(0)
+    fr2 = _pytest._code.Frame(f2('a', 'b', 'c'))
+    assert fr2.getargs(var=True) == [('x', 'a'), ('y', ('b', 'c'))]
+
+    def f3(x, **z):
+        return sys._getframe(0)
+    fr3 = _pytest._code.Frame(f3('a', b='c'))
+    assert fr3.getargs(var=True) == [('x', 'a'), ('z', {'b': 'c'})]
+
+    def f4(x, *y, **z):
+        return sys._getframe(0)
+    fr4 = _pytest._code.Frame(f4('a', 'b', c='d'))
+    assert fr4.getargs(var=True) == [('x', 'a'), ('y', ('b',)),
+                                     ('z', {'c': 'd'})]
+
+
+class TestExceptionInfo:
+
+    def test_bad_getsource(self):
+        try:
+            if False: pass
+            else: assert False
+        except AssertionError:
+            exci = _pytest._code.ExceptionInfo()
+        assert exci.getrepr()
+
+
+class TestTracebackEntry:
+
+    def test_getsource(self):
+        try:
+            if False: pass
+            else: assert False
+        except AssertionError:
+            exci = _pytest._code.ExceptionInfo()
+        entry = exci.traceback[0]
+        source = entry.getsource()
+        assert len(source) == 4
+        assert 'else: assert False' in source[3]

testing/code/test_excinfo.py

@@ -0,0 +1,911 @@
+# -*- coding: utf-8 -*-
+
+import _pytest
+import py
+import pytest
+from _pytest._code.code import FormattedExcinfo, ReprExceptionInfo
+
+queue = py.builtin._tryimport('queue', 'Queue')
+
+failsonjython = pytest.mark.xfail("sys.platform.startswith('java')")
+from test_source import astonly
+
+try:
+    import importlib
+except ImportError:
+    invalidate_import_caches = None
+else:
+    invalidate_import_caches = getattr(importlib, "invalidate_caches", None)
+
+import pytest
+pytest_version_info = tuple(map(int, pytest.__version__.split(".")[:3]))
+
+class TWMock:
+    def __init__(self):
+        self.lines = []
+    def sep(self, sep, line=None):
+        self.lines.append((sep, line))
+    def line(self, line, **kw):
+        self.lines.append(line)
+    def markup(self, text, **kw):
+        return text
+
+    fullwidth = 80
+
+def test_excinfo_simple():
+    try:
+        raise ValueError
+    except ValueError:
+        info = _pytest._code.ExceptionInfo()
+    assert info.type == ValueError
+
+def test_excinfo_getstatement():
+    def g():
+        raise ValueError
+    def f():
+        g()
+    try:
+        f()
+    except ValueError:
+        excinfo = _pytest._code.ExceptionInfo()
+    linenumbers = [_pytest._code.getrawcode(f).co_firstlineno - 1 + 3,
+                   _pytest._code.getrawcode(f).co_firstlineno - 1 + 1,
+                   _pytest._code.getrawcode(g).co_firstlineno - 1 + 1, ]
+    l = list(excinfo.traceback)
+    foundlinenumbers = [x.lineno for x in l]
+    assert foundlinenumbers == linenumbers
+    #for x in info:
+    #    print "%s:%d  %s" %(x.path.relto(root), x.lineno, x.statement)
+    #xxx
+
+# testchain for getentries test below
+def f():
+    #
+    raise ValueError
+    #
+def g():
+    #
+    __tracebackhide__ = True
+    f()
+    #
+def h():
+    #
+    g()
+    #
+
+class TestTraceback_f_g_h:
+    def setup_method(self, method):
+        try:
+            h()
+        except ValueError:
+            self.excinfo = _pytest._code.ExceptionInfo()
+
+    def test_traceback_entries(self):
+        tb = self.excinfo.traceback
+        entries = list(tb)
+        assert len(tb) == 4 # maybe fragile test
+        assert len(entries) == 4 # maybe fragile test
+        names = ['f', 'g', 'h']
+        for entry in entries:
+            try:
+                names.remove(entry.frame.code.name)
+            except ValueError:
+                pass
+        assert not names
+
+    def test_traceback_entry_getsource(self):
+        tb = self.excinfo.traceback
+        s = str(tb[-1].getsource() )
+        assert s.startswith("def f():")
+        assert s.endswith("raise ValueError")
+
+    @astonly
+    @failsonjython
+    def test_traceback_entry_getsource_in_construct(self):
+        source = _pytest._code.Source("""\
+            def xyz():
+                try:
+                    raise ValueError
+                except somenoname:
+                    pass
+            xyz()
+        """)
+        try:
+            exec (source.compile())
+        except NameError:
+            tb = _pytest._code.ExceptionInfo().traceback
+            print (tb[-1].getsource())
+            s = str(tb[-1].getsource())
+            assert s.startswith("def xyz():\n    try:")
+            assert s.strip().endswith("except somenoname:")
+
+    def test_traceback_cut(self):
+        co = _pytest._code.Code(f)
+        path, firstlineno = co.path, co.firstlineno
+        traceback = self.excinfo.traceback
+        newtraceback = traceback.cut(path=path, firstlineno=firstlineno)
+        assert len(newtraceback) == 1
+        newtraceback = traceback.cut(path=path, lineno=firstlineno+2)
+        assert len(newtraceback) == 1
+
+    def test_traceback_cut_excludepath(self, testdir):
+        p = testdir.makepyfile("def f(): raise ValueError")
+        excinfo = pytest.raises(ValueError, "p.pyimport().f()")
+        basedir = py.path.local(pytest.__file__).dirpath()
+        newtraceback = excinfo.traceback.cut(excludepath=basedir)
+        for x in newtraceback:
+            if hasattr(x, 'path'):
+                assert not py.path.local(x.path).relto(basedir)
+        assert newtraceback[-1].frame.code.path == p
+
+    def test_traceback_filter(self):
+        traceback = self.excinfo.traceback
+        ntraceback = traceback.filter()
+        assert len(ntraceback) == len(traceback) - 1
+
+    def test_traceback_recursion_index(self):
+        def f(n):
+            if n < 10:
+                n += 1
+            f(n)
+        excinfo = pytest.raises(RuntimeError, f, 8)
+        traceback = excinfo.traceback
+        recindex = traceback.recursionindex()
+        assert recindex == 3
+
+    def test_traceback_only_specific_recursion_errors(self, monkeypatch):
+        def f(n):
+            if n == 0:
+                raise RuntimeError("hello")
+            f(n-1)
+
+        excinfo = pytest.raises(RuntimeError, f, 100)
+        monkeypatch.delattr(excinfo.traceback.__class__, "recursionindex")
+        repr = excinfo.getrepr()
+        assert "RuntimeError: hello" in str(repr.reprcrash)
+
+    def test_traceback_no_recursion_index(self):
+        def do_stuff():
+            raise RuntimeError
+        def reraise_me():
+            import sys
+            exc, val, tb = sys.exc_info()
+            py.builtin._reraise(exc, val, tb)
+        def f(n):
+            try:
+                do_stuff()
+            except:
+                reraise_me()
+        excinfo = pytest.raises(RuntimeError, f, 8)
+        traceback = excinfo.traceback
+        recindex = traceback.recursionindex()
+        assert recindex is None
+
+    def test_traceback_messy_recursion(self):
+        #XXX: simplified locally testable version
+        decorator = pytest.importorskip('decorator').decorator
+
+        def log(f, *k, **kw):
+            print('%s %s' % (k, kw))
+            f(*k, **kw)
+        log = decorator(log)
+
+        def fail():
+            raise ValueError('')
+
+        fail = log(log(fail))
+
+        excinfo = pytest.raises(ValueError, fail)
+        assert excinfo.traceback.recursionindex() is None
+
+
+
+    def test_traceback_getcrashentry(self):
+        def i():
+            __tracebackhide__ = True
+            raise ValueError
+        def h():
+            i()
+        def g():
+            __tracebackhide__ = True
+            h()
+        def f():
+            g()
+
+        excinfo = pytest.raises(ValueError, f)
+        tb = excinfo.traceback
+        entry = tb.getcrashentry()
+        co = _pytest._code.Code(h)
+        assert entry.frame.code.path == co.path
+        assert entry.lineno == co.firstlineno + 1
+        assert entry.frame.code.name == 'h'
+
+    def test_traceback_getcrashentry_empty(self):
+        def g():
+            __tracebackhide__ = True
+            raise ValueError
+        def f():
+            __tracebackhide__ = True
+            g()
+
+        excinfo = pytest.raises(ValueError, f)
+        tb = excinfo.traceback
+        entry = tb.getcrashentry()
+        co = _pytest._code.Code(g)
+        assert entry.frame.code.path == co.path
+        assert entry.lineno == co.firstlineno + 2
+        assert entry.frame.code.name == 'g'
+
+def hello(x):
+    x + 5
+
+def test_tbentry_reinterpret():
+    try:
+        hello("hello")
+    except TypeError:
+        excinfo = _pytest._code.ExceptionInfo()
+    tbentry = excinfo.traceback[-1]
+    msg = tbentry.reinterpret()
+    assert msg.startswith("TypeError: ('hello' + 5)")
+
+def test_excinfo_exconly():
+    excinfo = pytest.raises(ValueError, h)
+    assert excinfo.exconly().startswith('ValueError')
+    excinfo = pytest.raises(ValueError,
+        "raise ValueError('hello\\nworld')")
+    msg = excinfo.exconly(tryshort=True)
+    assert msg.startswith('ValueError')
+    assert msg.endswith("world")
+
+def test_excinfo_repr():
+    excinfo = pytest.raises(ValueError, h)
+    s = repr(excinfo)
+    assert s == "<ExceptionInfo ValueError tblen=4>"
+
+def test_excinfo_str():
+    excinfo = pytest.raises(ValueError, h)
+    s = str(excinfo)
+    assert s.startswith(__file__[:-9]) # pyc file and $py.class
+    assert s.endswith("ValueError")
+    assert len(s.split(":")) >= 3 # on windows it's 4
+
+def test_excinfo_errisinstance():
+    excinfo = pytest.raises(ValueError, h)
+    assert excinfo.errisinstance(ValueError)
+
+def test_excinfo_no_sourcecode():
+    try:
+        exec ("raise ValueError()")
+    except ValueError:
+        excinfo = _pytest._code.ExceptionInfo()
+    s = str(excinfo.traceback[-1])
+    if py.std.sys.version_info < (2,5):
+        assert s == "  File '<string>':1 in ?\n  ???\n"
+    else:
+        assert s == "  File '<string>':1 in <module>\n  ???\n"
+
+def test_excinfo_no_python_sourcecode(tmpdir):
+    #XXX: simplified locally testable version
+    tmpdir.join('test.txt').write("{{ h()}}:")
+
+    jinja2 = pytest.importorskip('jinja2')
+    loader = jinja2.FileSystemLoader(str(tmpdir))
+    env = jinja2.Environment(loader=loader)
+    template = env.get_template('test.txt')
+    excinfo = pytest.raises(ValueError,
+                             template.render, h=h)
+    for item in excinfo.traceback:
+        print(item) #XXX: for some reason jinja.Template.render is printed in full
+        item.source # shouldnt fail
+        if item.path.basename == 'test.txt':
+            assert str(item.source) == '{{ h()}}:'
+
+
+def test_entrysource_Queue_example():
+    try:
+        queue.Queue().get(timeout=0.001)
+    except queue.Empty:
+        excinfo = _pytest._code.ExceptionInfo()
+    entry = excinfo.traceback[-1]
+    source = entry.getsource()
+    assert source is not None
+    s = str(source).strip()
+    assert s.startswith("def get")
+
+def test_codepath_Queue_example():
+    try:
+        queue.Queue().get(timeout=0.001)
+    except queue.Empty:
+        excinfo = _pytest._code.ExceptionInfo()
+    entry = excinfo.traceback[-1]
+    path = entry.path
+    assert isinstance(path, py.path.local)
+    assert path.basename.lower() == "queue.py"
+    assert path.check()
+
+class TestFormattedExcinfo:
+    def pytest_funcarg__importasmod(self, request):
+        def importasmod(source):
+            source = _pytest._code.Source(source)
+            tmpdir = request.getfuncargvalue("tmpdir")
+            modpath = tmpdir.join("mod.py")
+            tmpdir.ensure("__init__.py")
+            modpath.write(source)
+            if invalidate_import_caches is not None:
+                invalidate_import_caches()
+            return modpath.pyimport()
+        return importasmod
+
+    def excinfo_from_exec(self, source):
+        source = _pytest._code.Source(source).strip()
+        try:
+            exec (source.compile())
+        except KeyboardInterrupt:
+            raise
+        except:
+            return _pytest._code.ExceptionInfo()
+        assert 0, "did not raise"
+
+    def test_repr_source(self):
+        pr = FormattedExcinfo()
+        source = _pytest._code.Source("""
+            def f(x):
+                pass
+        """).strip()
+        pr.flow_marker = "|"
+        lines = pr.get_source(source, 0)
+        assert len(lines) == 2
+        assert lines[0] == "|   def f(x):"
+        assert lines[1] == "        pass"
+
+    def test_repr_source_excinfo(self):
+        """ check if indentation is right """
+        pr = FormattedExcinfo()
+        excinfo = self.excinfo_from_exec("""
+                def f():
+                    assert 0
+                f()
+        """)
+        pr = FormattedExcinfo()
+        source = pr._getentrysource(excinfo.traceback[-1])
+        lines = pr.get_source(source, 1, excinfo)
+        assert lines == [
+            '    def f():',
+            '>       assert 0',
+            'E       assert 0'
+        ]
+
+
+    def test_repr_source_not_existing(self):
+        pr = FormattedExcinfo()
+        co = compile("raise ValueError()", "", "exec")
+        try:
+            exec (co)
+        except ValueError:
+            excinfo = _pytest._code.ExceptionInfo()
+        repr = pr.repr_excinfo(excinfo)
+        assert repr.reprtraceback.reprentries[1].lines[0] == ">   ???"
+
+    def test_repr_many_line_source_not_existing(self):
+        pr = FormattedExcinfo()
+        co = compile("""
+a = 1
+raise ValueError()
+""", "", "exec")
+        try:
+            exec (co)
+        except ValueError:
+            excinfo = _pytest._code.ExceptionInfo()
+        repr = pr.repr_excinfo(excinfo)
+        assert repr.reprtraceback.reprentries[1].lines[0] == ">   ???"
+
+    def test_repr_source_failing_fullsource(self):
+        pr = FormattedExcinfo()
+
+        class FakeCode(object):
+            class raw:
+                co_filename = '?'
+            path = '?'
+            firstlineno = 5
+
+            def fullsource(self):
+                return None
+            fullsource = property(fullsource)
+
+        class FakeFrame(object):
+            code = FakeCode()
+            f_locals = {}
+            f_globals = {}
+
+        class FakeTracebackEntry(_pytest._code.Traceback.Entry):
+            def __init__(self, tb):
+                self.lineno = 5+3
+
+            @property
+            def frame(self):
+                return FakeFrame()
+
+        class Traceback(_pytest._code.Traceback):
+            Entry = FakeTracebackEntry
+
+        class FakeExcinfo(_pytest._code.ExceptionInfo):
+            typename = "Foo"
+            def __init__(self):
+                pass
+
+            def exconly(self, tryshort):
+                return "EXC"
+            def errisinstance(self, cls):
+                return False
+
+        excinfo = FakeExcinfo()
+        class FakeRawTB(object):
+            tb_next = None
+        tb = FakeRawTB()
+        excinfo.traceback = Traceback(tb)
+
+        fail = IOError()  # noqa
+        repr = pr.repr_excinfo(excinfo)
+        assert repr.reprtraceback.reprentries[0].lines[0] == ">   ???"
+
+        fail = py.error.ENOENT  # noqa
+        repr = pr.repr_excinfo(excinfo)
+        assert repr.reprtraceback.reprentries[0].lines[0] == ">   ???"
+
+
+    def test_repr_local(self):
+        p = FormattedExcinfo(showlocals=True)
+        loc = {'y': 5, 'z': 7, 'x': 3, '@x': 2, '__builtins__': {}}
+        reprlocals = p.repr_locals(loc)
+        assert reprlocals.lines
+        assert reprlocals.lines[0] == '__builtins__ = <builtins>'
+        assert reprlocals.lines[1] == 'x          = 3'
+        assert reprlocals.lines[2] == 'y          = 5'
+        assert reprlocals.lines[3] == 'z          = 7'
+
+    def test_repr_tracebackentry_lines(self, importasmod):
+        mod = importasmod("""
+            def func1():
+                raise ValueError("hello\\nworld")
+        """)
+        excinfo = pytest.raises(ValueError, mod.func1)
+        excinfo.traceback = excinfo.traceback.filter()
+        p = FormattedExcinfo()
+        reprtb = p.repr_traceback_entry(excinfo.traceback[-1])
+
+        # test as intermittent entry
+        lines = reprtb.lines
+        assert lines[0] == '    def func1():'
+        assert lines[1] == '>       raise ValueError("hello\\nworld")'
+
+        # test as last entry
+        p = FormattedExcinfo(showlocals=True)
+        repr_entry = p.repr_traceback_entry(excinfo.traceback[-1], excinfo)
+        lines = repr_entry.lines
+        assert lines[0] == '    def func1():'
+        assert lines[1] == '>       raise ValueError("hello\\nworld")'
+        assert lines[2] == 'E       ValueError: hello'
+        assert lines[3] == 'E       world'
+        assert not lines[4:]
+
+        loc = repr_entry.reprlocals is not None
+        loc = repr_entry.reprfileloc
+        assert loc.path == mod.__file__
+        assert loc.lineno == 3
+        #assert loc.message == "ValueError: hello"
+
+    def test_repr_tracebackentry_lines2(self, importasmod):
+        mod = importasmod("""
+            def func1(m, x, y, z):
+                raise ValueError("hello\\nworld")
+        """)
+        excinfo = pytest.raises(ValueError, mod.func1, "m"*90, 5, 13, "z"*120)
+        excinfo.traceback = excinfo.traceback.filter()
+        entry = excinfo.traceback[-1]
+        p = FormattedExcinfo(funcargs=True)
+        reprfuncargs = p.repr_args(entry)
+        assert reprfuncargs.args[0] == ('m', repr("m"*90))
+        assert reprfuncargs.args[1] == ('x', '5')
+        assert reprfuncargs.args[2] == ('y', '13')
+        assert reprfuncargs.args[3] == ('z', repr("z" * 120))
+
+        p = FormattedExcinfo(funcargs=True)
+        repr_entry = p.repr_traceback_entry(entry)
+        assert repr_entry.reprfuncargs.args == reprfuncargs.args
+        tw = TWMock()
+        repr_entry.toterminal(tw)
+        assert tw.lines[0] == "m = " + repr('m' * 90)
+        assert tw.lines[1] == "x = 5, y = 13"
+        assert tw.lines[2] == "z = " + repr('z' * 120)
+
+    def test_repr_tracebackentry_lines_var_kw_args(self, importasmod):
+        mod = importasmod("""
+            def func1(x, *y, **z):
+                raise ValueError("hello\\nworld")
+        """)
+        excinfo = pytest.raises(ValueError, mod.func1, 'a', 'b', c='d')
+        excinfo.traceback = excinfo.traceback.filter()
+        entry = excinfo.traceback[-1]
+        p = FormattedExcinfo(funcargs=True)
+        reprfuncargs = p.repr_args(entry)
+        assert reprfuncargs.args[0] == ('x', repr('a'))
+        assert reprfuncargs.args[1] == ('y', repr(('b',)))
+        assert reprfuncargs.args[2] == ('z', repr({'c': 'd'}))
+
+        p = FormattedExcinfo(funcargs=True)
+        repr_entry = p.repr_traceback_entry(entry)
+        assert repr_entry.reprfuncargs.args == reprfuncargs.args
+        tw = TWMock()
+        repr_entry.toterminal(tw)
+        assert tw.lines[0] == "x = 'a', y = ('b',), z = {'c': 'd'}"
+
+    def test_repr_tracebackentry_short(self, importasmod):
+        mod = importasmod("""
+            def func1():
+                raise ValueError("hello")
+            def entry():
+                func1()
+        """)
+        excinfo = pytest.raises(ValueError, mod.entry)
+        p = FormattedExcinfo(style="short")
+        reprtb = p.repr_traceback_entry(excinfo.traceback[-2])
+        lines = reprtb.lines
+        basename = py.path.local(mod.__file__).basename
+        assert lines[0] == '    func1()'
+        assert basename in str(reprtb.reprfileloc.path)
+        assert reprtb.reprfileloc.lineno == 5
+
+        # test last entry
+        p = FormattedExcinfo(style="short")
+        reprtb = p.repr_traceback_entry(excinfo.traceback[-1], excinfo)
+        lines = reprtb.lines
+        assert lines[0] == '    raise ValueError("hello")'
+        assert lines[1] == 'E   ValueError: hello'
+        assert basename in str(reprtb.reprfileloc.path)
+        assert reprtb.reprfileloc.lineno == 3
+
+    def test_repr_tracebackentry_no(self, importasmod):
+        mod = importasmod("""
+            def func1():
+                raise ValueError("hello")
+            def entry():
+                func1()
+        """)
+        excinfo = pytest.raises(ValueError, mod.entry)
+        p = FormattedExcinfo(style="no")
+        p.repr_traceback_entry(excinfo.traceback[-2])
+
+        p = FormattedExcinfo(style="no")
+        reprentry = p.repr_traceback_entry(excinfo.traceback[-1], excinfo)
+        lines = reprentry.lines
+        assert lines[0] == 'E   ValueError: hello'
+        assert not lines[1:]
+
+    def test_repr_traceback_tbfilter(self, importasmod):
+        mod = importasmod("""
+            def f(x):
+                raise ValueError(x)
+            def entry():
+                f(0)
+        """)
+        excinfo = pytest.raises(ValueError, mod.entry)
+        p = FormattedExcinfo(tbfilter=True)
+        reprtb = p.repr_traceback(excinfo)
+        assert len(reprtb.reprentries) == 2
+        p = FormattedExcinfo(tbfilter=False)
+        reprtb = p.repr_traceback(excinfo)
+        assert len(reprtb.reprentries) == 3
+
+    def test_traceback_short_no_source(self, importasmod, monkeypatch):
+        mod = importasmod("""
+            def func1():
+                raise ValueError("hello")
+            def entry():
+                func1()
+        """)
+        excinfo = pytest.raises(ValueError, mod.entry)
+        from _pytest._code.code import Code
+        monkeypatch.setattr(Code, 'path', 'bogus')
+        excinfo.traceback[0].frame.code.path = "bogus"
+        p = FormattedExcinfo(style="short")
+        reprtb = p.repr_traceback_entry(excinfo.traceback[-2])
+        lines = reprtb.lines
+        last_p = FormattedExcinfo(style="short")
+        last_reprtb = last_p.repr_traceback_entry(excinfo.traceback[-1], excinfo)
+        last_lines = last_reprtb.lines
+        monkeypatch.undo()
+        assert lines[0] == '    func1()'
+
+        assert last_lines[0] == '    raise ValueError("hello")'
+        assert last_lines[1] == 'E   ValueError: hello'
+
+    def test_repr_traceback_and_excinfo(self, importasmod):
+        mod = importasmod("""
+            def f(x):
+                raise ValueError(x)
+            def entry():
+                f(0)
+        """)
+        excinfo = pytest.raises(ValueError, mod.entry)
+
+        for style in ("long", "short"):
+            p = FormattedExcinfo(style=style)
+            reprtb = p.repr_traceback(excinfo)
+            assert len(reprtb.reprentries) == 2
+            assert reprtb.style == style
+            assert not reprtb.extraline
+            repr = p.repr_excinfo(excinfo)
+            assert repr.reprtraceback
+            assert len(repr.reprtraceback.reprentries) == len(reprtb.reprentries)
+            assert repr.reprcrash.path.endswith("mod.py")
+            assert repr.reprcrash.message == "ValueError: 0"
+
+    def test_repr_traceback_with_invalid_cwd(self, importasmod, monkeypatch):
+        mod = importasmod("""
+            def f(x):
+                raise ValueError(x)
+            def entry():
+                f(0)
+        """)
+        excinfo = pytest.raises(ValueError, mod.entry)
+
+        p = FormattedExcinfo()
+        def raiseos():
+            raise OSError(2)
+        monkeypatch.setattr(py.std.os, 'getcwd', raiseos)
+        assert p._makepath(__file__) == __file__
+        p.repr_traceback(excinfo)
+
+    def test_repr_excinfo_addouterr(self, importasmod):
+        mod = importasmod("""
+            def entry():
+                raise ValueError()
+        """)
+        excinfo = pytest.raises(ValueError, mod.entry)
+        repr = excinfo.getrepr()
+        repr.addsection("title", "content")
+        twmock = TWMock()
+        repr.toterminal(twmock)
+        assert twmock.lines[-1] == "content"
+        assert twmock.lines[-2] == ("-", "title")
+
+    def test_repr_excinfo_reprcrash(self, importasmod):
+        mod = importasmod("""
+            def entry():
+                raise ValueError()
+        """)
+        excinfo = pytest.raises(ValueError, mod.entry)
+        repr = excinfo.getrepr()
+        assert repr.reprcrash.path.endswith("mod.py")
+        assert repr.reprcrash.lineno == 3
+        assert repr.reprcrash.message == "ValueError"
+        assert str(repr.reprcrash).endswith("mod.py:3: ValueError")
+
+    def test_repr_traceback_recursion(self, importasmod):
+        mod = importasmod("""
+            def rec2(x):
+                return rec1(x+1)
+            def rec1(x):
+                return rec2(x-1)
+            def entry():
+                rec1(42)
+        """)
+        excinfo = pytest.raises(RuntimeError, mod.entry)
+
+        for style in ("short", "long", "no"):
+            p = FormattedExcinfo(style="short")
+            reprtb = p.repr_traceback(excinfo)
+            assert reprtb.extraline == "!!! Recursion detected (same locals & position)"
+            assert str(reprtb)
+
+    def test_tb_entry_AssertionError(self, importasmod):
+        # probably this test is a bit redundant
+        # as py/magic/testing/test_assertion.py
+        # already tests correctness of
+        # assertion-reinterpretation  logic
+        mod = importasmod("""
+            def somefunc():
+                x = 1
+                assert x == 2
+        """)
+        excinfo = pytest.raises(AssertionError, mod.somefunc)
+
+        p = FormattedExcinfo()
+        reprentry = p.repr_traceback_entry(excinfo.traceback[-1], excinfo)
+        lines = reprentry.lines
+        assert lines[-1] == "E       assert 1 == 2"
+
+    def test_reprexcinfo_getrepr(self, importasmod):
+        mod = importasmod("""
+            def f(x):
+                raise ValueError(x)
+            def entry():
+                f(0)
+        """)
+        excinfo = pytest.raises(ValueError, mod.entry)
+
+        for style in ("short", "long", "no"):
+            for showlocals in (True, False):
+                repr = excinfo.getrepr(style=style, showlocals=showlocals)
+                assert isinstance(repr, ReprExceptionInfo)
+                assert repr.reprtraceback.style == style
+
+    def test_reprexcinfo_unicode(self):
+        from _pytest._code.code import TerminalRepr
+        class MyRepr(TerminalRepr):
+            def toterminal(self, tw):
+                tw.line(py.builtin._totext("я", "utf-8"))
+        x = py.builtin._totext(MyRepr())
+        assert x == py.builtin._totext("я", "utf-8")
+
+    def test_toterminal_long(self, importasmod):
+        mod = importasmod("""
+            def g(x):
+                raise ValueError(x)
+            def f():
+                g(3)
+        """)
+        excinfo = pytest.raises(ValueError, mod.f)
+        excinfo.traceback = excinfo.traceback.filter()
+        repr = excinfo.getrepr()
+        tw = TWMock()
+        repr.toterminal(tw)
+        assert tw.lines[0] == ""
+        tw.lines.pop(0)
+        assert tw.lines[0] == "    def f():"
+        assert tw.lines[1] == ">       g(3)"
+        assert tw.lines[2] == ""
+        assert tw.lines[3].endswith("mod.py:5: ")
+        assert tw.lines[4] == ("_ ", None)
+        assert tw.lines[5] == ""
+        assert tw.lines[6] == "    def g(x):"
+        assert tw.lines[7] == ">       raise ValueError(x)"
+        assert tw.lines[8] == "E       ValueError: 3"
+        assert tw.lines[9] == ""
+        assert tw.lines[10].endswith("mod.py:3: ValueError")
+
+    def test_toterminal_long_missing_source(self, importasmod, tmpdir):
+        mod = importasmod("""
+            def g(x):
+                raise ValueError(x)
+            def f():
+                g(3)
+        """)
+        excinfo = pytest.raises(ValueError, mod.f)
+        tmpdir.join('mod.py').remove()
+        excinfo.traceback = excinfo.traceback.filter()
+        repr = excinfo.getrepr()
+        tw = TWMock()
+        repr.toterminal(tw)
+        assert tw.lines[0] == ""
+        tw.lines.pop(0)
+        assert tw.lines[0] == ">   ???"
+        assert tw.lines[1] == ""
+        assert tw.lines[2].endswith("mod.py:5: ")
+        assert tw.lines[3] == ("_ ", None)
+        assert tw.lines[4] == ""
+        assert tw.lines[5] == ">   ???"
+        assert tw.lines[6] == "E   ValueError: 3"
+        assert tw.lines[7] == ""
+        assert tw.lines[8].endswith("mod.py:3: ValueError")
+
+    def test_toterminal_long_incomplete_source(self, importasmod, tmpdir):
+        mod = importasmod("""
+            def g(x):
+                raise ValueError(x)
+            def f():
+                g(3)
+        """)
+        excinfo = pytest.raises(ValueError, mod.f)
+        tmpdir.join('mod.py').write('asdf')
+        excinfo.traceback = excinfo.traceback.filter()
+        repr = excinfo.getrepr()
+        tw = TWMock()
+        repr.toterminal(tw)
+        assert tw.lines[0] == ""
+        tw.lines.pop(0)
+        assert tw.lines[0] == ">   ???"
+        assert tw.lines[1] == ""
+        assert tw.lines[2].endswith("mod.py:5: ")
+        assert tw.lines[3] == ("_ ", None)
+        assert tw.lines[4] == ""
+        assert tw.lines[5] == ">   ???"
+        assert tw.lines[6] == "E   ValueError: 3"
+        assert tw.lines[7] == ""
+        assert tw.lines[8].endswith("mod.py:3: ValueError")
+
+    def test_toterminal_long_filenames(self, importasmod):
+        mod = importasmod("""
+            def f():
+                raise ValueError()
+        """)
+        excinfo = pytest.raises(ValueError, mod.f)
+        tw = TWMock()
+        path = py.path.local(mod.__file__)
+        old = path.dirpath().chdir()
+        try:
+            repr = excinfo.getrepr(abspath=False)
+            repr.toterminal(tw)
+            line = tw.lines[-1]
+            x = py.path.local().bestrelpath(path)
+            if len(x) < len(str(path)):
+                assert line == "mod.py:3: ValueError"
+
+            repr = excinfo.getrepr(abspath=True)
+            repr.toterminal(tw)
+            line = tw.lines[-1]
+            assert line == "%s:3: ValueError" %(path,)
+        finally:
+            old.chdir()
+
+    @pytest.mark.parametrize('reproptions', [
+        {'style': style, 'showlocals': showlocals,
+         'funcargs': funcargs, 'tbfilter': tbfilter
+        } for style in ("long", "short", "no")
+            for showlocals in (True, False)
+                for tbfilter in (True, False)
+                    for funcargs in (True, False)])
+    def test_format_excinfo(self, importasmod, reproptions):
+        mod = importasmod("""
+            def g(x):
+                raise ValueError(x)
+            def f():
+                g(3)
+        """)
+        excinfo = pytest.raises(ValueError, mod.f)
+        tw = py.io.TerminalWriter(stringio=True)
+        repr = excinfo.getrepr(**reproptions)
+        repr.toterminal(tw)
+        assert tw.stringio.getvalue()
+
+
+    def test_native_style(self):
+        excinfo = self.excinfo_from_exec("""
+            assert 0
+        """)
+        repr = excinfo.getrepr(style='native')
+        assert "assert 0" in str(repr.reprcrash)
+        s = str(repr)
+        assert s.startswith('Traceback (most recent call last):\n  File')
+        assert s.endswith('\nAssertionError: assert 0')
+        assert 'exec (source.compile())' in s
+        # python 2.4 fails to get the source line for the assert
+        if py.std.sys.version_info >= (2, 5):
+            assert s.count('assert 0') == 2
+
+    def test_traceback_repr_style(self, importasmod):
+        mod = importasmod("""
+            def f():
+                g()
+            def g():
+                h()
+            def h():
+                i()
+            def i():
+                raise ValueError()
+        """)
+        excinfo = pytest.raises(ValueError, mod.f)
+        excinfo.traceback = excinfo.traceback.filter()
+        excinfo.traceback[1].set_repr_style("short")
+        excinfo.traceback[2].set_repr_style("short")
+        r = excinfo.getrepr(style="long")
+        tw = TWMock()
+        r.toterminal(tw)
+        for line in tw.lines: print (line)
+        assert tw.lines[0] == ""
+        assert tw.lines[1] == "    def f():"
+        assert tw.lines[2] == ">       g()"
+        assert tw.lines[3] == ""
+        assert tw.lines[4].endswith("mod.py:3: ")
+        assert tw.lines[5] == ("_ ", None)
+        assert tw.lines[6].endswith("in g")
+        assert tw.lines[7] == "    h()"
+        assert tw.lines[8].endswith("in h")
+        assert tw.lines[9] == "    i()"
+        assert tw.lines[10] == ("_ ", None)
+        assert tw.lines[11] == ""
+        assert tw.lines[12] == "    def i():"
+        assert tw.lines[13] == ">       raise ValueError()"
+        assert tw.lines[14] == "E       ValueError"
+        assert tw.lines[15] == ""
+        assert tw.lines[16].endswith("mod.py:9: ValueError")

testing/code/test_source.py

@@ -0,0 +1,659 @@
+# flake8: noqa
+# disable flake check on this file because some constructs are strange
+# or redundant on purpose and can't be disable on a line-by-line basis
+import sys
+
+import _pytest._code
+import py
+import pytest
+from _pytest._code import Source
+from _pytest._code.source import _ast
+
+if _ast is not None:
+    astonly = pytest.mark.nothing
+else:
+    astonly = pytest.mark.xfail("True", reason="only works with AST-compile")
+
+failsonjython = pytest.mark.xfail("sys.platform.startswith('java')")
+
+def test_source_str_function():
+    x = Source("3")
+    assert str(x) == "3"
+
+    x = Source("   3")
+    assert str(x) == "3"
+
+    x = Source("""
+        3
+    """, rstrip=False)
+    assert str(x) == "\n3\n    "
+
+    x = Source("""
+        3
+    """, rstrip=True)
+    assert str(x) == "\n3"
+
+def test_unicode():
+    try:
+        unicode
+    except NameError:
+        return
+    x = Source(unicode("4"))
+    assert str(x) == "4"
+    co = _pytest._code.compile(unicode('u"\xc3\xa5"', 'utf8'), mode='eval')
+    val = eval(co)
+    assert isinstance(val, unicode)
+
+def test_source_from_function():
+    source = _pytest._code.Source(test_source_str_function)
+    assert str(source).startswith('def test_source_str_function():')
+
+def test_source_from_method():
+    class TestClass:
+        def test_method(self):
+            pass
+    source = _pytest._code.Source(TestClass().test_method)
+    assert source.lines == ["def test_method(self):",
+                            "    pass"]
+
+def test_source_from_lines():
+    lines = ["a \n", "b\n", "c"]
+    source = _pytest._code.Source(lines)
+    assert source.lines == ['a ', 'b', 'c']
+
+def test_source_from_inner_function():
+    def f():
+        pass
+    source = _pytest._code.Source(f, deindent=False)
+    assert str(source).startswith('    def f():')
+    source = _pytest._code.Source(f)
+    assert str(source).startswith('def f():')
+
+def test_source_putaround_simple():
+    source = Source("raise ValueError")
+    source = source.putaround(
+        "try:", """\
+        except ValueError:
+            x = 42
+        else:
+            x = 23""")
+    assert str(source)=="""\
+try:
+    raise ValueError
+except ValueError:
+    x = 42
+else:
+    x = 23"""
+
+def test_source_putaround():
+    source = Source()
+    source = source.putaround("""
+        if 1:
+            x=1
+    """)
+    assert str(source).strip() == "if 1:\n    x=1"
+
+def test_source_strips():
+    source = Source("")
+    assert source == Source()
+    assert str(source) == ''
+    assert source.strip() == source
+
+def test_source_strip_multiline():
+    source = Source()
+    source.lines = ["", " hello", "  "]
+    source2 = source.strip()
+    assert source2.lines == [" hello"]
+
+def test_syntaxerror_rerepresentation():
+    ex = pytest.raises(SyntaxError, _pytest._code.compile, 'xyz xyz')
+    assert ex.value.lineno == 1
+    assert ex.value.offset in (4,7) # XXX pypy/jython versus cpython?
+    assert ex.value.text.strip(), 'x x'
+
+def test_isparseable():
+    assert Source("hello").isparseable()
+    assert Source("if 1:\n  pass").isparseable()
+    assert Source(" \nif 1:\n  pass").isparseable()
+    assert not Source("if 1:\n").isparseable()
+    assert not Source(" \nif 1:\npass").isparseable()
+    assert not Source(chr(0)).isparseable()
+
+class TestAccesses:
+    source = Source("""\
+        def f(x):
+            pass
+        def g(x):
+            pass
+    """)
+    def test_getrange(self):
+        x = self.source[0:2]
+        assert x.isparseable()
+        assert len(x.lines) == 2
+        assert str(x) == "def f(x):\n    pass"
+
+    def test_getline(self):
+        x = self.source[0]
+        assert x == "def f(x):"
+
+    def test_len(self):
+        assert len(self.source) == 4
+
+    def test_iter(self):
+        l = [x for x in self.source]
+        assert len(l) == 4
+
+class TestSourceParsingAndCompiling:
+    source = Source("""\
+        def f(x):
+            assert (x ==
+                    3 +
+                    4)
+    """).strip()
+
+    def test_compile(self):
+        co = _pytest._code.compile("x=3")
+        d = {}
+        exec (co, d)
+        assert d['x'] == 3
+
+    def test_compile_and_getsource_simple(self):
+        co = _pytest._code.compile("x=3")
+        exec (co)
+        source = _pytest._code.Source(co)
+        assert str(source) == "x=3"
+
+    def test_compile_and_getsource_through_same_function(self):
+        def gensource(source):
+            return _pytest._code.compile(source)
+        co1 = gensource("""
+            def f():
+                raise KeyError()
+        """)
+        co2 = gensource("""
+            def f():
+                raise ValueError()
+        """)
+        source1 = py.std.inspect.getsource(co1)
+        assert 'KeyError' in source1
+        source2 = py.std.inspect.getsource(co2)
+        assert 'ValueError' in source2
+
+    def test_getstatement(self):
+        #print str(self.source)
+        ass = str(self.source[1:])
+        for i in range(1, 4):
+            #print "trying start in line %r" % self.source[i]
+            s = self.source.getstatement(i)
+            #x = s.deindent()
+            assert str(s) == ass
+
+    def test_getstatementrange_triple_quoted(self):
+        #print str(self.source)
+        source = Source("""hello('''
+        ''')""")
+        s = source.getstatement(0)
+        assert s == str(source)
+        s = source.getstatement(1)
+        assert s == str(source)
+
+    @astonly
+    def test_getstatementrange_within_constructs(self):
+        source = Source("""\
+            try:
+                try:
+                    raise ValueError
+                except SomeThing:
+                    pass
+            finally:
+                42
+        """)
+        assert len(source) == 7
+        # check all lineno's that could occur in a traceback
+        #assert source.getstatementrange(0) == (0, 7)
+        #assert source.getstatementrange(1) == (1, 5)
+        assert source.getstatementrange(2) == (2, 3)
+        assert source.getstatementrange(3) == (3, 4)
+        assert source.getstatementrange(4) == (4, 5)
+        #assert source.getstatementrange(5) == (0, 7)
+        assert source.getstatementrange(6) == (6, 7)
+
+    def test_getstatementrange_bug(self):
+        source = Source("""\
+            try:
+                x = (
+                   y +
+                   z)
+            except:
+                pass
+        """)
+        assert len(source) == 6
+        assert source.getstatementrange(2) == (1, 4)
+
+    def test_getstatementrange_bug2(self):
+        source = Source("""\
+            assert (
+                33
+                ==
+                [
+                  X(3,
+                      b=1, c=2
+                   ),
+                ]
+              )
+        """)
+        assert len(source) == 9
+        assert source.getstatementrange(5) == (0, 9)
+
+    def test_getstatementrange_ast_issue58(self):
+        source = Source("""\
+
+            def test_some():
+                for a in [a for a in
+                    CAUSE_ERROR]: pass
+
+            x = 3
+        """)
+        assert getstatement(2, source).lines == source.lines[2:3]
+        assert getstatement(3, source).lines == source.lines[3:4]
+
+    @pytest.mark.skipif("sys.version_info < (2,6)")
+    def test_getstatementrange_out_of_bounds_py3(self):
+        source = Source("if xxx:\n   from .collections import something")
+        r = source.getstatementrange(1)
+        assert r == (1,2)
+
+    def test_getstatementrange_with_syntaxerror_issue7(self):
+        source = Source(":")
+        pytest.raises(SyntaxError, lambda: source.getstatementrange(0))
+
+    @pytest.mark.skipif("sys.version_info < (2,6)")
+    def test_compile_to_ast(self):
+        import ast
+        source = Source("x = 4")
+        mod = source.compile(flag=ast.PyCF_ONLY_AST)
+        assert isinstance(mod, ast.Module)
+        compile(mod, "<filename>", "exec")
+
+    def test_compile_and_getsource(self):
+        co = self.source.compile()
+        py.builtin.exec_(co, globals())
+        f(7)
+        excinfo = pytest.raises(AssertionError, "f(6)")
+        frame = excinfo.traceback[-1].frame
+        stmt = frame.code.fullsource.getstatement(frame.lineno)
+        #print "block", str(block)
+        assert str(stmt).strip().startswith('assert')
+
+    def test_compilefuncs_and_path_sanity(self):
+        def check(comp, name):
+            co = comp(self.source, name)
+            if not name:
+                expected = "codegen %s:%d>" %(mypath, mylineno+2+1)
+            else:
+                expected = "codegen %r %s:%d>" % (name, mypath, mylineno+2+1)
+            fn = co.co_filename
+            assert fn.endswith(expected)
+
+        mycode = _pytest._code.Code(self.test_compilefuncs_and_path_sanity)
+        mylineno = mycode.firstlineno
+        mypath = mycode.path
+
+        for comp in _pytest._code.compile, _pytest._code.Source.compile:
+            for name in '', None, 'my':
+                yield check, comp, name
+
+    def test_offsetless_synerr(self):
+        pytest.raises(SyntaxError, _pytest._code.compile, "lambda a,a: 0", mode='eval')
+
+def test_getstartingblock_singleline():
+    class A:
+        def __init__(self, *args):
+            frame = sys._getframe(1)
+            self.source = _pytest._code.Frame(frame).statement
+
+    x = A('x', 'y')
+
+    l = [i for i in x.source.lines if i.strip()]
+    assert len(l) == 1
+
+def test_getstartingblock_multiline():
+    class A:
+        def __init__(self, *args):
+            frame = sys._getframe(1)
+            self.source = _pytest._code.Frame(frame).statement
+
+    x = A('x',
+          'y' \
+          ,
+          'z')
+
+    l = [i for i in x.source.lines if i.strip()]
+    assert len(l) == 4
+
+def test_getline_finally():
+    def c(): pass
+    excinfo = pytest.raises(TypeError, """
+           teardown = None
+           try:
+                c(1)
+           finally:
+                if teardown:
+                    teardown()
+    """)
+    source = excinfo.traceback[-1].statement
+    assert str(source).strip() == 'c(1)'
+
+def test_getfuncsource_dynamic():
+    source = """
+        def f():
+            raise ValueError
+
+        def g(): pass
+    """
+    co = _pytest._code.compile(source)
+    py.builtin.exec_(co, globals())
+    assert str(_pytest._code.Source(f)).strip() == 'def f():\n    raise ValueError'
+    assert str(_pytest._code.Source(g)).strip() == 'def g(): pass'
+
+
+def test_getfuncsource_with_multine_string():
+    def f():
+        c = '''while True:
+    pass
+'''
+    assert str(_pytest._code.Source(f)).strip() == "def f():\n    c = '''while True:\n    pass\n'''"
+
+
+def test_deindent():
+    from _pytest._code.source import deindent as deindent
+    assert deindent(['\tfoo', '\tbar', ]) == ['foo', 'bar']
+
+    def f():
+        c = '''while True:
+    pass
+'''
+    import inspect
+    lines = deindent(inspect.getsource(f).splitlines())
+    assert lines == ["def f():", "    c = '''while True:", "    pass", "'''"]
+
+    source = """
+        def f():
+            def g():
+                pass
+    """
+    lines = deindent(source.splitlines())
+    assert lines == ['', 'def f():', '    def g():', '        pass', '    ']
+
+@pytest.mark.xfail("sys.version_info[:3] < (2,7,0) or "
+    "((3,0) <= sys.version_info[:2] < (3,2))")
+def test_source_of_class_at_eof_without_newline(tmpdir):
+    # this test fails because the implicit inspect.getsource(A) below
+    # does not return the "x = 1" last line.
+    source = _pytest._code.Source('''
+        class A(object):
+            def method(self):
+                x = 1
+    ''')
+    path = tmpdir.join("a.py")
+    path.write(source)
+    s2 = _pytest._code.Source(tmpdir.join("a.py").pyimport().A)
+    assert str(source).strip() == str(s2).strip()
+
+if True:
+    def x():
+        pass
+
+def test_getsource_fallback():
+    from _pytest._code.source import getsource
+    expected = """def x():
+    pass"""
+    src = getsource(x)
+    assert src == expected
+
+def test_idem_compile_and_getsource():
+    from _pytest._code.source import getsource
+    expected = "def x(): pass"
+    co = _pytest._code.compile(expected)
+    src = getsource(co)
+    assert src == expected
+
+def test_findsource_fallback():
+    from _pytest._code.source import findsource
+    src, lineno = findsource(x)
+    assert 'test_findsource_simple' in str(src)
+    assert src[lineno] == '    def x():'
+
+def test_findsource():
+    from _pytest._code.source import findsource
+    co = _pytest._code.compile("""if 1:
+    def x():
+        pass
+""")
+
+    src, lineno = findsource(co)
+    assert 'if 1:' in str(src)
+
+    d = {}
+    eval(co, d)
+    src, lineno = findsource(d['x'])
+    assert 'if 1:' in str(src)
+    assert src[lineno] == "    def x():"
+
+
+def test_getfslineno():
+    from _pytest._code import getfslineno
+
+    def f(x):
+        pass
+
+    fspath, lineno = getfslineno(f)
+
+    assert fspath.basename == "test_source.py"
+    assert lineno == _pytest._code.getrawcode(f).co_firstlineno - 1 # see findsource
+
+    class A(object):
+        pass
+
+    fspath, lineno = getfslineno(A)
+
+    _, A_lineno = py.std.inspect.findsource(A)
+    assert fspath.basename == "test_source.py"
+    assert lineno == A_lineno
+
+    assert getfslineno(3) == ("", -1)
+    class B:
+        pass
+    B.__name__ = "B2"
+    assert getfslineno(B)[1] == -1
+
+def test_code_of_object_instance_with_call():
+    class A:
+        pass
+    pytest.raises(TypeError, lambda: _pytest._code.Source(A()))
+    class WithCall:
+        def __call__(self):
+            pass
+
+    code = _pytest._code.Code(WithCall())
+    assert 'pass' in str(code.source())
+
+    class Hello(object):
+        def __call__(self):
+            pass
+    pytest.raises(TypeError, lambda: _pytest._code.Code(Hello))
+
+
+def getstatement(lineno, source):
+    from _pytest._code.source import getstatementrange_ast
+    source = _pytest._code.Source(source, deindent=False)
+    ast, start, end = getstatementrange_ast(lineno, source)
+    return source[start:end]
+
+def test_oneline():
+    source = getstatement(0, "raise ValueError")
+    assert str(source) == "raise ValueError"
+
+def test_comment_and_no_newline_at_end():
+    from _pytest._code.source import getstatementrange_ast
+    source = Source(['def test_basic_complex():',
+                     '    assert 1 == 2',
+                     '# vim: filetype=pyopencl:fdm=marker'])
+    ast, start, end = getstatementrange_ast(1, source)
+    assert end == 2
+
+def test_oneline_and_comment():
+    source = getstatement(0, "raise ValueError\n#hello")
+    assert str(source) == "raise ValueError"
+
+@pytest.mark.xfail(hasattr(sys, "pypy_version_info"),
+                   reason='does not work on pypy')
+def test_comments():
+    source = '''def test():
+    "comment 1"
+    x = 1
+      # comment 2
+    # comment 3
+
+    assert False
+
+"""
+comment 4
+"""
+'''
+    for line in range(2,6):
+        assert str(getstatement(line, source)) == '    x = 1'
+    for line in range(6,10):
+        assert str(getstatement(line, source)) == '    assert False'
+    assert str(getstatement(10, source)) == '"""'
+
+def test_comment_in_statement():
+    source = '''test(foo=1,
+    # comment 1
+    bar=2)
+'''
+    for line in range(1,3):
+        assert str(getstatement(line, source)) == \
+               'test(foo=1,\n    # comment 1\n    bar=2)'
+
+def test_single_line_else():
+    source = getstatement(1, "if False: 2\nelse: 3")
+    assert str(source) == "else: 3"
+
+def test_single_line_finally():
+    source = getstatement(1, "try: 1\nfinally: 3")
+    assert str(source) == "finally: 3"
+
+def test_issue55():
+    source = ('def round_trip(dinp):\n  assert 1 == dinp\n'
+              'def test_rt():\n  round_trip("""\n""")\n')
+    s = getstatement(3, source)
+    assert str(s) == '  round_trip("""\n""")'
+
+
+def XXXtest_multiline():
+    source = getstatement(0, """\
+raise ValueError(
+    23
+)
+x = 3
+""")
+    assert str(source) == "raise ValueError(\n    23\n)"
+
+class TestTry:
+    pytestmark = astonly
+    source = """\
+try:
+    raise ValueError
+except Something:
+    raise IndexError(1)
+else:
+    raise KeyError()
+"""
+
+    def test_body(self):
+        source = getstatement(1, self.source)
+        assert str(source) == "    raise ValueError"
+
+    def test_except_line(self):
+        source = getstatement(2, self.source)
+        assert str(source) == "except Something:"
+
+    def test_except_body(self):
+        source = getstatement(3, self.source)
+        assert str(source) == "    raise IndexError(1)"
+
+    def test_else(self):
+        source = getstatement(5, self.source)
+        assert str(source) == "    raise KeyError()"
+
+class TestTryFinally:
+    source = """\
+try:
+    raise ValueError
+finally:
+    raise IndexError(1)
+"""
+
+    def test_body(self):
+        source = getstatement(1, self.source)
+        assert str(source) == "    raise ValueError"
+
+    def test_finally(self):
+        source = getstatement(3, self.source)
+        assert str(source) == "    raise IndexError(1)"
+
+
+
+class TestIf:
+    pytestmark = astonly
+    source = """\
+if 1:
+    y = 3
+elif False:
+    y = 5
+else:
+    y = 7
+"""
+
+    def test_body(self):
+        source = getstatement(1, self.source)
+        assert str(source) == "    y = 3"
+
+    def test_elif_clause(self):
+        source = getstatement(2, self.source)
+        assert str(source) == "elif False:"
+
+    def test_elif(self):
+        source = getstatement(3, self.source)
+        assert str(source) == "    y = 5"
+
+    def test_else(self):
+        source = getstatement(5, self.source)
+        assert str(source) == "    y = 7"
+
+def test_semicolon():
+    s = """\
+hello ; pytest.skip()
+"""
+    source = getstatement(0, s)
+    assert str(source) == s.strip()
+
+def test_def_online():
+    s = """\
+def func(): raise ValueError(42)
+
+def something():
+    pass
+"""
+    source = getstatement(0, s)
+    assert str(source) == "def func(): raise ValueError(42)"
+
+def XXX_test_expression_multiline():
+    source = """\
+something
+'''
+'''"""
+    result = getstatement(1, source)
+    assert str(result) == "'''\n'''"
+

testing/python/collect.py

@@ -1,6 +1,10 @@
+# -*- coding: utf-8 -*-
 import sys
 from textwrap import dedent
-import pytest, py
+
+import _pytest._code
+import py
+import pytest
 from _pytest.main import EXIT_NOTESTSCOLLECTED
 
 
@@ -494,6 +498,7 @@ class TestFunction:
                 return True
         config.pluginmanager.register(MyPlugin1())
         config.pluginmanager.register(MyPlugin2())
+        config.hook.pytest_runtest_setup(item=item)
         config.hook.pytest_pyfunc_call(pyfuncitem=item)
 
     def test_multiple_parametrize(self, testdir):
@@ -527,6 +532,84 @@ class TestFunction:
         assert colitems[2].name == 'test2[a-c]'
         assert colitems[3].name == 'test2[b-c]'
 
+    def test_parametrize_skipif(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+
+            m = pytest.mark.skipif('True')
+
+            @pytest.mark.parametrize('x', [0, 1, m(2)])
+            def test_skip_if(x):
+                assert x < 2
+        """)
+        result = testdir.runpytest()
+        result.stdout.fnmatch_lines('* 2 passed, 1 skipped in *')
+
+    def test_parametrize_skip(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+
+            m = pytest.mark.skip('')
+
+            @pytest.mark.parametrize('x', [0, 1, m(2)])
+            def test_skip(x):
+                assert x < 2
+        """)
+        result = testdir.runpytest()
+        result.stdout.fnmatch_lines('* 2 passed, 1 skipped in *')
+
+    def test_parametrize_skipif_no_skip(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+
+            m = pytest.mark.skipif('False')
+
+            @pytest.mark.parametrize('x', [0, 1, m(2)])
+            def test_skipif_no_skip(x):
+                assert x < 2
+        """)
+        result = testdir.runpytest()
+        result.stdout.fnmatch_lines('* 1 failed, 2 passed in *')
+
+    def test_parametrize_xfail(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+
+            m = pytest.mark.xfail('True')
+
+            @pytest.mark.parametrize('x', [0, 1, m(2)])
+            def test_xfail(x):
+                assert x < 2
+        """)
+        result = testdir.runpytest()
+        result.stdout.fnmatch_lines('* 2 passed, 1 xfailed in *')
+
+    def test_parametrize_passed(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+
+            m = pytest.mark.xfail('True')
+
+            @pytest.mark.parametrize('x', [0, 1, m(2)])
+            def test_xfail(x):
+                pass
+        """)
+        result = testdir.runpytest()
+        result.stdout.fnmatch_lines('* 2 passed, 1 xpassed in *')
+
+    def test_parametrize_xfail_passed(self, testdir):
+        testdir.makepyfile("""
+            import pytest
+
+            m = pytest.mark.xfail('False')
+
+            @pytest.mark.parametrize('x', [0, 1, m(2)])
+            def test_passed(x):
+                pass
+        """)
+        result = testdir.runpytest()
+        result.stdout.fnmatch_lines('* 3 passed in *')
+
 
 class TestSorting:
     def test_check_equality(self, testdir):
@@ -598,13 +681,13 @@ class TestConftestCustomization:
 
     def test_customized_pymakemodule_issue205_subdir(self, testdir):
         b = testdir.mkdir("a").mkdir("b")
-        b.join("conftest.py").write(py.code.Source("""
+        b.join("conftest.py").write(_pytest._code.Source("""
             def pytest_pycollect_makemodule(__multicall__):
                 mod = __multicall__.execute()
                 mod.obj.hello = "world"
                 return mod
         """))
-        b.join("test_module.py").write(py.code.Source("""
+        b.join("test_module.py").write(_pytest._code.Source("""
             def test_hello():
                 assert hello == "world"
         """))
@@ -613,7 +696,7 @@ class TestConftestCustomization:
 
     def test_customized_pymakeitem(self, testdir):
         b = testdir.mkdir("a").mkdir("b")
-        b.join("conftest.py").write(py.code.Source("""
+        b.join("conftest.py").write(_pytest._code.Source("""
             import pytest
             @pytest.hookimpl(hookwrapper=True)
             def pytest_pycollect_makeitem():
@@ -624,7 +707,7 @@ class TestConftestCustomization:
                         for func in result:
                             func._some123 = "world"
         """))
-        b.join("test_module.py").write(py.code.Source("""
+        b.join("test_module.py").write(_pytest._code.Source("""
             import pytest
 
             @pytest.fixture()
@@ -662,7 +745,7 @@ class TestConftestCustomization:
 def test_setup_only_available_in_subdir(testdir):
     sub1 = testdir.mkpydir("sub1")
     sub2 = testdir.mkpydir("sub2")
-    sub1.join("conftest.py").write(py.code.Source("""
+    sub1.join("conftest.py").write(_pytest._code.Source("""
         import pytest
         def pytest_runtest_setup(item):
             assert item.fspath.purebasename == "test_in_sub1"
@@ -671,7 +754,7 @@ def test_setup_only_available_in_subdir(testdir):
         def pytest_runtest_teardown(item):
             assert item.fspath.purebasename == "test_in_sub1"
     """))
-    sub2.join("conftest.py").write(py.code.Source("""
+    sub2.join("conftest.py").write(_pytest._code.Source("""
         import pytest
         def pytest_runtest_setup(item):
             assert item.fspath.purebasename == "test_in_sub2"
@@ -787,7 +870,7 @@ class TestTracebackCutting:
         except ValueError:
             _, _, tb = sys.exc_info()
 
-        tb = py.code.Traceback(tb)
+        tb = _pytest._code.Traceback(tb)
         assert isinstance(tb[-1].path, str)
         assert not filter_traceback(tb[-1])
 
@@ -810,7 +893,7 @@ class TestTracebackCutting:
             _, _, tb = sys.exc_info()
 
         testdir.tmpdir.join('filter_traceback_entry_as_str.py').remove()
-        tb = py.code.Traceback(tb)
+        tb = _pytest._code.Traceback(tb)
         assert isinstance(tb[-1].path, str)
         assert filter_traceback(tb[-1])
 
@@ -1099,3 +1182,19 @@ def test_class_injection_does_not_break_collection(testdir):
     result = testdir.runpytest()
     assert "RuntimeError: dictionary changed size during iteration" not in result.stdout.str()
     result.stdout.fnmatch_lines(['*1 passed*'])
+
+
+def test_syntax_error_with_non_ascii_chars(testdir):
+    """Fix decoding issue while formatting SyntaxErrors during collection (#578)
+    """
+    testdir.makepyfile(u"""
+    # -*- coding: UTF-8 -*-
+
+    ☃
+    """)
+    result = testdir.runpytest()
+    result.stdout.fnmatch_lines([
+        '*ERROR collecting*',
+        '*SyntaxError*',
+        '*1 error in*',
+    ])

testing/python/fixture.py

@@ -1,9 +1,13 @@
-import pytest, py, sys
-from _pytest import python as funcargs
-from _pytest.python import FixtureLookupError
-from _pytest.pytester import get_public_names
 from textwrap import dedent
 
+import _pytest._code
+import pytest
+import sys
+from _pytest import python as funcargs
+from _pytest.pytester import get_public_names
+from _pytest.python import FixtureLookupError
+
+
 def test_getfuncargnames():
     def f(): pass
     assert not funcargs.getfuncargnames(f)
@@ -86,12 +90,12 @@ class TestFillFixtures:
     def test_conftest_funcargs_only_available_in_subdir(self, testdir):
         sub1 = testdir.mkpydir("sub1")
         sub2 = testdir.mkpydir("sub2")
-        sub1.join("conftest.py").write(py.code.Source("""
+        sub1.join("conftest.py").write(_pytest._code.Source("""
             import pytest
             def pytest_funcarg__arg1(request):
                 pytest.raises(Exception, "request.getfuncargvalue('arg2')")
         """))
-        sub2.join("conftest.py").write(py.code.Source("""
+        sub2.join("conftest.py").write(_pytest._code.Source("""
             import pytest
             def pytest_funcarg__arg2(request):
                 pytest.raises(Exception, "request.getfuncargvalue('arg1')")
@@ -156,7 +160,7 @@ class TestFillFixtures:
                 return 'spam'
         """)
         pkg = testdir.mkpydir("pkg")
-        pkg.join("conftest.py").write(py.code.Source("""
+        pkg.join("conftest.py").write(_pytest._code.Source("""
             import pytest
 
             @pytest.fixture
@@ -164,7 +168,7 @@ class TestFillFixtures:
                 return spam * 2
         """))
         testfile = pkg.join("test_spam.py")
-        testfile.write(py.code.Source("""
+        testfile.write(_pytest._code.Source("""
             def test_spam(spam):
                 assert spam == "spamspam"
         """))
@@ -258,7 +262,7 @@ class TestFillFixtures:
                 return request.param
         """)
         subdir = testdir.mkpydir('subdir')
-        subdir.join("conftest.py").write(py.code.Source("""
+        subdir.join("conftest.py").write(_pytest._code.Source("""
             import pytest
 
             @pytest.fixture
@@ -266,7 +270,7 @@ class TestFillFixtures:
                 return 'spam'
         """))
         testfile = subdir.join("test_spam.py")
-        testfile.write(py.code.Source("""
+        testfile.write(_pytest._code.Source("""
             def test_spam(spam):
                 assert spam == "spam"
         """))
@@ -312,7 +316,7 @@ class TestFillFixtures:
                 return 'spam'
         """)
         subdir = testdir.mkpydir('subdir')
-        subdir.join("conftest.py").write(py.code.Source("""
+        subdir.join("conftest.py").write(_pytest._code.Source("""
             import pytest
 
             @pytest.fixture(params=[1, 2, 3])
@@ -320,7 +324,7 @@ class TestFillFixtures:
                 return request.param
         """))
         testfile = subdir.join("test_spam.py")
-        testfile.write(py.code.Source("""
+        testfile.write(_pytest._code.Source("""
             params = {'spam': 1}
 
             def test_spam(spam):
@@ -609,7 +613,7 @@ class TestRequestBasic:
     def test_fixtures_sub_subdir_normalize_sep(self, testdir):
         # this tests that normalization of nodeids takes place
         b = testdir.mkdir("tests").mkdir("unit")
-        b.join("conftest.py").write(py.code.Source("""
+        b.join("conftest.py").write(_pytest._code.Source("""
             def pytest_funcarg__arg1():
                 pass
         """))
@@ -1349,7 +1353,7 @@ class TestAutouseDiscovery:
 class TestAutouseManagement:
     def test_autouse_conftest_mid_directory(self, testdir):
         pkgdir = testdir.mkpydir("xyz123")
-        pkgdir.join("conftest.py").write(py.code.Source("""
+        pkgdir.join("conftest.py").write(_pytest._code.Source("""
             import pytest
             @pytest.fixture(autouse=True)
             def app():
@@ -1357,7 +1361,7 @@ class TestAutouseManagement:
                 sys._myapp = "hello"
         """))
         t = pkgdir.ensure("tests", "test_app.py")
-        t.write(py.code.Source("""
+        t.write(_pytest._code.Source("""
             import sys
             def test_app():
                 assert sys._myapp == "hello"

testing/python/integration.py

@@ -1,6 +1,7 @@
 import pytest
-from _pytest import runner
 from _pytest import python
+from _pytest import runner
+
 
 class TestOEJSKITSpecials:
     def test_funcarg_non_pycollectobj(self, testdir): # rough jstests usage

testing/python/metafunc.py

@@ -1,7 +1,9 @@
 # -*- coding: utf-8 -*-
 import re
 
-import pytest, py
+import _pytest._code
+import py
+import pytest
 from _pytest import python as funcargs
 
 class TestMetafunc:
@@ -168,6 +170,11 @@ class TestMetafunc:
         result = idmaker((py.builtin._totext("a"), "b"), [({}, b'\xc3\xb4')])
         assert result == ['a0-\\xc3\\xb4']
 
+    def test_idmaker_with_bytes_regex(self):
+        from _pytest.python import idmaker
+        result = idmaker(("a"), [(re.compile(b'foo'), 1.0)])
+        assert result == ["foo"]
+
     def test_idmaker_native_strings(self):
         from _pytest.python import idmaker
         totext = py.builtin._totext
@@ -838,11 +845,11 @@ class TestMetafuncFunctional:
     def test_generate_tests_only_done_in_subdir(self, testdir):
         sub1 = testdir.mkpydir("sub1")
         sub2 = testdir.mkpydir("sub2")
-        sub1.join("conftest.py").write(py.code.Source("""
+        sub1.join("conftest.py").write(_pytest._code.Source("""
             def pytest_generate_tests(metafunc):
                 assert metafunc.function.__name__ == "test_1"
         """))
-        sub2.join("conftest.py").write(py.code.Source("""
+        sub2.join("conftest.py").write(_pytest._code.Source("""
             def pytest_generate_tests(metafunc):
                 assert metafunc.function.__name__ == "test_2"
         """))

testing/python/raises.py

@@ -38,10 +38,11 @@ class TestRaises:
         testdir.makepyfile("""
             from __future__ import with_statement
             import py, pytest
+            import _pytest._code
 
             def test_simple():
                 with pytest.raises(ZeroDivisionError) as excinfo:
-                    assert isinstance(excinfo, py.code.ExceptionInfo)
+                    assert isinstance(excinfo, _pytest._code.ExceptionInfo)
                     1/0
                 print (excinfo)
                 assert excinfo.type == ZeroDivisionError
@@ -69,3 +70,9 @@ class TestRaises:
     def test_tuple(self):
         with pytest.raises((KeyError, ValueError)):
             raise KeyError('oops')
+
+    def test_no_raise_message(self):
+        try:
+            pytest.raises(ValueError, int, '0')
+        except pytest.raises.Exception as e:
+            assert e.msg == "DID NOT RAISE {0}".format(repr(ValueError))

testing/test_argcomplete.py

@@ -69,11 +69,8 @@ class FilesCompleter(object):
                 completion += [f + '/' for f in anticomp]
         return completion
 
-# the following barfs with a syntax error on py2.5
-# @pytest.mark.skipif("sys.version_info < (2,6)")
 class TestArgComplete:
     @pytest.mark.skipif("sys.platform in ('win32', 'darwin')")
-    @pytest.mark.skipif("sys.version_info < (2,6)")
     def test_compare_with_compgen(self):
         from _pytest._argcomplete import FastFilesCompleter
         ffc = FastFilesCompleter()
@@ -82,7 +79,6 @@ class TestArgComplete:
             assert equal_with_bash(x, ffc, fc, out=py.std.sys.stdout)
 
     @pytest.mark.skipif("sys.platform in ('win32', 'darwin')")
-    @pytest.mark.skipif("sys.version_info < (2,6)")
     def test_remove_dir_prefix(self):
         """this is not compatible with compgen but it is with bash itself:
         ls /usr/<TAB>

testing/test_assertinterpret.py

@@ -1,8 +1,9 @@
 "PYTEST_DONT_REWRITE"
-import pytest, py
-
+import py
+import pytest
 from _pytest.assertion import util
 
+
 def exvalue():
     return py.std.sys.exc_info()[1]
 
@@ -79,7 +80,6 @@ def test_is():
         assert s.startswith("assert 1 is 2")
 
 
-@pytest.mark.skipif("sys.version_info < (2,6)")
 def test_attrib():
     class Foo(object):
         b = 1
@@ -91,7 +91,6 @@ def test_attrib():
         s = str(e)
         assert s.startswith("assert 1 == 2")
 
-@pytest.mark.skipif("sys.version_info < (2,6)")
 def test_attrib_inst():
     class Foo(object):
         b = 1
@@ -197,66 +196,6 @@ def test_power():
         assert "assert (2 ** 3) == 7" in e.msg
 
 
-class TestView:
-
-    def setup_class(cls):
-        cls.View = pytest.importorskip("_pytest.assertion.oldinterpret").View
-
-    def test_class_dispatch(self):
-        # Use a custom class hierarchy with existing instances
-
-        class Picklable(self.View):
-            pass
-
-        class Simple(Picklable):
-            __view__ = object
-            def pickle(self):
-                return repr(self.__obj__)
-
-        class Seq(Picklable):
-            __view__ = list, tuple, dict
-            def pickle(self):
-                return ';'.join(
-                    [Picklable(item).pickle() for item in self.__obj__])
-
-        class Dict(Seq):
-            __view__ = dict
-            def pickle(self):
-                return Seq.pickle(self) + '!' + Seq(self.values()).pickle()
-
-        assert Picklable(123).pickle() == '123'
-        assert Picklable([1,[2,3],4]).pickle() == '1;2;3;4'
-        assert Picklable({1:2}).pickle() == '1!2'
-
-    def test_viewtype_class_hierarchy(self):
-        # Use a custom class hierarchy based on attributes of existing instances
-        class Operation:
-            "Existing class that I don't want to change."
-            def __init__(self, opname, *args):
-                self.opname = opname
-                self.args = args
-
-        existing = [Operation('+', 4, 5),
-                    Operation('getitem', '', 'join'),
-                    Operation('setattr', 'x', 'y', 3),
-                    Operation('-', 12, 1)]
-
-        class PyOp(self.View):
-            def __viewkey__(self):
-                return self.opname
-            def generate(self):
-                return '%s(%s)' % (self.opname, ', '.join(map(repr, self.args)))
-
-        class PyBinaryOp(PyOp):
-            __view__ = ('+', '-', '*', '/')
-            def generate(self):
-                return '%s %s %s' % (self.args[0], self.opname, self.args[1])
-
-        codelines = [PyOp(op).generate() for op in existing]
-        assert codelines == ["4 + 5", "getitem('', 'join')",
-            "setattr('x', 'y', 3)", "12 - 1"]
-
-@pytest.mark.skipif("sys.version_info < (2,6)")
 def test_assert_customizable_reprcompare(monkeypatch):
     monkeypatch.setattr(util, '_reprcompare', lambda *args: 'hello')
     try:
@@ -306,7 +245,6 @@ def test_assert_raise_alias(testdir):
     ])
 
 
-@pytest.mark.skipif("sys.version_info < (2,5)")
 def test_assert_raise_subclass():
     class SomeEx(AssertionError):
         def __init__(self, *args):
@@ -334,18 +272,3 @@ def test_assert_raises_in_nonzero_of_object_pytest_issue10():
         e = exvalue()
         s = str(e)
         assert "<MY42 object> < 0" in s
-
-@pytest.mark.skipif("sys.version_info >= (2,6)")
-def test_oldinterpret_importation():
-    # we had a cyclic import there
-    # requires pytest on sys.path
-    res = py.std.subprocess.call([
-        py.std.sys.executable, '-c', str(py.code.Source("""
-        try:
-            from _pytest.assertion.newinterpret import interpret
-        except ImportError:
-            from _pytest.assertion.oldinterpret import interpret
-        """))
-    ])
-
-    assert res == 0

testing/test_assertion.py

@@ -2,12 +2,13 @@
 import sys
 import textwrap
 
-import py, pytest
 import _pytest.assertion as plugin
+import _pytest._code
+import py
+import pytest
 from _pytest.assertion import reinterpret
 from _pytest.assertion import util
 
-needsnewassert = pytest.mark.skipif("sys.version_info < (2,6)")
 PY3 = sys.version_info >= (3, 0)
 
 
@@ -23,10 +24,9 @@ def mock_config():
 
 
 def interpret(expr):
-    return reinterpret.reinterpret(expr, py.code.Frame(sys._getframe(1)))
+    return reinterpret.reinterpret(expr, _pytest._code.Frame(sys._getframe(1)))
 
 class TestBinReprIntegration:
-    pytestmark = needsnewassert
 
     def test_pytest_assertrepr_compare_called(self, testdir):
         testdir.makeconftest("""
@@ -242,6 +242,9 @@ class TestAssert_reprcompare:
         expl = callequal(A(), '1')
         assert expl
 
+    def test_format_nonascii_explanation(self):
+        assert util.format_explanation('λ')
+
     def test_mojibake(self):
         # issue 429
         left = 'e'
@@ -361,7 +364,6 @@ def test_python25_compile_issue257(testdir):
             *1 failed*
     """)
 
-@needsnewassert
 def test_rewritten(testdir):
     testdir.makepyfile("""
         def test_rewritten():
@@ -374,7 +376,6 @@ def test_reprcompare_notin(mock_config):
         mock_config, 'not in', 'foo', 'aaafoobbb')[1:]
     assert detail == ["'foo' is contained here:", '  aaafoobbb', '?    +++']
 
-@needsnewassert
 def test_pytest_assertrepr_compare_integration(testdir):
     testdir.makepyfile("""
         def test_hello():
@@ -391,7 +392,6 @@ def test_pytest_assertrepr_compare_integration(testdir):
         "*E*50*",
     ])
 
-@needsnewassert
 def test_sequence_comparison_uses_repr(testdir):
     testdir.makepyfile("""
         def test_hello():
@@ -410,8 +410,7 @@ def test_sequence_comparison_uses_repr(testdir):
     ])
 
 
-@pytest.mark.xfail("sys.version_info < (2,6)")
-def test_assert_compare_truncate_longmessage(testdir):
+def test_assert_compare_truncate_longmessage(monkeypatch, testdir):
     testdir.makepyfile(r"""
         def test_long():
             a = list(range(200))
@@ -420,6 +419,7 @@ def test_assert_compare_truncate_longmessage(testdir):
             b = '\n'.join(map(str, b))
             assert a == b
     """)
+    monkeypatch.delenv('CI', raising=False)
 
     result = testdir.runpytest()
     # without -vv, truncate the message showing a few diff lines only
@@ -437,8 +437,13 @@ def test_assert_compare_truncate_longmessage(testdir):
         "*- 197",
     ])
 
+    monkeypatch.setenv('CI', '1')
+    result = testdir.runpytest()
+    result.stdout.fnmatch_lines([
+        "*- 197",
+    ])
+
 
-@needsnewassert
 def test_assertrepr_loaded_per_dir(testdir):
     testdir.makepyfile(test_base=['def test_base(): assert 1 == 2'])
     a = testdir.mkdir('a')
@@ -547,7 +552,7 @@ def test_traceback_failure(testdir):
         "*test_traceback_failure.py:4: AssertionError"
     ])
 
-@pytest.mark.skipif("sys.version_info < (2,5) or '__pypy__' in sys.builtin_module_names or sys.platform.startswith('java')" )
+@pytest.mark.skipif("'__pypy__' in sys.builtin_module_names or sys.platform.startswith('java')" )
 def test_warn_missing(testdir):
     testdir.makepyfile("")
     result = testdir.run(sys.executable, "-OO", "-m", "pytest", "-h")

testing/test_assertrewrite.py

@@ -10,6 +10,7 @@ if sys.platform.startswith("java"):
     # XXX should be xfail
     pytest.skip("assert rewrite does currently not work on jython")
 
+import _pytest._code
 from _pytest.assertion import util
 from _pytest.assertion.rewrite import rewrite_asserts, PYTEST_TAG
 from _pytest.main import EXIT_NOTESTSCOLLECTED
@@ -17,7 +18,7 @@ from _pytest.main import EXIT_NOTESTSCOLLECTED
 
 def setup_module(mod):
     mod._old_reprcompare = util._reprcompare
-    py.code._reprcompare = None
+    _pytest._code._reprcompare = None
 
 def teardown_module(mod):
     util._reprcompare = mod._old_reprcompare
@@ -31,7 +32,7 @@ def rewrite(src):
 
 def getmsg(f, extra_ns=None, must_pass=False):
     """Rewrite the assertions in f, run it, and get the failure message."""
-    src = '\n'.join(py.code.Code(f).source().lines)
+    src = '\n'.join(_pytest._code.Code(f).source().lines)
     mod = rewrite(src)
     code = compile(mod, "<test>", "exec")
     ns = {}
@@ -279,6 +280,19 @@ class TestAssertionRewrite:
             assert False or 4 % 2
         assert getmsg(f) == "assert (False or (4 % 2))"
 
+    @pytest.mark.skipif("sys.version_info < (3,5)")
+    def test_at_operator_issue1290(self, testdir):
+        testdir.makepyfile("""
+            class Matrix:
+                def __init__(self, num):
+                    self.num = num
+                def __matmul__(self, other):
+                    return self.num * other.num
+
+            def test_multmat_operator():
+                assert Matrix(2) @ Matrix(3) == 6""")
+        testdir.runpytest().assert_outcomes(passed=1)
+
     def test_call(self):
         def g(a=42, *args, **kwargs):
             return False
@@ -669,7 +683,7 @@ class TestAssertionRewriteHookDetails(object):
         """Implement optional PEP302 api (#808).
         """
         path = testdir.mkpydir("foo")
-        path.join("test_foo.py").write(py.code.Source("""
+        path.join("test_foo.py").write(_pytest._code.Source("""
             class Test:
                 def test_foo(self):
                     import pkgutil

testing/test_cache.py

@@ -1,8 +1,9 @@
 import sys
+
+import _pytest
 import pytest
 import os
 import shutil
-import py
 
 pytest_plugins = "pytester",
 
@@ -45,12 +46,12 @@ class TestNewAPI:
     def test_cache_failure_warns(self, testdir):
         testdir.tmpdir.ensure_dir('.cache').chmod(0)
         testdir.makepyfile("""
-            def test_pass():
-                pass
+            def test_error():
+                raise Exception
 
         """)
         result = testdir.runpytest('-rw')
-        assert result.ret == 0
+        assert result.ret == 1
         result.stdout.fnmatch_lines([
             "*could not create cache path*",
             "*1 pytest-warnings*",
@@ -129,7 +130,7 @@ def test_cache_show(testdir):
 
 
 class TestLastFailed:
-    @pytest.mark.skipif("sys.version_info < (2,6)")
+
     def test_lastfailed_usecase(self, testdir, monkeypatch):
         monkeypatch.setenv("PYTHONDONTWRITEBYTECODE", 1)
         p = testdir.makepyfile("""
@@ -144,7 +145,7 @@ class TestLastFailed:
         result.stdout.fnmatch_lines([
             "*2 failed*",
         ])
-        p.write(py.code.Source("""
+        p.write(_pytest._code.Source("""
             def test_1():
                 assert 1
 
@@ -176,11 +177,11 @@ class TestLastFailed:
         ])
 
     def test_failedfirst_order(self, testdir):
-        testdir.tmpdir.join('test_a.py').write(py.code.Source("""
+        testdir.tmpdir.join('test_a.py').write(_pytest._code.Source("""
             def test_always_passes():
                 assert 1
         """))
-        testdir.tmpdir.join('test_b.py').write(py.code.Source("""
+        testdir.tmpdir.join('test_b.py').write(_pytest._code.Source("""
             def test_always_fails():
                 assert 0
         """))
@@ -197,7 +198,6 @@ class TestLastFailed:
             "test_a.py*",
         ])
 
-    @pytest.mark.skipif("sys.version_info < (2,6)")
     def test_lastfailed_difference_invocations(self, testdir, monkeypatch):
         monkeypatch.setenv("PYTHONDONTWRITEBYTECODE", 1)
         testdir.makepyfile(test_a="""
@@ -220,7 +220,7 @@ class TestLastFailed:
         result.stdout.fnmatch_lines([
             "*1 failed*",
         ])
-        p2.write(py.code.Source("""
+        p2.write(_pytest._code.Source("""
             def test_b1():
                 assert 1
         """))
@@ -233,7 +233,6 @@ class TestLastFailed:
             "*1 failed*1 desel*",
         ])
 
-    @pytest.mark.skipif("sys.version_info < (2,6)")
     def test_lastfailed_usecase_splice(self, testdir, monkeypatch):
         monkeypatch.setenv("PYTHONDONTWRITEBYTECODE", 1)
         testdir.makepyfile("""
@@ -241,7 +240,7 @@ class TestLastFailed:
                 assert 0
         """)
         p2 = testdir.tmpdir.join("test_something.py")
-        p2.write(py.code.Source("""
+        p2.write(_pytest._code.Source("""
             def test_2():
                 assert 0
         """))
@@ -267,7 +266,7 @@ class TestLastFailed:
         """)
         config = testdir.parseconfigure()
         lastfailed = config.cache.get("cache/lastfailed", -1)
-        assert not lastfailed
+        assert lastfailed == -1
 
     def test_non_serializable_parametrize(self, testdir):
         """Test that failed parametrized tests with unmarshable parameters
@@ -306,7 +305,7 @@ class TestLastFailed:
             return lastfailed
 
         lastfailed = rlf(fail_import=0, fail_run=0)
-        assert not lastfailed
+        assert lastfailed == -1
 
         lastfailed = rlf(fail_import=1, fail_run=0)
         assert list(lastfailed) == ['test_maybe.py']
@@ -348,7 +347,7 @@ class TestLastFailed:
             return result, lastfailed
 
         result, lastfailed = rlf(fail_import=0, fail_run=0)
-        assert not lastfailed
+        assert lastfailed == -1
         result.stdout.fnmatch_lines([
             '*3 passed*',
         ])
@@ -371,3 +370,17 @@ class TestLastFailed:
         result.stdout.fnmatch_lines([
             '*2 passed*',
         ])
+
+    def test_lastfailed_creates_cache_when_needed(self, testdir):
+        # Issue #1342
+        testdir.makepyfile(test_empty='')
+        testdir.runpytest('-q', '--lf')
+        assert not os.path.exists('.cache')
+
+        testdir.makepyfile(test_successful='def test_success():\n    assert True')
+        testdir.runpytest('-q', '--lf')
+        assert not os.path.exists('.cache')
+
+        testdir.makepyfile(test_errored='def test_error():\n    assert False')
+        testdir.runpytest('-q', '--lf')
+        assert os.path.exists('.cache')

testing/test_capture.py

@@ -4,6 +4,8 @@ from __future__ import with_statement
 import pickle
 import os
 import sys
+
+import _pytest._code
 import py
 import pytest
 import contextlib
@@ -481,7 +483,7 @@ class TestCaptureFixture:
 
 def test_setup_failure_does_not_kill_capturing(testdir):
     sub1 = testdir.mkpydir("sub1")
-    sub1.join("conftest.py").write(py.code.Source("""
+    sub1.join("conftest.py").write(_pytest._code.Source("""
         def pytest_runtest_setup(item):
             raise ValueError(42)
     """))
@@ -556,7 +558,6 @@ def test_capture_binary_output(testdir):
             import subprocess
             subprocess.call([sys.executable, __file__])
 
-        @pytest.mark.skip
         def test_foo():
             import os;os.write(1, b'\xc3')
 

testing/test_config.py

@@ -1,5 +1,6 @@
 import py, pytest
 
+import _pytest._code
 from _pytest.config import getcfg, get_common_ancestor, determine_setup
 from _pytest.main import EXIT_NOTESTSCOLLECTED
 
@@ -7,7 +8,7 @@ class TestParseIni:
     def test_getcfg_and_config(self, testdir, tmpdir):
         sub = tmpdir.mkdir("sub")
         sub.chdir()
-        tmpdir.join("setup.cfg").write(py.code.Source("""
+        tmpdir.join("setup.cfg").write(_pytest._code.Source("""
             [pytest]
             name = value
         """))
@@ -21,7 +22,7 @@ class TestParseIni:
 
     def test_append_parse_args(self, testdir, tmpdir, monkeypatch):
         monkeypatch.setenv('PYTEST_ADDOPTS', '--color no -rs --tb="short"')
-        tmpdir.join("setup.cfg").write(py.code.Source("""
+        tmpdir.join("setup.cfg").write(_pytest._code.Source("""
             [pytest]
             addopts = --verbose
         """))
@@ -230,6 +231,21 @@ class TestConfigAPI:
         l = config.getini("a2")
         assert l == []
 
+    @pytest.mark.parametrize('str_val, bool_val',
+                             [('True', True), ('no', False), ('no-ini', True)])
+    def test_addini_bool(self, testdir, str_val, bool_val):
+        testdir.makeconftest("""
+            def pytest_addoption(parser):
+                parser.addini("strip", "", type="bool", default=True)
+        """)
+        if str_val != 'no-ini':
+            testdir.makeini("""
+                [pytest]
+                strip=%s
+            """ % str_val)
+        config = testdir.parseconfig()
+        assert config.getini("strip") is bool_val
+
     def test_addinivalue_line_existing(self, testdir):
         testdir.makeconftest("""
             def pytest_addoption(parser):
@@ -264,6 +280,69 @@ class TestConfigAPI:
         assert len(l) == 2
         assert l == ["456", "123"]
 
+
+class TestConfigFromdictargs:
+    def test_basic_behavior(self):
+        from _pytest.config import Config
+        option_dict = {
+            'verbose': 444,
+            'foo': 'bar',
+            'capture': 'no',
+        }
+        args = ['a', 'b']
+
+        config = Config.fromdictargs(option_dict, args)
+        with pytest.raises(AssertionError):
+            config.parse(['should refuse to parse again'])
+        assert config.option.verbose == 444
+        assert config.option.foo == 'bar'
+        assert config.option.capture == 'no'
+        assert config.args == args
+
+    def test_origargs(self):
+        """Show that fromdictargs can handle args in their "orig" format"""
+        from _pytest.config import Config
+        option_dict = {}
+        args = ['-vvvv', '-s', 'a', 'b']
+
+        config = Config.fromdictargs(option_dict, args)
+        assert config.args == ['a', 'b']
+        assert config._origargs == args
+        assert config.option.verbose == 4
+        assert config.option.capture == 'no'
+
+    def test_inifilename(self, tmpdir):
+        tmpdir.join("foo/bar.ini").ensure().write(_pytest._code.Source("""
+            [pytest]
+            name = value
+        """))
+
+        from _pytest.config import Config
+        inifile = '../../foo/bar.ini'
+        option_dict = {
+            'inifilename': inifile,
+            'capture': 'no',
+        }
+
+        cwd = tmpdir.join('a/b')
+        cwd.join('pytest.ini').ensure().write(_pytest._code.Source("""
+            [pytest]
+            name = wrong-value
+            should_not_be_set = true
+        """))
+        with cwd.ensure(dir=True).as_cwd():
+            config = Config.fromdictargs(option_dict, ())
+
+        assert config.args == [str(cwd)]
+        assert config.option.inifilename == inifile
+        assert config.option.capture == 'no'
+
+        # this indicates this is the file used for getting configuration values
+        assert config.inifile == inifile
+        assert config.inicfg.get('name') == 'value'
+        assert config.inicfg.get('should_not_be_set') is None
+
+
 def test_options_on_small_file_do_not_blow_up(testdir):
     def runfiletest(opts):
         reprec = testdir.inline_run(*opts)

testing/test_conftest.py

@@ -1,5 +1,8 @@
 from textwrap import dedent
-import py, pytest
+
+import _pytest._code
+import py
+import pytest
 from _pytest.config import PytestPluginManager
 from _pytest.main import EXIT_NOTESTSCOLLECTED, EXIT_USAGEERROR
 
@@ -156,7 +159,7 @@ def test_setinitial_conftest_subdirs(testdir, name):
 def test_conftest_confcutdir(testdir):
     testdir.makeconftest("assert 0")
     x = testdir.mkdir("x")
-    x.join("conftest.py").write(py.code.Source("""
+    x.join("conftest.py").write(_pytest._code.Source("""
         def pytest_addoption(parser):
             parser.addoption("--xyz", action="store_true")
     """))
@@ -174,7 +177,7 @@ def test_no_conftest(testdir):
 
 def test_conftest_existing_resultlog(testdir):
     x = testdir.mkdir("tests")
-    x.join("conftest.py").write(py.code.Source("""
+    x.join("conftest.py").write(_pytest._code.Source("""
         def pytest_addoption(parser):
             parser.addoption("--xyz", action="store_true")
     """))
@@ -184,7 +187,7 @@ def test_conftest_existing_resultlog(testdir):
 
 def test_conftest_existing_junitxml(testdir):
     x = testdir.mkdir("tests")
-    x.join("conftest.py").write(py.code.Source("""
+    x.join("conftest.py").write(_pytest._code.Source("""
         def pytest_addoption(parser):
             parser.addoption("--xyz", action="store_true")
     """))
@@ -361,18 +364,18 @@ def test_search_conftest_up_to_inifile(testdir, confcutdir, passed, error):
     root = testdir.tmpdir
     src = root.join('src').ensure(dir=1)
     src.join('pytest.ini').write('[pytest]')
-    src.join('conftest.py').write(py.code.Source("""
+    src.join('conftest.py').write(_pytest._code.Source("""
         import pytest
         @pytest.fixture
         def fix1(): pass
     """))
-    src.join('test_foo.py').write(py.code.Source("""
+    src.join('test_foo.py').write(_pytest._code.Source("""
         def test_1(fix1):
             pass
         def test_2(out_of_reach):
             pass
     """))
-    root.join('conftest.py').write(py.code.Source("""
+    root.join('conftest.py').write(_pytest._code.Source("""
         import pytest
         @pytest.fixture
         def out_of_reach(): pass

testing/test_doctest.py

@@ -1,7 +1,7 @@
 # encoding: utf-8
 import sys
+import _pytest._code
 from _pytest.doctest import DoctestItem, DoctestModule, DoctestTextfile
-import py
 import pytest
 
 class TestDoctests:
@@ -88,7 +88,7 @@ class TestDoctests:
         reprec.assertoutcome(failed=1)
 
     def test_new_pattern(self, testdir):
-        p = testdir.maketxtfile(xdoc ="""
+        p = testdir.maketxtfile(xdoc="""
             >>> x = 1
             >>> x == 1
             False
@@ -96,6 +96,36 @@ class TestDoctests:
         reprec = testdir.inline_run(p, "--doctest-glob=x*.txt")
         reprec.assertoutcome(failed=1)
 
+    def test_multiple_patterns(self, testdir):
+        """Test support for multiple --doctest-glob arguments (#1255).
+        """
+        testdir.maketxtfile(xdoc="""
+            >>> 1
+            1
+        """)
+        testdir.makefile('.foo', test="""
+            >>> 1
+            1
+        """)
+        testdir.maketxtfile(test_normal="""
+            >>> 1
+            1
+        """)
+        expected = set(['xdoc.txt', 'test.foo', 'test_normal.txt'])
+        assert set(x.basename for x in testdir.tmpdir.listdir()) == expected
+        args = ["--doctest-glob=xdoc*.txt", "--doctest-glob=*.foo"]
+        result = testdir.runpytest(*args)
+        result.stdout.fnmatch_lines([
+            '*test.foo *',
+            '*xdoc.txt *',
+            '*2 passed*',
+        ])
+        result = testdir.runpytest()
+        result.stdout.fnmatch_lines([
+            '*test_normal.txt *',
+            '*1 passed*',
+        ])
+
     def test_doctest_unexpected_exception(self, testdir):
         testdir.maketxtfile("""
             >>> i = 0
@@ -151,7 +181,7 @@ class TestDoctests:
         assert 'text-line-after' not in result.stdout.str()
 
     def test_doctest_linedata_missing(self, testdir):
-        testdir.tmpdir.join('hello.py').write(py.code.Source("""
+        testdir.tmpdir.join('hello.py').write(_pytest._code.Source("""
             class Fun(object):
                 @property
                 def test(self):
@@ -171,7 +201,7 @@ class TestDoctests:
 
 
     def test_doctest_unex_importerror(self, testdir):
-        testdir.tmpdir.join("hello.py").write(py.code.Source("""
+        testdir.tmpdir.join("hello.py").write(_pytest._code.Source("""
             import asdalsdkjaslkdjasd
         """))
         testdir.maketxtfile("""
@@ -199,7 +229,7 @@ class TestDoctests:
 
     def test_doctestmodule_external_and_issue116(self, testdir):
         p = testdir.mkpydir("hello")
-        p.join("__init__.py").write(py.code.Source("""
+        p.join("__init__.py").write(_pytest._code.Source("""
             def somefunc():
                 '''
                     >>> i = 0
@@ -429,6 +459,9 @@ class TestDoctests:
                                     "--junit-xml=junit.xml")
         reprec.assertoutcome(failed=1)
 
+
+class TestLiterals:
+
     @pytest.mark.parametrize('config_mode', ['ini', 'comment'])
     def test_allow_unicode(self, testdir, config_mode):
         """Test that doctests which output unicode work in all python versions
@@ -458,6 +491,35 @@ class TestDoctests:
         reprec = testdir.inline_run("--doctest-modules")
         reprec.assertoutcome(passed=2)
 
+    @pytest.mark.parametrize('config_mode', ['ini', 'comment'])
+    def test_allow_bytes(self, testdir, config_mode):
+        """Test that doctests which output bytes work in all python versions
+        tested by pytest when the ALLOW_BYTES option is used (either in
+        the ini file or by an inline comment)(#1287).
+        """
+        if config_mode == 'ini':
+            testdir.makeini('''
+            [pytest]
+            doctest_optionflags = ALLOW_BYTES
+            ''')
+            comment = ''
+        else:
+            comment = '#doctest: +ALLOW_BYTES'
+
+        testdir.maketxtfile(test_doc="""
+            >>> b'foo'  {comment}
+            'foo'
+        """.format(comment=comment))
+        testdir.makepyfile(foo="""
+            def foo():
+              '''
+              >>> b'foo'  {comment}
+              'foo'
+              '''
+        """.format(comment=comment))
+        reprec = testdir.inline_run("--doctest-modules")
+        reprec.assertoutcome(passed=2)
+
     def test_unicode_string(self, testdir):
         """Test that doctests which output unicode fail in Python 2 when
         the ALLOW_UNICODE option is not used. The same test should pass
@@ -471,6 +533,19 @@ class TestDoctests:
         passed = int(sys.version_info[0] >= 3)
         reprec.assertoutcome(passed=passed, failed=int(not passed))
 
+    def test_bytes_literal(self, testdir):
+        """Test that doctests which output bytes fail in Python 3 when
+        the ALLOW_BYTES option is not used. The same test should pass
+        in Python 2 (#1287).
+        """
+        testdir.maketxtfile(test_doc="""
+            >>> b'foo'
+            'foo'
+        """)
+        reprec = testdir.inline_run()
+        passed = int(sys.version_info[0] == 2)
+        reprec.assertoutcome(passed=passed, failed=int(not passed))
+
 
 class TestDoctestSkips:
     """

testing/test_junitxml.py

@@ -449,11 +449,12 @@ class TestPython:
         assert "hello-stderr" in systemout.toxml()
 
 
-def test_mangle_testnames():
-    from _pytest.junitxml import mangle_testnames
-    names = ["a/pything.py", "Class", "()", "method"]
-    newnames = mangle_testnames(names)
-    assert newnames == ["a.pything", "Class", "method"]
+def test_mangle_test_address():
+    from _pytest.junitxml import mangle_test_address
+    address = '::'.join(
+        ["a/my.py.thing.py", "Class", "()", "method", "[a-1-::]"])
+    newnames = mangle_test_address(address)
+    assert newnames == ["a.my.py.thing", "Class", "method", "[a-1-::]"]
 
 
 def test_dont_configure_on_slaves(tmpdir):
@@ -619,6 +620,36 @@ def test_escaped_parametrized_names_xml(testdir):
     node.assert_attr(name="test_func[#x00]")
 
 
+def test_double_colon_split_function_issue469(testdir):
+    testdir.makepyfile("""
+        import pytest
+        @pytest.mark.parametrize('param', ["double::colon"])
+        def test_func(param):
+            pass
+    """)
+    result, dom = runandparse(testdir)
+    assert result.ret == 0
+    node = dom.find_first_by_tag("testcase")
+    node.assert_attr(classname="test_double_colon_split_function_issue469")
+    node.assert_attr(name='test_func[double::colon]')
+
+
+def test_double_colon_split_method_issue469(testdir):
+    testdir.makepyfile("""
+        import pytest
+        class TestClass:
+            @pytest.mark.parametrize('param', ["double::colon"])
+            def test_func(self, param):
+                pass
+    """)
+    result, dom = runandparse(testdir)
+    assert result.ret == 0
+    node = dom.find_first_by_tag("testcase")
+    node.assert_attr(
+        classname="test_double_colon_split_method_issue469.TestClass")
+    node.assert_attr(name='test_func[double::colon]')
+
+
 def test_unicode_issue368(testdir):
     path = testdir.tmpdir.join("test.xml")
     log = LogXML(str(path), None)
@@ -669,6 +700,21 @@ def test_record_property(testdir):
     result.stdout.fnmatch_lines('*C3*test_record_property.py*experimental*')
 
 
+def test_record_property_same_name(testdir):
+    testdir.makepyfile("""
+        def test_record_with_same_name(record_xml_property):
+            record_xml_property("foo", "bar")
+            record_xml_property("foo", "baz")
+    """)
+    result, dom = runandparse(testdir, '-rw')
+    node = dom.find_first_by_tag("testsuite")
+    tnode = node.find_first_by_tag("testcase")
+    psnode = tnode.find_first_by_tag('properties')
+    pnodes = psnode.find_by_tag('property')
+    pnodes[0].assert_attr(name="foo", value="bar")
+    pnodes[1].assert_attr(name="foo", value="baz")
+
+
 def test_random_report_log_xdist(testdir):
     """xdist calls pytest_runtest_logreport as they are executed by the slaves,
     with nodes from several nodes overlapping, so junitxml must cope with that

testing/test_mark.py

@@ -269,6 +269,22 @@ def test_keyword_option_parametrize(spec, testdir):
     assert len(passed) == len(passed_result)
     assert list(passed) == list(passed_result)
 
+
+def test_parametrized_collected_from_command_line(testdir):
+    """Parametrized test not collected if test named specified
+       in command line issue#649.
+    """
+    py_file = testdir.makepyfile("""
+        import pytest
+        @pytest.mark.parametrize("arg", [None, 1.3, "2-3"])
+        def test_func(arg):
+            pass
+    """)
+    file_name = os.path.basename(py_file.strpath)
+    rec = testdir.inline_run(file_name + "::" + "test_func")
+    rec.assertoutcome(passed=3)
+
+
 class TestFunctional:
 
     def test_mark_per_function(self, testdir):
@@ -316,7 +332,6 @@ class TestFunctional:
         assert 'hello' in keywords
         assert 'world' in keywords
 
-    @pytest.mark.skipif("sys.version_info < (2,6)")
     def test_mark_per_class_decorator(self, testdir):
         item = testdir.getitem("""
             import pytest
@@ -328,7 +343,6 @@ class TestFunctional:
         keywords = item.keywords
         assert 'hello' in keywords
 
-    @pytest.mark.skipif("sys.version_info < (2,6)")
     def test_mark_per_class_decorator_plus_existing_dec(self, testdir):
         item = testdir.getitem("""
             import pytest

testing/test_nose.py

@@ -300,7 +300,6 @@ def test_apiwrapper_problem_issue260(testdir):
     result = testdir.runpytest()
     result.assert_outcomes(passed=1)
 
-@pytest.mark.skipif("sys.version_info < (2,6)")
 def test_setup_teardown_linking_issue265(testdir):
     # we accidentally didnt integrate nose setupstate with normal setupstate
     # this test ensures that won't happen again

testing/test_parseopt.py

@@ -171,7 +171,6 @@ class TestParser:
         assert option.this == 42
         assert option.no is False
 
-    @pytest.mark.skipif("sys.version_info < (2,5)")
     def test_drop_short_helper(self):
         parser = py.std.argparse.ArgumentParser(formatter_class=parseopt.DropShorterLongHelpFormatter)
         parser.add_argument('-t', '--twoword', '--duo', '--two-word', '--two',
@@ -213,20 +212,17 @@ class TestParser:
         assert args.abc_def is False
         assert args.klm_hij is True
 
-    @pytest.mark.skipif("sys.version_info < (2,5)")
     def test_drop_short_2(self, parser):
         parser.addoption('--func-arg', '--doit', action='store_true')
         args = parser.parse(['--doit'])
         assert args.func_arg is True
 
-    @pytest.mark.skipif("sys.version_info < (2,5)")
     def test_drop_short_3(self, parser):
         parser.addoption('--func-arg', '--funcarg', '--doit', action='store_true')
         args = parser.parse(['abcd'])
         assert args.func_arg is False
         assert args.file_or_dir == ['abcd']
 
-    @pytest.mark.skipif("sys.version_info < (2,5)")
     def test_drop_short_help0(self, parser, capsys):
         parser.addoption('--func-args', '--doit', help = 'foo',
                          action='store_true')
@@ -235,7 +231,6 @@ class TestParser:
         assert '--func-args, --doit  foo' in  help
 
     # testing would be more helpful with all help generated
-    @pytest.mark.skipif("sys.version_info < (2,5)")
     def test_drop_short_help1(self, parser, capsys):
         group = parser.getgroup("general")
         group.addoption('--doit', '--func-args', action='store_true', help='foo')
@@ -246,7 +241,6 @@ class TestParser:
         assert '-doit, --func-args  foo' in  help
 
 
-@pytest.mark.skipif("sys.version_info < (2,6)")
 def test_argcomplete(testdir, monkeypatch):
     if not py.path.local.sysfind('bash'):
         pytest.skip("bash not available")

testing/test_pdb.py

@@ -1,7 +1,8 @@
-
-import py
 import sys
 
+import _pytest._code
+
+
 def runpdb_and_get_report(testdir, source):
     p = testdir.makepyfile(source)
     result = testdir.runpytest_inprocess("--pdb", p)
@@ -27,7 +28,7 @@ class TestPDB:
         """)
         assert rep.failed
         assert len(pdblist) == 1
-        tb = py.code.Traceback(pdblist[0][0])
+        tb = _pytest._code.Traceback(pdblist[0][0])
         assert tb[-1].name == "test_func"
 
     def test_pdb_on_xfail(self, testdir, pdblist):
@@ -291,8 +292,12 @@ class TestPDB:
 
     def test_enter_pdb_hook_is_called(self, testdir):
         testdir.makeconftest("""
-            def pytest_enter_pdb():
+            def pytest_enter_pdb(config):
+                assert config.testing_verification == 'configured'
                 print 'enter_pdb_hook'
+
+            def pytest_configure(config):
+                config.testing_verification = 'configured'
         """)
         p1 = testdir.makepyfile("""
             import pytest