Various fixes for tests in IPython.testing.

IPython/testing/plugin/dtexample.py

@@ -1,162 +1,164 b''
 """Simple example using doctests.
 
 This file just contains doctests both using plain python and IPython prompts.
 All tests should be loaded by nose.
 """
+from IPython.utils.py3compat import doctest_refactor_print
 
 def pyfunc():
     """Some pure python tests...
 
     >>> pyfunc()
     'pyfunc'
 
     >>> import os
 
     >>> 2+3
     5
 
     >>> for i in range(3):
     ...     print i,
     ...     print i+1,
     ...
     0 1 1 2 2 3
     """
     return 'pyfunc'
 
-
+@doctest_refactor_print
 def ipfunc():
     """Some ipython tests...
 
     In [1]: import os
 
     In [3]: 2+3
     Out[3]: 5
 
     In [26]: for i in range(3):
        ....:     print i,
        ....:     print i+1,
        ....:
     0 1 1 2 2 3
 
 
     Examples that access the operating system work:
 
     In [1]: !echo hello
     hello
 
     In [2]: !echo hello > /tmp/foo
 
     In [3]: !cat /tmp/foo
     hello
 
     In [4]: rm -f /tmp/foo
 
     It's OK to use '_' for the last result, but do NOT try to use IPython's
     numbered history of _NN outputs, since those won't exist under the
     doctest environment:
 
     In [7]: 'hi'
     Out[7]: 'hi'
 
     In [8]: print repr(_)
     'hi'
     
     In [7]: 3+4
     Out[7]: 7
 
     In [8]: _+3
     Out[8]: 10
 
     In [9]: ipfunc()
     Out[9]: 'ipfunc'
     """
     return 'ipfunc'
 
 
 def ranfunc():
     """A function with some random output.
 
        Normal examples are verified as usual:
        >>> 1+3
        4
 
        But if you put '# random' in the output, it is ignored:
        >>> 1+3
        junk goes here...  # random
 
        >>> 1+2
        again,  anything goes #random
        if multiline, the random mark is only needed once.
 
        >>> 1+2
        You can also put the random marker at the end:
        # random
 
        >>> 1+2
        # random
        .. or at the beginning.
 
        More correct input is properly verified:
        >>> ranfunc()
        'ranfunc'
     """
     return 'ranfunc'
 
 
 def random_all():
     """A function where we ignore the output of ALL examples.
 
     Examples:
 
       # all-random
 
       This mark tells the testing machinery that all subsequent examples should
       be treated as random (ignoring their output).  They are still executed,
       so if a they raise an error, it will be detected as such, but their
       output is completely ignored.
 
       >>> 1+3
       junk goes here...
 
       >>> 1+3
       klasdfj;
 
       >>> 1+2
       again,  anything goes
       blah...
     """
     pass
 
-
+@doctest_refactor_print
 def iprand():
     """Some ipython tests with random output.
 
     In [7]: 3+4
     Out[7]: 7
 
     In [8]: print 'hello'
     world  # random
 
     In [9]: iprand()
     Out[9]: 'iprand'
     """
     return 'iprand'
 
-
+@doctest_refactor_print
 def iprand_all():
     """Some ipython tests with fully random output.
 
     # all-random
     
     In [7]: 1
     Out[7]: 99
 
     In [8]: print 'hello'
     world
 
     In [9]: iprand_all()
     Out[9]: 'junk'
     """
     return 'iprand_all'
 
 
+    

IPython/testing/plugin/test_ipdoctest.py

@@ -1,75 +1,80 b''
 """Tests for the ipdoctest machinery itself.
 
 Note: in a file named test_X, functions whose only test is their docstring (as
 a doctest) and which have no test functionality of their own, should be called
 'doctest_foo' instead of 'test_foo', otherwise they get double-counted (the
 empty function call is counted as a test, which just inflates tests numbers
 artificially).
 """
+from IPython.utils.py3compat import doctest_refactor_print
 
+@doctest_refactor_print
 def doctest_simple():
     """ipdoctest must handle simple inputs
     
     In [1]: 1
     Out[1]: 1
 
     In [2]: print 1
     1
     """
 
-
+@doctest_refactor_print
 def doctest_multiline1():
     """The ipdoctest machinery must handle multiline examples gracefully.
 
-    In [2]: for i in range(10):
-       ...:     print i,
+    In [2]: for i in range(4):
+       ...:     print i
        ...:      
-    0 1 2 3 4 5 6 7 8 9
+    0
+    1
+    2
+    3
     """
 
-    
+@doctest_refactor_print
 def doctest_multiline2():
     """Multiline examples that define functions and print output.
 
     In [7]: def f(x):
        ...:     return x+1
        ...: 
 
     In [8]: f(1)
     Out[8]: 2
 
     In [9]: def g(x):
        ...:     print 'x is:',x
        ...:      
 
     In [10]: g(1)
     x is: 1
 
     In [11]: g('hello')
     x is: hello
     """
 
 
 def doctest_multiline3():
     """Multiline examples with blank lines.
 
     In [12]: def h(x):
        ....:     if x>1:
        ....:         return x**2
        ....:     # To leave a blank line in the input, you must mark it
        ....:     # with a comment character:
        ....:     #
        ....:     # otherwise the doctest parser gets confused.
        ....:     else:
        ....:         return -1
        ....:      
 
     In [13]: h(5)
     Out[13]: 25
 
     In [14]: h(1)
     Out[14]: -1
 
     In [15]: h(0)
     Out[15]: -1
    """

IPython/testing/plugin/test_refs.py

@@ -1,46 +1,46 b''
 """Some simple tests for the plugin while running scripts.
 """
 # Module imports
 # Std lib
 import inspect
 
 # Our own
 
 #-----------------------------------------------------------------------------
 # Testing functions
 
 def test_trivial():
     """A trivial passing test."""
     pass
 
 def doctest_run():
     """Test running a trivial script.
 
     In [13]: run simplevars.py
     x is: 1
     """
     
 def doctest_runvars():
     """Test that variables defined in scripts get loaded correcly via %run.
 
     In [13]: run simplevars.py
     x is: 1
 
     In [14]: x
     Out[14]: 1
     """
 
 def doctest_ivars():
     """Test that variables defined interactively are picked up.
     In [5]: zz=1
 
     In [6]: zz
     Out[6]: 1
     """
 
 def doctest_refs():
     """DocTest reference holding issues when running scripts.
 
     In [32]: run show_refs.py
-    c referrers: [<type 'dict'>]
+    c referrers: [<... 'dict'>]
     """

IPython/testing/tests/test_ipunittest.py

@@ -1,122 +1,137 b''
 """Tests for IPython's test support utilities.
 
 These are decorators that allow standalone functions and docstrings to be seen
 as tests by unittest, replicating some of nose's functionality.  Additionally,
 IPython-syntax docstrings can be auto-converted to '>>>' so that ipython
 sessions can be copy-pasted as tests.
 
 This file can be run as a script, and it will call unittest.main().  We must
 check that it works with unittest as well as with nose...
 
 
 Notes:
 
 - Using nosetests --with-doctest --doctest-tests testfile.py
   will find docstrings as tests wherever they are, even in methods.  But
   if we use ipython syntax in the docstrings, they must be decorated with
   @ipdocstring.  This is OK for test-only code, but not for user-facing
   docstrings where we want to keep the ipython syntax.
 
 - Using nosetests --with-doctest file.py
   also finds doctests if the file name doesn't have 'test' in it, because it is
   treated like a normal module.  But if nose treats the file like a test file,
   then for normal classes to be doctested the extra --doctest-tests is
   necessary.
 
 - running this script with python (it has a __main__ section at the end) misses
   one docstring test, the one embedded in the Foo object method.  Since our
   approach relies on using decorators that create standalone TestCase
   instances, it can only be used for functions, not for methods of objects.
 Authors
 -------
 
 - Fernando Perez <[e-mail]>
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2009  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from IPython.testing.ipunittest import ipdoctest, ipdocstring
+from IPython.utils.py3compat import doctest_refactor_print
 
 #-----------------------------------------------------------------------------
 # Test classes and functions
 #-----------------------------------------------------------------------------
 @ipdoctest
+@doctest_refactor_print
 def simple_dt():
     """
     >>> print 1+1
     2
     """
 
 
 @ipdoctest
+@doctest_refactor_print
 def ipdt_flush():
     """
 In [20]: print 1
 1
 
-In [26]: for i in range(10):
-   ....:     print i,
+In [26]: for i in range(4):
+   ....:     print i
    ....:     
    ....: 
-0 1 2 3 4 5 6 7 8 9
+0
+1
+2
+3
 
 In [27]: 3+4
 Out[27]: 7
 """
 
 
 @ipdoctest
+@doctest_refactor_print
 def ipdt_indented_test():
     """
     In [20]: print 1
     1
 
-    In [26]: for i in range(10):
-       ....:     print i,
+    In [26]: for i in range(4):
+       ....:     print i
        ....:     
        ....: 
-    0 1 2 3 4 5 6 7 8 9
+    0
+    1
+    2
+    3
 
     In [27]: 3+4
     Out[27]: 7
     """
 
 
 class Foo(object):
     """For methods, the normal decorator doesn't work.
 
     But rewriting the docstring with ip2py does, *but only if using nose
     --with-doctest*.  Do we want to have that as a dependency?
     """
 
     @ipdocstring
+    @doctest_refactor_print
     def ipdt_method(self):
         """
         In [20]: print 1
         1
 
-        In [26]: for i in range(10):
-           ....:     print i,
+        In [26]: for i in range(4):
+           ....:     print i
            ....:     
            ....: 
-        0 1 2 3 4 5 6 7 8 9
+        0
+        1
+        2
+        3
 
         In [27]: 3+4
         Out[27]: 7
         """
 
+    @doctest_refactor_print
     def normaldt_method(self):
         """
         >>> print 1+1
         2
         """