Index: Lib/doctest.py =================================================================== --- Lib/doctest.py (revision 83044) +++ Lib/doctest.py (working copy) @@ -207,6 +207,7 @@ raise TypeError("Expected a module, string, or None") def _load_testfile(filename, package, module_relative): + file_contents = None if module_relative: package = _normalize_module(package, 3) filename = _module_relative_path(package, filename) @@ -214,9 +215,18 @@ if hasattr(package.__loader__, 'get_data'): file_contents = package.__loader__.get_data(filename) # get_data() opens files as 'rb', so one must do the equivalent - # conversion as universal newlines would do. - return file_contents.replace(os.linesep, '\n'), filename - return open(filename).read(), filename + # conversion as universal newlines would do -- see below. + if file_contents is None: + f = open(filename, 'rU') # we hope universal newline support is enabled + file_contents = f.read() + if hasattr(f, 'newlines'): + # Universal newlines are enabled, we're OK + return file_contents, filename + # If we get here, we need to do the universal newline conversion ourselves; + # we have two possible cases and we need to do them in the right order + for linesep in ('\r\n', '\r'): + file_contents = file_contents.replace(linesep, '\n') + return file_contents, filename # Use sys.stdout encoding for ouput. _encoding = getattr(sys.__stdout__, 'encoding', None) or 'utf-8' Index: Lib/test/test_doctest.py =================================================================== --- Lib/test/test_doctest.py (revision 83044) +++ Lib/test/test_doctest.py (working copy) @@ -2398,6 +2398,13 @@ >>> doctest._encoding = saved_encoding >>> doctest.master = None # Reset master. >>> sys.argv = save_argv + +We use a helper script to test for correct newline handling in +the _load_testfile function: + + >>> from test import doctest_testfile + >>> doctest_testfile.run() + >>> doctest.master = None # Reset master. """ # old_test1, ... used to live in doctest.py, but cluttered it. Note Index: Lib/test/doctest_testfile.py =================================================================== --- Lib/test/doctest_testfile.py (revision 0) +++ Lib/test/doctest_testfile.py (revision 0) @@ -0,0 +1,132 @@ +""" +Test script to exercise all code paths of +_load_testfile in doctest.py + +To be called from test_doctest.py +""" + +import sys +import os +import doctest +import tempfile +from test import test_importhooks + +testpkgname = 'doctest_testfile_test' +hookpkgname = 'hooktestpackage' + +# This ensures we have our own unique tmp directory for testing +rootdir = tempfile.mkdtemp() + +testpkgdir = os.path.join(rootdir, testpkgname) +txtfile = "doctest_testfile.txt" +initpypath = os.path.join(testpkgdir, "__init__.py") +initpycpath = os.path.join(testpkgdir, "__init__.pyc") +txtpath = os.path.join(testpkgdir, txtfile) + +# XXX (pdonis) Note: to set up this test, we are creating a +# fake package in a temporary directory and writing a txt file +# into it to be used as a doctest. We do this because the txt +# file needs to have intentionally mismatched newlines, and if +# we stored the file permanently in the Python distribution, +# there could be issues with making sure it is reproduced +# correctly across repository checkouts/commits, etc. Since the +# exact byte by byte content of the file is critical for this +# test, it's safer to just generate the temporary txt file so +# we can control its exact contents. + +def create_temp_files(): + # Create the testing directory + os.mkdir(testpkgdir, 0700) + # Write txt file with intentionally mismatched newlines + txtfile_contents = ''.join([ + '>>> print "Unix newlines OK."\n', + 'Unix newlines OK.\n', + '>>> print "Windows newlines OK."\r\n', + 'Windows newlines OK.\r\n', + '>>> print "Mac newlines OK."\r', + 'Mac newlines OK.\r' + ]) + with open(txtpath, 'wb') as f: + f.write(txtfile_contents) + # Make the testing directory importable as a package + # (must contain __init__.py and its parent must be on sys.path) + with open(initpypath, 'w'): + pass # creates a 0-byte file + sys.path.append(rootdir) + +def cleanup_temp_files(): + sys.path.remove(rootdir) + os.remove(txtpath) + os.remove(initpypath) + os.remove(initpycpath) # don't forget this, it was created during the test! + os.rmdir(testpkgdir) + os.rmdir(rootdir) + +# Helper classes for the package loader test, code cribbed +# shamelessly from test_importhooks +class PackageLoaderTestImporter(test_importhooks.PathImporter): + def __init__(self, path=''): + self.path = path + def get_data(self, path): + return open(os.path.join(self.path, path), 'rb').read() + +class InstallHook: + def __init__(self, pkgname): + self.pkgname = pkgname + self.path = sys.path[:] + self.meta_path = sys.meta_path[:] + self.path_hooks = sys.path_hooks[:] + sys.path_importer_cache.clear() + self.modules_before = sys.modules.copy() + self.importer = PackageLoaderTestImporter(path=testpkgdir) + sys.meta_path.append(self.importer) + + def remove(self): + sys.path[:] = self.path + sys.meta_path[:] = self.meta_path + sys.path_hooks[:] = self.path_hooks + sys.path_importer_cache.clear() + sys.modules.clear() + sys.modules.update(self.modules_before) + del self.importer + +def run(): + # Set up the test environment + create_temp_files() + + # If there are any exceptions during testing, we want to + # make sure we clean up + try: + # XXX (pdonis) Technically we should include a test + # with no package argument to doctest.testfile, but: + # (1) The code path is the same for no package as for + # a package with no __loader__, so we aren't giving + # up any coverage as long as that remains true; + # (2) With no package, we can't control what directory + # doctest.testfile will look in for the file (at + # least, I can't see how to do it without major + # hackery to fool doctest's internal routines), + # so we can't depend on writing a temporary txt + # file to use as our doctest (see comments above + # for why we want to do the test that way). + + # First try a package with no __loader___ + doctest.testfile(txtfile, package=testpkgname) + doctest.master = None + + # Now try a package with a __loader___.get_data method + hook = InstallHook(hookpkgname) + doctest.testfile(txtfile, package=hookpkgname) + hook.remove() + del hook + doctest.master = None + + # Finally, try loading with module_relative=False + doctest.testfile(txtpath, module_relative=False) + + finally: + # Clean up + cleanup_temp_files() + +if __name__ == '__main__': + run()