Merge pull request #3864 from asottile/source_to_dedent

Replace Source with dedent where possible

testing/acceptance_test.py

@@ -2,11 +2,11 @@
 from __future__ import absolute_import, division, print_function
 import os
 import sys
+import textwrap
 import types
 
 import six
 
-import _pytest._code
 import py
 import pytest
 from _pytest.main import EXIT_NOTESTSCOLLECTED, EXIT_USAGEERROR
@@ -201,16 +201,16 @@ class TestGeneralUsage(object):
         testdir.tmpdir.join("py").mksymlinkto(py._pydir)
         p = testdir.tmpdir.join("main.py")
         p.write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                import sys, os
+                sys.path.insert(0, '')
+                import py
+                print(py.__file__)
+                print(py.__path__)
+                os.chdir(os.path.dirname(os.getcwd()))
+                print(py.log)
                 """
-            import sys, os
-            sys.path.insert(0, '')
-            import py
-            print (py.__file__)
-            print (py.__path__)
-            os.chdir(os.path.dirname(os.getcwd()))
-            print (py.log)
-        """
             )
         )
         result = testdir.runpython(p)

testing/code/test_code.py

@@ -4,6 +4,7 @@ import sys
 
 import _pytest._code
 import pytest
+import mock
 from test_excinfo import TWMock
 from six import text_type
 
@@ -67,12 +68,8 @@ def test_getstatement_empty_fullsource():
 
     f = func()
     f = _pytest._code.Frame(f)
-    prop = f.code.__class__.fullsource
+    with mock.patch.object(f.code.__class__, "fullsource", None):
-    try:
+        assert f.statement == ""
-        f.code.__class__.fullsource = None
-        assert f.statement == _pytest._code.Source("")
-    finally:
-        f.code.__class__.fullsource = prop
 
 
 def test_code_from_func():

testing/code/test_excinfo.py

@@ -149,7 +149,7 @@ class TestTraceback_f_g_h(object):
                 except somenoname:
                     pass
             xyz()
-        """
+            """
         )
         try:
             exec(source.compile())
@@ -426,7 +426,7 @@ class TestFormattedExcinfo(object):
     @pytest.fixture
     def importasmod(self, request):
         def importasmod(source):
-            source = _pytest._code.Source(source)
+            source = textwrap.dedent(source)
             tmpdir = request.getfixturevalue("tmpdir")
             modpath = tmpdir.join("mod.py")
             tmpdir.ensure("__init__.py")
@@ -450,10 +450,10 @@ class TestFormattedExcinfo(object):
     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)

testing/python/collect.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 import os
 import sys
-from textwrap import dedent
+import textwrap
 
 import _pytest._code
 import pytest
@@ -47,13 +47,14 @@ class TestModule(object):
         p = root2.join("test_x456.py")
         monkeypatch.syspath_prepend(str(root1))
         p.write(
-            dedent(
+            textwrap.dedent(
                 """\
-            import x456
+                import x456
-            def test():
+                def test():
-                assert x456.__file__.startswith(%r)
+                    assert x456.__file__.startswith({!r})
-        """
+                """.format(
-                % str(root2)
+                    str(root2)
+                )
             )
         )
         with root2.as_cwd():
@@ -929,23 +930,23 @@ class TestConftestCustomization(object):
     def test_customized_pymakemodule_issue205_subdir(self, testdir):
         b = testdir.mkdir("a").mkdir("b")
         b.join("conftest.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                import pytest
+                @pytest.hookimpl(hookwrapper=True)
+                def pytest_pycollect_makemodule():
+                    outcome = yield
+                    mod = outcome.get_result()
+                    mod.obj.hello = "world"
                 """
-            import pytest
-            @pytest.hookimpl(hookwrapper=True)
-            def pytest_pycollect_makemodule():
-                outcome = yield
-                mod = outcome.get_result()
-                mod.obj.hello = "world"
-        """
             )
         )
         b.join("test_module.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                def test_hello():
+                    assert hello == "world"
                 """
-            def test_hello():
-                assert hello == "world"
-        """
             )
         )
         reprec = testdir.inline_run()
@@ -954,31 +955,31 @@ class TestConftestCustomization(object):
     def test_customized_pymakeitem(self, testdir):
         b = testdir.mkdir("a").mkdir("b")
         b.join("conftest.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                import pytest
+                @pytest.hookimpl(hookwrapper=True)
+                def pytest_pycollect_makeitem():
+                    outcome = yield
+                    if outcome.excinfo is None:
+                        result = outcome.get_result()
+                        if result:
+                            for func in result:
+                                func._some123 = "world"
                 """
-            import pytest
-            @pytest.hookimpl(hookwrapper=True)
-            def pytest_pycollect_makeitem():
-                outcome = yield
-                if outcome.excinfo is None:
-                    result = outcome.get_result()
-                    if result:
-                        for func in result:
-                            func._some123 = "world"
-        """
             )
         )
         b.join("test_module.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
-                """
+                """\
-            import pytest
+                import pytest
 
-            @pytest.fixture()
+                @pytest.fixture()
-            def obj(request):
+                def obj(request):
-                return request.node._some123
+                    return request.node._some123
-            def test_hello(obj):
+                def test_hello(obj):
-                assert obj == "world"
+                    assert obj == "world"
-        """
+                """
             )
         )
         reprec = testdir.inline_run()
@@ -1033,7 +1034,7 @@ class TestConftestCustomization(object):
         )
         testdir.makefile(
             ".narf",
-            """
+            """\
             def test_something():
                 assert 1 + 1 == 2""",
         )
@@ -1046,29 +1047,29 @@ def test_setup_only_available_in_subdir(testdir):
     sub1 = testdir.mkpydir("sub1")
     sub2 = testdir.mkpydir("sub2")
     sub1.join("conftest.py").write(
-        _pytest._code.Source(
+        textwrap.dedent(
+            """\
+            import pytest
+            def pytest_runtest_setup(item):
+                assert item.fspath.purebasename == "test_in_sub1"
+            def pytest_runtest_call(item):
+                assert item.fspath.purebasename == "test_in_sub1"
+            def pytest_runtest_teardown(item):
+                assert item.fspath.purebasename == "test_in_sub1"
             """
-        import pytest
-        def pytest_runtest_setup(item):
-            assert item.fspath.purebasename == "test_in_sub1"
-        def pytest_runtest_call(item):
-            assert item.fspath.purebasename == "test_in_sub1"
-        def pytest_runtest_teardown(item):
-            assert item.fspath.purebasename == "test_in_sub1"
-    """
         )
     )
     sub2.join("conftest.py").write(
-        _pytest._code.Source(
+        textwrap.dedent(
+            """\
+            import pytest
+            def pytest_runtest_setup(item):
+                assert item.fspath.purebasename == "test_in_sub2"
+            def pytest_runtest_call(item):
+                assert item.fspath.purebasename == "test_in_sub2"
+            def pytest_runtest_teardown(item):
+                assert item.fspath.purebasename == "test_in_sub2"
             """
-        import pytest
-        def pytest_runtest_setup(item):
-            assert item.fspath.purebasename == "test_in_sub2"
-        def pytest_runtest_call(item):
-            assert item.fspath.purebasename == "test_in_sub2"
-        def pytest_runtest_teardown(item):
-            assert item.fspath.purebasename == "test_in_sub2"
-    """
         )
     )
     sub1.join("test_in_sub1.py").write("def test_1(): pass")
@@ -1547,12 +1548,12 @@ def test_skip_duplicates_by_default(testdir):
     a = testdir.mkdir("a")
     fh = a.join("test_a.py")
     fh.write(
-        _pytest._code.Source(
+        textwrap.dedent(
+            """\
+            import pytest
+            def test_real():
+                pass
             """
-        import pytest
-        def test_real():
-            pass
-    """
         )
     )
     result = testdir.runpytest(a.strpath, a.strpath)
@@ -1567,12 +1568,12 @@ def test_keep_duplicates(testdir):
     a = testdir.mkdir("a")
     fh = a.join("test_a.py")
     fh.write(
-        _pytest._code.Source(
+        textwrap.dedent(
+            """\
+            import pytest
+            def test_real():
+                pass
             """
-        import pytest
-        def test_real():
-            pass
-    """
         )
     )
     result = testdir.runpytest("--keep-duplicates", a.strpath, a.strpath)

testing/python/fixture.py

@@ -1,6 +1,5 @@
-from textwrap import dedent
+import textwrap
 
-import _pytest._code
 import pytest
 from _pytest.pytester import get_public_names
 from _pytest.fixtures import FixtureLookupError, FixtureRequest
@@ -208,23 +207,23 @@ class TestFillFixtures(object):
         )
         subdir = testdir.mkpydir("subdir")
         subdir.join("conftest.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
-                """
+                """\
-            import pytest
+                import pytest
 
-            @pytest.fixture
+                @pytest.fixture
-            def spam():
+                def spam():
-                return 'spam'
+                    return 'spam'
-        """
+                """
             )
         )
         testfile = subdir.join("test_spam.py")
         testfile.write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                def test_spam(spam):
+                    assert spam == "spam"
                 """
-            def test_spam(spam):
-                assert spam == "spam"
-        """
             )
         )
         result = testdir.runpytest()
@@ -276,26 +275,26 @@ class TestFillFixtures(object):
         )
         subdir = testdir.mkpydir("subdir")
         subdir.join("conftest.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
-                """
+                """\
-            import pytest
+                import pytest
 
-            @pytest.fixture(params=[1, 2, 3])
+                @pytest.fixture(params=[1, 2, 3])
-            def spam(request):
+                def spam(request):
-                return request.param
+                    return request.param
-        """
+                """
             )
         )
         testfile = subdir.join("test_spam.py")
         testfile.write(
-            _pytest._code.Source(
+            textwrap.dedent(
-                """
+                """\
-            params = {'spam': 1}
+                params = {'spam': 1}
 
-            def test_spam(spam):
+                def test_spam(spam):
-                assert spam == params['spam']
+                    assert spam == params['spam']
-                params['spam'] += 1
+                    params['spam'] += 1
-        """
+                """
             )
         )
         result = testdir.runpytest()
@@ -320,26 +319,26 @@ class TestFillFixtures(object):
         )
         subdir = testdir.mkpydir("subdir")
         subdir.join("conftest.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
-                """
+                """\
-            import pytest
+                import pytest
 
-            @pytest.fixture(params=[1, 2, 3])
+                @pytest.fixture(params=[1, 2, 3])
-            def spam(request):
+                def spam(request):
-                return request.param
+                    return request.param
-        """
+                """
             )
         )
         testfile = subdir.join("test_spam.py")
         testfile.write(
-            _pytest._code.Source(
+            textwrap.dedent(
-                """
+                """\
-            params = {'spam': 1}
+                params = {'spam': 1}
 
-            def test_spam(spam):
+                def test_spam(spam):
-                assert spam == params['spam']
+                    assert spam == params['spam']
-                params['spam'] += 1
+                    params['spam'] += 1
-        """
+                """
             )
         )
         result = testdir.runpytest()
@@ -807,13 +806,13 @@ class TestRequestBasic(object):
         # this tests that normalization of nodeids takes place
         b = testdir.mkdir("tests").mkdir("unit")
         b.join("conftest.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                import pytest
+                @pytest.fixture
+                def arg1():
+                    pass
                 """
-            import pytest
-            @pytest.fixture
-            def arg1():
-                pass
-        """
             )
         )
         p = b.join("test_module.py")
@@ -1484,41 +1483,41 @@ class TestFixtureManagerParseFactories(object):
         runner = testdir.mkdir("runner")
         package = testdir.mkdir("package")
         package.join("conftest.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
             import pytest
             @pytest.fixture
             def one():
                 return 1
-        """
+            """
             )
         )
         package.join("test_x.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
-            def test_x(one):
+                def test_x(one):
-                assert one == 1
+                    assert one == 1
-        """
+                """
             )
         )
         sub = package.mkdir("sub")
         sub.join("__init__.py").ensure()
         sub.join("conftest.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
-            import pytest
+                import pytest
-            @pytest.fixture
+                @pytest.fixture
-            def one():
+                def one():
-                return 2
+                    return 2
-        """
+                """
             )
         )
         sub.join("test_y.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
-            def test_x(one):
+                def test_x(one):
-                assert one == 2
+                    assert one == 2
-        """
+                """
             )
         )
         reprec = testdir.inline_run()
@@ -1535,44 +1534,44 @@ class TestFixtureManagerParseFactories(object):
         )
         package = testdir.mkdir("package")
         package.join("__init__.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
-            from .. import values
+                from .. import values
-            def setup_module():
+                def setup_module():
-                values.append("package")
+                    values.append("package")
-            def teardown_module():
+                def teardown_module():
-                values[:] = []
+                    values[:] = []
-        """
+                """
             )
         )
         package.join("test_x.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
-            from .. import values
+                from .. import values
-            def test_x():
+                def test_x():
-                assert values == ["package"]
+                    assert values == ["package"]
-        """
+                """
             )
         )
         package = testdir.mkdir("package2")
         package.join("__init__.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
-            from .. import values
+                from .. import values
-            def setup_module():
+                def setup_module():
-                values.append("package2")
+                    values.append("package2")
-            def teardown_module():
+                def teardown_module():
-                values[:] = []
+                    values[:] = []
-        """
+                """
             )
         )
         package.join("test_x.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
-            from .. import values
+                from .. import values
-            def test_x():
+                def test_x():
-                assert values == ["package2"]
+                    assert values == ["package2"]
-        """
+                """
             )
         )
         reprec = testdir.inline_run()
@@ -1587,32 +1586,32 @@ class TestFixtureManagerParseFactories(object):
         package = testdir.mkdir("package")
         package.join("__init__.py").write("")
         package.join("conftest.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
-            import pytest
+                import pytest
-            from .. import values
+                from .. import values
-            @pytest.fixture(scope="package")
+                @pytest.fixture(scope="package")
-            def one():
+                def one():
-                values.append("package")
+                    values.append("package")
-                yield values
+                    yield values
-                values.pop()
+                    values.pop()
-            @pytest.fixture(scope="package", autouse=True)
+                @pytest.fixture(scope="package", autouse=True)
-            def two():
+                def two():
-                values.append("package-auto")
+                    values.append("package-auto")
-                yield values
+                    yield values
-                values.pop()
+                    values.pop()
-        """
+                """
             )
         )
         package.join("test_x.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
-            from .. import values
+                from .. import values
-            def test_package_autouse():
+                def test_package_autouse():
-                assert values == ["package-auto"]
+                    assert values == ["package-auto"]
-            def test_package(one):
+                def test_package(one):
-                assert values == ["package-auto", "package"]
+                    assert values == ["package-auto", "package"]
-        """
+                """
             )
         )
         reprec = testdir.inline_run()
@@ -1804,24 +1803,24 @@ class TestAutouseManagement(object):
     def test_autouse_conftest_mid_directory(self, testdir):
         pkgdir = testdir.mkpydir("xyz123")
         pkgdir.join("conftest.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                import pytest
+                @pytest.fixture(autouse=True)
+                def app():
+                    import sys
+                    sys._myapp = "hello"
                 """
-            import pytest
-            @pytest.fixture(autouse=True)
-            def app():
-                import sys
-                sys._myapp = "hello"
-        """
             )
         )
         t = pkgdir.ensure("tests", "test_app.py")
         t.write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                import sys
+                def test_app():
+                    assert sys._myapp == "hello"
                 """
-            import sys
-            def test_app():
-                assert sys._myapp == "hello"
-        """
             )
         )
         reprec = testdir.inline_run("-s")
@@ -2715,17 +2714,17 @@ class TestFixtureMarker(object):
         )
         b = testdir.mkdir("subdir")
         b.join("test_overridden_fixture_finalizer.py").write(
-            dedent(
+            textwrap.dedent(
-                """
+                """\
-            import pytest
+                import pytest
-            @pytest.fixture
+                @pytest.fixture
-            def browser(browser):
+                def browser(browser):
-                browser['visited'] = True
+                    browser['visited'] = True
-                return browser
+                    return browser
 
-            def test_browser(browser):
+                def test_browser(browser):
-                assert browser['visited'] is True
+                    assert browser['visited'] is True
-        """
+                """
             )
         )
         reprec = testdir.runpytest("-s")
@@ -3217,120 +3216,119 @@ class TestShowFixtures(object):
 
     def test_show_fixtures_trimmed_doc(self, testdir):
         p = testdir.makepyfile(
-            dedent(
+            textwrap.dedent(
+                '''\
+                import pytest
+                @pytest.fixture
+                def arg1():
+                    """
+                    line1
+                    line2
+
+                    """
+                @pytest.fixture
+                def arg2():
+                    """
+                    line1
+                    line2
+
+                    """
                 '''
-            import pytest
-            @pytest.fixture
-            def arg1():
-                """
-                line1
-                line2
-
-                """
-            @pytest.fixture
-            def arg2():
-                """
-                line1
-                line2
-
-                """
-        '''
             )
         )
         result = testdir.runpytest("--fixtures", p)
         result.stdout.fnmatch_lines(
-            dedent(
+            textwrap.dedent(
+                """\
+                * fixtures defined from test_show_fixtures_trimmed_doc *
+                arg2
+                    line1
+                    line2
+                arg1
+                    line1
+                    line2
                 """
-            * fixtures defined from test_show_fixtures_trimmed_doc *
-            arg2
-                line1
-                line2
-            arg1
-                line1
-                line2
-
-        """
             )
         )
 
     def test_show_fixtures_indented_doc(self, testdir):
         p = testdir.makepyfile(
-            dedent(
+            textwrap.dedent(
+                '''\
+                import pytest
+                @pytest.fixture
+                def fixture1():
+                    """
+                    line1
+                        indented line
+                    """
                 '''
-            import pytest
-            @pytest.fixture
-            def fixture1():
-                """
-                line1
-                    indented line
-                """
-        '''
             )
         )
         result = testdir.runpytest("--fixtures", p)
         result.stdout.fnmatch_lines(
-            dedent(
+            textwrap.dedent(
+                """\
+                * fixtures defined from test_show_fixtures_indented_doc *
+                fixture1
+                    line1
+                        indented line
                 """
-            * fixtures defined from test_show_fixtures_indented_doc *
-            fixture1
-                line1
-                    indented line
-        """
             )
         )
 
     def test_show_fixtures_indented_doc_first_line_unindented(self, testdir):
         p = testdir.makepyfile(
-            dedent(
+            textwrap.dedent(
+                '''\
+                import pytest
+                @pytest.fixture
+                def fixture1():
+                    """line1
+                    line2
+                        indented line
+                    """
                 '''
-            import pytest
-            @pytest.fixture
-            def fixture1():
-                """line1
-                line2
-                    indented line
-                """
-        '''
             )
         )
         result = testdir.runpytest("--fixtures", p)
         result.stdout.fnmatch_lines(
-            dedent(
+            textwrap.dedent(
+                """\
+                * fixtures defined from test_show_fixtures_indented_doc_first_line_unindented *
+                fixture1
+                    line1
+                    line2
+                        indented line
                 """
-            * fixtures defined from test_show_fixtures_indented_doc_first_line_unindented *
-            fixture1
-                line1
-                line2
-                    indented line
-        """
             )
         )
 
     def test_show_fixtures_indented_in_class(self, testdir):
         p = testdir.makepyfile(
-            dedent(
+            textwrap.dedent(
+                '''\
+                import pytest
+                class TestClass(object):
+                    @pytest.fixture
+                    def fixture1(self):
+                        """line1
+                        line2
+                            indented line
+                        """
                 '''
-            import pytest
-            class TestClass(object):
-                @pytest.fixture
-                def fixture1(self):
-                    """line1
-                    line2
-                        indented line
-                    """
-        '''
             )
         )
         result = testdir.runpytest("--fixtures", p)
         result.stdout.fnmatch_lines(
-            dedent(
+            textwrap.dedent(
+                """\
+                * fixtures defined from test_show_fixtures_indented_in_class *
+                fixture1
+                    line1
+                    line2
+                        indented line
                 """
-            * fixtures defined from test_show_fixtures_indented_in_class *
-            fixture1
-                line1
-                line2
-                    indented line
-        """
             )
         )
 
@@ -3667,26 +3665,26 @@ class TestParameterizedSubRequest(object):
         fixdir = testdir.mkdir("fixtures")
         fixfile = fixdir.join("fix.py")
         fixfile.write(
-            _pytest._code.Source(
+            textwrap.dedent(
-                """
+                """\
-            import pytest
+                import pytest
 
-            @pytest.fixture(params=[0, 1, 2])
+                @pytest.fixture(params=[0, 1, 2])
-            def fix_with_param(request):
+                def fix_with_param(request):
-                return request.param
+                    return request.param
-            """
+                """
             )
         )
 
         testfile = tests_dir.join("test_foos.py")
         testfile.write(
-            _pytest._code.Source(
+            textwrap.dedent(
-                """
+                """\
-            from fix import fix_with_param
+                from fix import fix_with_param
 
-            def test_foo(request):
+                def test_foo(request):
-                request.getfixturevalue('fix_with_param')
+                    request.getfixturevalue('fix_with_param')
-            """
+                """
             )
         )
 
@@ -3698,9 +3696,9 @@ class TestParameterizedSubRequest(object):
             E*Failed: The requested fixture has no parameter defined for the current test.
             E*
             E*Requested fixture 'fix_with_param' defined in:
-            E*fix.py:5
+            E*fix.py:4
             E*Requested here:
-            E*test_foos.py:5
+            E*test_foos.py:4
             *1 failed*
             """
         )

testing/python/metafunc.py

@@ -2,7 +2,7 @@
 import re
 import sys
 import attr
-import _pytest._code
+import textwrap
 import pytest
 from _pytest import python, fixtures
 
@@ -1271,19 +1271,19 @@ class TestMetafuncFunctional(object):
         sub1 = testdir.mkpydir("sub1")
         sub2 = testdir.mkpydir("sub2")
         sub1.join("conftest.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                def pytest_generate_tests(metafunc):
+                    assert metafunc.function.__name__ == "test_1"
                 """
-            def pytest_generate_tests(metafunc):
-                assert metafunc.function.__name__ == "test_1"
-        """
             )
         )
         sub2.join("conftest.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                def pytest_generate_tests(metafunc):
+                    assert metafunc.function.__name__ == "test_2"
                 """
-            def pytest_generate_tests(metafunc):
-                assert metafunc.function.__name__ == "test_2"
-        """
             )
         )
         sub1.join("test_in_sub1.py").write("def test_1(): pass")

testing/test_assertrewrite.py

@@ -1039,14 +1039,14 @@ class TestAssertionRewriteHookDetails(object):
         """
         path = testdir.mkpydir("foo")
         path.join("test_foo.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                class Test(object):
+                    def test_foo(self):
+                        import pkgutil
+                        data = pkgutil.get_data('foo.test_foo', 'data.txt')
+                        assert data == b'Hey'
                 """
-            class Test(object):
-                def test_foo(self):
-                    import pkgutil
-                    data = pkgutil.get_data('foo.test_foo', 'data.txt')
-                    assert data == b'Hey'
-        """
             )
         )
         path.join("data.txt").write("Hey")

testing/test_cacheprovider.py

@@ -1,9 +1,9 @@
 from __future__ import absolute_import, division, print_function
 
 import sys
+import textwrap
 
 import py
-import _pytest
 import pytest
 import os
 import shutil
@@ -224,17 +224,17 @@ class TestLastFailed(object):
         result = testdir.runpytest()
         result.stdout.fnmatch_lines(["*2 failed*"])
         p.write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                def test_1():
+                    assert 1
+
+                def test_2():
+                    assert 1
+
+                def test_3():
+                    assert 0
                 """
-            def test_1():
-                assert 1
-
-            def test_2():
-                assert 1
-
-            def test_3():
-                assert 0
-        """
             )
         )
         result = testdir.runpytest("--lf")
@@ -252,19 +252,19 @@ class TestLastFailed(object):
 
     def test_failedfirst_order(self, testdir):
         testdir.tmpdir.join("test_a.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                def test_always_passes():
+                    assert 1
                 """
-            def test_always_passes():
-                assert 1
-        """
             )
         )
         testdir.tmpdir.join("test_b.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                def test_always_fails():
+                    assert 0
                 """
-            def test_always_fails():
-                assert 0
-        """
             )
         )
         result = testdir.runpytest()
@@ -277,14 +277,14 @@ class TestLastFailed(object):
     def test_lastfailed_failedfirst_order(self, testdir):
         testdir.makepyfile(
             **{
-                "test_a.py": """
+                "test_a.py": """\
                 def test_always_passes():
                     assert 1
-            """,
+                """,
-                "test_b.py": """
+                "test_b.py": """\
                 def test_always_fails():
                     assert 0
-            """,
+                """,
             }
         )
         result = testdir.runpytest()
@@ -298,16 +298,16 @@ class TestLastFailed(object):
     def test_lastfailed_difference_invocations(self, testdir, monkeypatch):
         monkeypatch.setenv("PYTHONDONTWRITEBYTECODE", 1)
         testdir.makepyfile(
-            test_a="""
+            test_a="""\
             def test_a1():
                 assert 0
             def test_a2():
                 assert 1
-        """,
+            """,
-            test_b="""
+            test_b="""\
             def test_b1():
                 assert 0
-        """,
+            """,
         )
         p = testdir.tmpdir.join("test_a.py")
         p2 = testdir.tmpdir.join("test_b.py")
@@ -317,11 +317,11 @@ class TestLastFailed(object):
         result = testdir.runpytest("--lf", p2)
         result.stdout.fnmatch_lines(["*1 failed*"])
         p2.write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                def test_b1():
+                    assert 1
                 """
-            def test_b1():
-                assert 1
-        """
             )
         )
         result = testdir.runpytest("--lf", p2)
@@ -332,18 +332,18 @@ class TestLastFailed(object):
     def test_lastfailed_usecase_splice(self, testdir, monkeypatch):
         monkeypatch.setenv("PYTHONDONTWRITEBYTECODE", 1)
         testdir.makepyfile(
-            """
+            """\
             def test_1():
                 assert 0
-        """
+            """
         )
         p2 = testdir.tmpdir.join("test_something.py")
         p2.write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                def test_2():
+                    assert 0
                 """
-            def test_2():
-                assert 0
-        """
             )
         )
         result = testdir.runpytest()

testing/test_capture.py

@@ -6,9 +6,9 @@ from __future__ import absolute_import, division, print_function
 import pickle
 import os
 import sys
+import textwrap
 from io import UnsupportedOperation
 
-import _pytest._code
 import py
 import pytest
 import contextlib
@@ -269,7 +269,7 @@ class TestPerTestCapturing(object):
 
     def test_capturing_outerr(self, testdir):
         p1 = testdir.makepyfile(
-            """
+            """\
             import sys
             def test_capturing():
                 print (42)
@@ -278,7 +278,7 @@ class TestPerTestCapturing(object):
                 print (1)
                 sys.stderr.write(str(2))
                 raise ValueError
-        """
+            """
         )
         result = testdir.runpytest(p1)
         result.stdout.fnmatch_lines(
@@ -298,21 +298,21 @@ class TestPerTestCapturing(object):
 class TestLoggingInteraction(object):
     def test_logging_stream_ownership(self, testdir):
         p = testdir.makepyfile(
-            """
+            """\
             def test_logging():
                 import logging
                 import pytest
                 stream = capture.CaptureIO()
                 logging.basicConfig(stream=stream)
                 stream.close() # to free memory/release resources
-        """
+            """
         )
         result = testdir.runpytest_subprocess(p)
         assert result.stderr.str().find("atexit") == -1
 
     def test_logging_and_immediate_setupteardown(self, testdir):
         p = testdir.makepyfile(
-            """
+            """\
             import logging
             def setup_function(function):
                 logging.warn("hello1")
@@ -324,7 +324,7 @@ class TestLoggingInteraction(object):
             def teardown_function(function):
                 logging.warn("hello3")
                 assert 0
-        """
+            """
         )
         for optargs in (("--capture=sys",), ("--capture=fd",)):
             print(optargs)
@@ -338,7 +338,7 @@ class TestLoggingInteraction(object):
 
     def test_logging_and_crossscope_fixtures(self, testdir):
         p = testdir.makepyfile(
-            """
+            """\
             import logging
             def setup_module(function):
                 logging.warn("hello1")
@@ -350,7 +350,7 @@ class TestLoggingInteraction(object):
             def teardown_module(function):
                 logging.warn("hello3")
                 assert 0
-        """
+            """
         )
         for optargs in (("--capture=sys",), ("--capture=fd",)):
             print(optargs)
@@ -364,11 +364,11 @@ class TestLoggingInteraction(object):
 
     def test_conftestlogging_is_shown(self, testdir):
         testdir.makeconftest(
-            """
+            """\
                 import logging
                 logging.basicConfig()
                 logging.warn("hello435")
-        """
+            """
         )
         # make sure that logging is still captured in tests
         result = testdir.runpytest_subprocess("-s", "-p", "no:capturelog")
@@ -378,19 +378,19 @@ class TestLoggingInteraction(object):
 
     def test_conftestlogging_and_test_logging(self, testdir):
         testdir.makeconftest(
-            """
+            """\
                 import logging
                 logging.basicConfig()
-        """
+            """
         )
         # make sure that logging is still captured in tests
         p = testdir.makepyfile(
-            """
+            """\
             def test_hello():
                 import logging
                 logging.warn("hello433")
                 assert 0
-        """
+            """
         )
         result = testdir.runpytest_subprocess(p, "-p", "no:capturelog")
         assert result.ret != 0
@@ -403,24 +403,24 @@ class TestCaptureFixture(object):
     @pytest.mark.parametrize("opt", [[], ["-s"]])
     def test_std_functional(self, testdir, opt):
         reprec = testdir.inline_runsource(
-            """
+            """\
             def test_hello(capsys):
                 print (42)
                 out, err = capsys.readouterr()
                 assert out.startswith("42")
-        """,
+            """,
             *opt
         )
         reprec.assertoutcome(passed=1)
 
     def test_capsyscapfd(self, testdir):
         p = testdir.makepyfile(
-            """
+            """\
             def test_one(capsys, capfd):
                 pass
             def test_two(capfd, capsys):
                 pass
-        """
+            """
         )
         result = testdir.runpytest(p)
         result.stdout.fnmatch_lines(
@@ -438,12 +438,12 @@ class TestCaptureFixture(object):
         in the same test is an error.
         """
         testdir.makepyfile(
-            """
+            """\
             def test_one(capsys, request):
                 request.getfixturevalue("capfd")
             def test_two(capfd, request):
                 request.getfixturevalue("capsys")
-        """
+            """
         )
         result = testdir.runpytest()
         result.stdout.fnmatch_lines(
@@ -458,10 +458,10 @@ class TestCaptureFixture(object):
 
     def test_capsyscapfdbinary(self, testdir):
         p = testdir.makepyfile(
-            """
+            """\
             def test_one(capsys, capfdbinary):
                 pass
-        """
+            """
         )
         result = testdir.runpytest(p)
         result.stdout.fnmatch_lines(
@@ -471,12 +471,13 @@ class TestCaptureFixture(object):
     @pytest.mark.parametrize("method", ["sys", "fd"])
     def test_capture_is_represented_on_failure_issue128(self, testdir, method):
         p = testdir.makepyfile(
-            """
+            """\
-            def test_hello(cap%s):
+            def test_hello(cap{}):
                 print ("xxx42xxx")
                 assert 0
-        """
+            """.format(
-            % method
+                method
+            )
         )
         result = testdir.runpytest(p)
         result.stdout.fnmatch_lines(["xxx42xxx"])
@@ -484,21 +485,21 @@ class TestCaptureFixture(object):
     @needsosdup
     def test_stdfd_functional(self, testdir):
         reprec = testdir.inline_runsource(
-            """
+            """\
             def test_hello(capfd):
                 import os
                 os.write(1, "42".encode('ascii'))
                 out, err = capfd.readouterr()
                 assert out.startswith("42")
                 capfd.close()
-        """
+            """
         )
         reprec.assertoutcome(passed=1)
 
     @needsosdup
     def test_capfdbinary(self, testdir):
         reprec = testdir.inline_runsource(
-            """
+            """\
             def test_hello(capfdbinary):
                 import os
                 # some likely un-decodable bytes
@@ -506,7 +507,7 @@ class TestCaptureFixture(object):
                 out, err = capfdbinary.readouterr()
                 assert out == b'\\xfe\\x98\\x20'
                 assert err == b''
-        """
+            """
         )
         reprec.assertoutcome(passed=1)
 
@@ -515,7 +516,7 @@ class TestCaptureFixture(object):
     )
     def test_capsysbinary(self, testdir):
         reprec = testdir.inline_runsource(
-            """
+            """\
             def test_hello(capsysbinary):
                 import sys
                 # some likely un-decodable bytes
@@ -523,7 +524,7 @@ class TestCaptureFixture(object):
                 out, err = capsysbinary.readouterr()
                 assert out == b'\\xfe\\x98\\x20'
                 assert err == b''
-        """
+            """
         )
         reprec.assertoutcome(passed=1)
 
@@ -532,10 +533,10 @@ class TestCaptureFixture(object):
     )
     def test_capsysbinary_forbidden_in_python2(self, testdir):
         testdir.makepyfile(
-            """
+            """\
             def test_hello(capsysbinary):
                 pass
-        """
+            """
         )
         result = testdir.runpytest()
         result.stdout.fnmatch_lines(
@@ -548,10 +549,10 @@ class TestCaptureFixture(object):
 
     def test_partial_setup_failure(self, testdir):
         p = testdir.makepyfile(
-            """
+            """\
             def test_hello(capsys, missingarg):
                 pass
-        """
+            """
         )
         result = testdir.runpytest(p)
         result.stdout.fnmatch_lines(["*test_partial_setup_failure*", "*1 error*"])
@@ -559,12 +560,12 @@ class TestCaptureFixture(object):
     @needsosdup
     def test_keyboardinterrupt_disables_capturing(self, testdir):
         p = testdir.makepyfile(
-            """
+            """\
             def test_hello(capfd):
                 import os
                 os.write(1, str(42).encode('ascii'))
                 raise KeyboardInterrupt()
-        """
+            """
         )
         result = testdir.runpytest_subprocess(p)
         result.stdout.fnmatch_lines(["*KeyboardInterrupt*"])
@@ -573,7 +574,7 @@ class TestCaptureFixture(object):
     @pytest.mark.issue14
     def test_capture_and_logging(self, testdir):
         p = testdir.makepyfile(
-            """
+            """\
             import logging
             def test_log(capsys):
                 logging.error('x')
@@ -586,7 +587,7 @@ class TestCaptureFixture(object):
     @pytest.mark.parametrize("no_capture", [True, False])
     def test_disabled_capture_fixture(self, testdir, fixture, no_capture):
         testdir.makepyfile(
-            """
+            """\
             def test_disabled({fixture}):
                 print('captured before')
                 with {fixture}.disabled():
@@ -620,7 +621,7 @@ class TestCaptureFixture(object):
         Ensure that capsys and capfd can be used by other fixtures during setup and teardown.
         """
         testdir.makepyfile(
-            """
+            """\
             from __future__ import print_function
             import sys
             import pytest
@@ -656,7 +657,7 @@ class TestCaptureFixture(object):
     def test_fixture_use_by_other_fixtures_teardown(self, testdir, cap):
         """Ensure we can access setup and teardown buffers from teardown when using capsys/capfd (##3033)"""
         testdir.makepyfile(
-            """
+            """\
             import sys
             import pytest
             import os
@@ -684,11 +685,11 @@ class TestCaptureFixture(object):
 def test_setup_failure_does_not_kill_capturing(testdir):
     sub1 = testdir.mkpydir("sub1")
     sub1.join("conftest.py").write(
-        _pytest._code.Source(
+        textwrap.dedent(
+            """\
+            def pytest_runtest_setup(item):
+                raise ValueError(42)
             """
-        def pytest_runtest_setup(item):
-            raise ValueError(42)
-    """
         )
     )
     sub1.join("test_mod.py").write("def test_func1(): pass")

testing/test_collection.py

@@ -1,9 +1,9 @@
 from __future__ import absolute_import, division, print_function
 import pprint
 import sys
+import textwrap
 import pytest
 
-import _pytest._code
 from _pytest.main import Session, EXIT_NOTESTSCOLLECTED, _in_venv
 
 
@@ -913,13 +913,13 @@ def test_fixture_scope_sibling_conftests(testdir):
     """Regression test case for https://github.com/pytest-dev/pytest/issues/2836"""
     foo_path = testdir.mkdir("foo")
     foo_path.join("conftest.py").write(
-        _pytest._code.Source(
+        textwrap.dedent(
+            """\
+            import pytest
+            @pytest.fixture
+            def fix():
+                return 1
             """
-        import pytest
-        @pytest.fixture
-        def fix():
-            return 1
-    """
         )
     )
     foo_path.join("test_foo.py").write("def test_foo(fix): assert fix == 1")

testing/test_config.py

@@ -17,11 +17,11 @@ class TestParseIni(object):
         sub = tmpdir.mkdir("sub")
         sub.chdir()
         tmpdir.join(filename).write(
-            _pytest._code.Source(
+            textwrap.dedent(
-                """
+                """\
-            [{section}]
+                [{section}]
-            name = value
+                name = value
-        """.format(
+                """.format(
                     section=section
                 )
             )
@@ -38,11 +38,11 @@ class TestParseIni(object):
     def test_append_parse_args(self, testdir, tmpdir, monkeypatch):
         monkeypatch.setenv("PYTEST_ADDOPTS", '--color no -rs --tb="short"')
         tmpdir.join("pytest.ini").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                [pytest]
+                addopts = --verbose
                 """
-            [pytest]
-            addopts = --verbose
-        """
             )
         )
         config = testdir.parseconfig(tmpdir)
@@ -438,11 +438,11 @@ class TestConfigFromdictargs(object):
 
     def test_inifilename(self, tmpdir):
         tmpdir.join("foo/bar.ini").ensure().write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                [pytest]
+                name = value
                 """
-            [pytest]
-            name = value
-        """
             )
         )
 
@@ -453,12 +453,12 @@ class TestConfigFromdictargs(object):
 
         cwd = tmpdir.join("a/b")
         cwd.join("pytest.ini").ensure().write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                [pytest]
+                name = wrong-value
+                should_not_be_set = true
                 """
-            [pytest]
-            name = wrong-value
-            should_not_be_set = true
-        """
             )
         )
         with cwd.ensure(dir=True).as_cwd():

testing/test_conftest.py

@@ -1,7 +1,6 @@
 from __future__ import absolute_import, division, print_function
-from textwrap import dedent
+import textwrap
 
-import _pytest._code
 import py
 import pytest
 from _pytest.config import PytestPluginManager
@@ -174,11 +173,11 @@ def test_conftest_confcutdir(testdir):
     testdir.makeconftest("assert 0")
     x = testdir.mkdir("x")
     x.join("conftest.py").write(
-        _pytest._code.Source(
+        textwrap.dedent(
+            """\
+            def pytest_addoption(parser):
+                parser.addoption("--xyz", action="store_true")
             """
-        def pytest_addoption(parser):
-            parser.addoption("--xyz", action="store_true")
-    """
         )
     )
     result = testdir.runpytest("-h", "--confcutdir=%s" % x, x)
@@ -198,11 +197,11 @@ def test_no_conftest(testdir):
 def test_conftest_existing_resultlog(testdir):
     x = testdir.mkdir("tests")
     x.join("conftest.py").write(
-        _pytest._code.Source(
+        textwrap.dedent(
+            """\
+            def pytest_addoption(parser):
+                parser.addoption("--xyz", action="store_true")
             """
-        def pytest_addoption(parser):
-            parser.addoption("--xyz", action="store_true")
-    """
         )
     )
     testdir.makefile(ext=".log", result="")  # Writes result.log
@@ -213,11 +212,11 @@ def test_conftest_existing_resultlog(testdir):
 def test_conftest_existing_junitxml(testdir):
     x = testdir.mkdir("tests")
     x.join("conftest.py").write(
-        _pytest._code.Source(
+        textwrap.dedent(
+            """\
+            def pytest_addoption(parser):
+                parser.addoption("--xyz", action="store_true")
             """
-        def pytest_addoption(parser):
-            parser.addoption("--xyz", action="store_true")
-    """
         )
     )
     testdir.makefile(ext=".xml", junit="")  # Writes junit.xml
@@ -247,38 +246,38 @@ def test_fixture_dependency(testdir, monkeypatch):
     sub = testdir.mkdir("sub")
     sub.join("__init__.py").write("")
     sub.join("conftest.py").write(
-        dedent(
+        textwrap.dedent(
+            """\
+            import pytest
+
+            @pytest.fixture
+            def not_needed():
+                assert False, "Should not be called!"
+
+            @pytest.fixture
+            def foo():
+                assert False, "Should not be called!"
+
+            @pytest.fixture
+            def bar(foo):
+                return 'bar'
             """
-        import pytest
-
-        @pytest.fixture
-        def not_needed():
-            assert False, "Should not be called!"
-
-        @pytest.fixture
-        def foo():
-            assert False, "Should not be called!"
-
-        @pytest.fixture
-        def bar(foo):
-            return 'bar'
-    """
         )
     )
     subsub = sub.mkdir("subsub")
     subsub.join("__init__.py").write("")
     subsub.join("test_bar.py").write(
-        dedent(
+        textwrap.dedent(
+            """\
+            import pytest
+
+            @pytest.fixture
+            def bar():
+                return 'sub bar'
+
+            def test_event_fixture(bar):
+                assert bar == 'sub bar'
             """
-        import pytest
-
-        @pytest.fixture
-        def bar():
-            return 'sub bar'
-
-        def test_event_fixture(bar):
-            assert bar == 'sub bar'
-    """
         )
     )
     result = testdir.runpytest("sub")
@@ -288,11 +287,11 @@ def test_fixture_dependency(testdir, monkeypatch):
 def test_conftest_found_with_double_dash(testdir):
     sub = testdir.mkdir("sub")
     sub.join("conftest.py").write(
-        dedent(
+        textwrap.dedent(
+            """\
+            def pytest_addoption(parser):
+                parser.addoption("--hello-world", action="store_true")
             """
-        def pytest_addoption(parser):
-            parser.addoption("--hello-world", action="store_true")
-    """
         )
     )
     p = sub.join("test_hello.py")
@@ -313,56 +312,54 @@ class TestConftestVisibility(object):
         package = testdir.mkdir("package")
 
         package.join("conftest.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
-            import pytest
+                import pytest
-            @pytest.fixture
+                @pytest.fixture
-            def fxtr():
+                def fxtr():
-                return "from-package"
+                    return "from-package"
-        """
+                """
             )
         )
         package.join("test_pkgroot.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
-            def test_pkgroot(fxtr):
+                def test_pkgroot(fxtr):
-                assert fxtr == "from-package"
+                    assert fxtr == "from-package"
-        """
+                """
             )
         )
 
         swc = package.mkdir("swc")
         swc.join("__init__.py").ensure()
         swc.join("conftest.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
-            import pytest
+                import pytest
-            @pytest.fixture
+                @pytest.fixture
-            def fxtr():
+                def fxtr():
-                return "from-swc"
+                    return "from-swc"
-        """
+                """
             )
         )
         swc.join("test_with_conftest.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
-            def test_with_conftest(fxtr):
+                def test_with_conftest(fxtr):
-                assert fxtr == "from-swc"
+                    assert fxtr == "from-swc"
-
+                """
-        """
             )
         )
 
         snc = package.mkdir("snc")
         snc.join("__init__.py").ensure()
         snc.join("test_no_conftest.py").write(
-            dedent(
+            textwrap.dedent(
                 """\
-            def test_no_conftest(fxtr):
+                def test_no_conftest(fxtr):
-                assert fxtr == "from-package"   # No local conftest.py, so should
+                    assert fxtr == "from-package"   # No local conftest.py, so should
-                                                # use value from parent dir's
+                                                    # use value from parent dir's
-
+                """
-        """
             )
         )
         print("created directory structure:")
@@ -422,31 +419,31 @@ def test_search_conftest_up_to_inifile(testdir, confcutdir, passed, error):
     src = root.join("src").ensure(dir=1)
     src.join("pytest.ini").write("[pytest]")
     src.join("conftest.py").write(
-        _pytest._code.Source(
+        textwrap.dedent(
+            """\
+            import pytest
+            @pytest.fixture
+            def fix1(): pass
             """
-        import pytest
-        @pytest.fixture
-        def fix1(): pass
-    """
         )
     )
     src.join("test_foo.py").write(
-        _pytest._code.Source(
+        textwrap.dedent(
+            """\
+            def test_1(fix1):
+                pass
+            def test_2(out_of_reach):
+                pass
             """
-        def test_1(fix1):
-            pass
-        def test_2(out_of_reach):
-            pass
-    """
         )
     )
     root.join("conftest.py").write(
-        _pytest._code.Source(
+        textwrap.dedent(
+            """\
+            import pytest
+            @pytest.fixture
+            def out_of_reach(): pass
             """
-        import pytest
-        @pytest.fixture
-        def out_of_reach(): pass
-    """
         )
     )
 
@@ -464,19 +461,19 @@ def test_search_conftest_up_to_inifile(testdir, confcutdir, passed, error):
 
 def test_issue1073_conftest_special_objects(testdir):
     testdir.makeconftest(
-        """
+        """\
         class DontTouchMe(object):
             def __getattr__(self, x):
                 raise Exception('cant touch me')
 
         x = DontTouchMe()
-    """
+        """
     )
     testdir.makepyfile(
-        """
+        """\
         def test_some():
             pass
-    """
+        """
     )
     res = testdir.runpytest()
     assert res.ret == 0
@@ -484,15 +481,15 @@ def test_issue1073_conftest_special_objects(testdir):
 
 def test_conftest_exception_handling(testdir):
     testdir.makeconftest(
-        """
+        """\
         raise ValueError()
-    """
+        """
     )
     testdir.makepyfile(
-        """
+        """\
         def test_some():
             pass
-    """
+        """
     )
     res = testdir.runpytest()
     assert res.ret == 4
@@ -507,7 +504,7 @@ def test_hook_proxy(testdir):
         **{
             "root/demo-0/test_foo1.py": "def test1(): pass",
             "root/demo-a/test_foo2.py": "def test1(): pass",
-            "root/demo-a/conftest.py": """
+            "root/demo-a/conftest.py": """\
             def pytest_ignore_collect(path, config):
                 return True
             """,
@@ -525,11 +522,11 @@ def test_required_option_help(testdir):
     testdir.makeconftest("assert 0")
     x = testdir.mkdir("x")
     x.join("conftest.py").write(
-        _pytest._code.Source(
+        textwrap.dedent(
+            """\
+            def pytest_addoption(parser):
+                parser.addoption("--xyz", action="store_true", required=True)
             """
-        def pytest_addoption(parser):
-            parser.addoption("--xyz", action="store_true", required=True)
-    """
         )
     )
     result = testdir.runpytest("-h", x)

testing/test_doctest.py

@@ -1,7 +1,7 @@
 # encoding: utf-8
 from __future__ import absolute_import, division, print_function
 import sys
-import _pytest._code
+import textwrap
 from _pytest.compat import MODULE_NOT_FOUND_ERROR
 from _pytest.doctest import DoctestItem, DoctestModule, DoctestTextfile
 import pytest
@@ -258,16 +258,16 @@ class TestDoctests(object):
 
     def test_doctest_linedata_missing(self, testdir):
         testdir.tmpdir.join("hello.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                class Fun(object):
+                    @property
+                    def test(self):
+                        '''
+                        >>> a = 1
+                        >>> 1/0
+                        '''
                 """
-            class Fun(object):
-                @property
-                def test(self):
-                    '''
-                    >>> a = 1
-                    >>> 1/0
-                    '''
-            """
             )
         )
         result = testdir.runpytest("--doctest-modules")
@@ -300,10 +300,10 @@ class TestDoctests(object):
 
     def test_doctest_unex_importerror_with_module(self, testdir):
         testdir.tmpdir.join("hello.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                import asdalsdkjaslkdjasd
                 """
-            import asdalsdkjaslkdjasd
-        """
             )
         )
         testdir.maketxtfile(
@@ -339,27 +339,27 @@ class TestDoctests(object):
     def test_doctestmodule_external_and_issue116(self, testdir):
         p = testdir.mkpydir("hello")
         p.join("__init__.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                def somefunc():
+                    '''
+                        >>> i = 0
+                        >>> i + 1
+                        2
+                    '''
                 """
-            def somefunc():
-                '''
-                    >>> i = 0
-                    >>> i + 1
-                    2
-                '''
-        """
             )
         )
         result = testdir.runpytest(p, "--doctest-modules")
         result.stdout.fnmatch_lines(
             [
-                "004 *>>> i = 0",
+                "003 *>>> i = 0",
-                "005 *>>> i + 1",
+                "004 *>>> i + 1",
                 "*Expected:",
                 "*    2",
                 "*Got:",
                 "*    1",
-                "*:5: DocTestFailure",
+                "*:4: DocTestFailure",
             ]
         )
 

testing/test_terminal.py

@@ -4,9 +4,9 @@ terminal reporting of the full testing process.
 from __future__ import absolute_import, division, print_function
 import collections
 import sys
+import textwrap
 
 import pluggy
-import _pytest._code
 import py
 import pytest
 from _pytest.main import EXIT_NOTESTSCOLLECTED
@@ -161,12 +161,12 @@ class TestTerminal(object):
     def test_itemreport_directclasses_not_shown_as_subclasses(self, testdir):
         a = testdir.mkpydir("a123")
         a.join("test_hello123.py").write(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                class TestClass(object):
+                    def test_method(self):
+                        pass
                 """
-            class TestClass(object):
-                def test_method(self):
-                    pass
-        """
             )
         )
         result = testdir.runpytest("-v")
@@ -312,13 +312,13 @@ class TestCollectonly(object):
         result = testdir.runpytest("--collect-only", p)
         assert result.ret == 2
         result.stdout.fnmatch_lines(
-            _pytest._code.Source(
+            textwrap.dedent(
+                """\
+                *ERROR*
+                *ImportError*
+                *No module named *Errlk*
+                *1 error*
                 """
-            *ERROR*
-            *ImportError*
-            *No module named *Errlk*
-            *1 error*
-        """
             ).strip()
         )