Move some tests into function docstrings.

runtests.py

@@ -433,6 +433,7 @@ is_private_field = re.compile('^_[^_]').match
 
 class _FakeClass(object):
     def __init__(self, **kwargs):
+        self.shortDescription = lambda x: kwargs.get('module_name')
         self.__dict__.update(kwargs)
 
 try: # Py2.7+ and Py3.2+

tests/run/addloop.pyx

@@ -5,27 +5,33 @@ __doc__ = u"""
     >>> x
     46
 
-    >>> add_pyrange(10)
-    46
-    >>> add_py(10)
-    46
-    >>> add_c(10)
-    46
 """
 
 def add_pyrange(max):
+    """
+    >>> add_pyrange(10)
+    46
+    """
     x = 1
     for i in range(max):
         x = x + i
     return x
 
 def add_py(max):
+    """
+    >>> add_py(10)
+    46
+    """
     x = 1
     for i from 0 <= i < max:
         x = x + i
     return x
 
 def add_c(max):
+    """
+    >>> add_c(10)
+    46
+    """
     cdef int x,i
     x = 1
     for i from 0 <= i < max:

tests/run/addop.pyx

-__doc__ = u"""
+def f():
+    """
     >>> f()
     (30, 22)
-"""
-
-def f():
+    """
     cdef int int1, int2, int3
     cdef char *ptr1, *ptr2 = "test", *ptr3 = "toast"
     int2 = 10

tests/run/addressof.pyx

-__doc__ = u"""
+def f(int a):
+    """
     >>> f(5)
     5
-"""
-
-def f(int a):
+    """
     cdef int i,j
     cdef int *p
     i = a

tests/run/always_allow_keywords_T295.pyx

-__doc__ = u"""
->>> func1(None)
->>> func1(*[None])
->>> func1(arg=None)
-Traceback (most recent call last):
-...
-TypeError: func1() takes no keyword arguments
->>> func2(None)
->>> func2(*[None])
->>> func2(arg=None)
-Traceback (most recent call last):
-...
-TypeError: func2() takes no keyword arguments
->>> func3(None)
->>> func3(*[None])
->>> func3(arg=None)
-
->>> A().meth1(None)
->>> A().meth1(*[None])
->>> A().meth1(arg=None)
-Traceback (most recent call last):
-...
-TypeError: meth1() takes no keyword arguments
->>> A().meth2(None)
->>> A().meth2(*[None])
->>> A().meth2(arg=None)
-Traceback (most recent call last):
-...
-TypeError: meth2() takes no keyword arguments
->>> A().meth3(None)
->>> A().meth3(*[None])
->>> A().meth3(arg=None)
-"""
-
 cimport cython
 
 
 def func1(arg):
+    """
+    >>> func1(None)
+    >>> func1(*[None])
+    >>> func1(arg=None)
+    Traceback (most recent call last):
+    ...
+    TypeError: func1() takes no keyword arguments
+    """
     pass
 
 @cython.always_allow_keywords(False)
 def func2(arg):
+    """
+    >>> func2(None)
+    >>> func2(*[None])
+    >>> func2(arg=None)
+    Traceback (most recent call last):
+    ...
+    TypeError: func2() takes no keyword arguments
+    """
     pass
 
 @cython.always_allow_keywords(True)
 def func3(arg):
+    """
+    >>> func3(None)
+    >>> func3(*[None])
+    >>> func3(arg=None)
+    """
     pass
 
 cdef class A:
+    """
+    >>> A().meth1(None)
+    >>> A().meth1(*[None])
+    >>> A().meth1(arg=None)
+    Traceback (most recent call last):
+    ...
+    TypeError: meth1() takes no keyword arguments
+    >>> A().meth2(None)
+    >>> A().meth2(*[None])
+    >>> A().meth2(arg=None)
+    Traceback (most recent call last):
+    ...
+    TypeError: meth2() takes no keyword arguments
+    >>> A().meth3(None)
+    >>> A().meth3(*[None])
+    >>> A().meth3(arg=None)
+    """
 
     def meth1(self, arg):
         pass

tests/run/and.pyx

-__doc__ = u"""
->>> a,b = 'a *','b *' # use non-interned strings
-
->>> and2_assign(2,3) == (2 and 3)
-True
->>> and2_assign('a', 'b') == ('a' and 'b')
-True
->>> and2_assign(a, b) == (a and b)
-True
-
->>> and2(2,3) == (2 and 3)
-True
->>> and2(0,2) == (0 and 2)
-True
->>> and2('a', 'b') == ('a' and 'b')
-True
->>> and2(a, b) == (a and b)
-True
->>> and2('', 'b') == ('' and 'b')
-True
->>> and2([], [1]) == ([] and [1])
-True
->>> and2([], [a]) == ([] and [a])
-True
-
->>> and3(0,1,2) == (0 and 1 and 2)
-True
->>> and3([],(),[1]) == ([] and () and [1])
-True
-
->>> and2_no_result(2,3)
->>> and2_no_result(0,2)
->>> and2_no_result('a','b')
->>> and2_no_result(a,b)
->>> a and b
-'b *'
-"""
+a,b = 'a *','b *' # use non-interned strings
 
 def and2_assign(a,b):
+    """
+    >>> a,b = 'a *','b *' # use non-interned strings
+    >>> and2_assign(2,3) == (2 and 3)
+    True
+    >>> and2_assign('a', 'b') == ('a' and 'b')
+    True
+    >>> and2_assign(a, b) == (a and b)
+    True
+    """
     c = a and b
     return c
 
 def and2(a,b):
+    """
+    >>> and2(2,3) == (2 and 3)
+    True
+    >>> and2(0,2) == (0 and 2)
+    True
+    >>> and2('a', 'b') == ('a' and 'b')
+    True
+    >>> and2(a, b) == (a and b)
+    True
+    >>> and2('', 'b') == ('' and 'b')
+    True
+    >>> and2([], [1]) == ([] and [1])
+    True
+    >>> and2([], [a]) == ([] and [a])
+    True
+    """
     return a and b
 
 def and3(a,b,c):
+    """
+    >>> and3(0,1,2) == (0 and 1 and 2)
+    True
+    >>> and3([],(),[1]) == ([] and () and [1])
+    True
+    """
     d = a and b and c
     return d
 
 def and2_no_result(a,b):
+    """
+    >>> and2_no_result(2,3)
+    >>> and2_no_result(0,2)
+    >>> and2_no_result('a','b')
+    >>> and2_no_result(a,b)
+    >>> a and b
+    'b *'
+    """
     a and b

tests/run/append.pyx

-__doc__ = u"""
->>> test_append([])
-None
-None
-None
-got error
-[1, 2, (3, 4)]
->>> _ = test_append(A())
-appending
-1
-appending
-2
-appending
-(3, 4)
-got error
->>> test_append(B())
-None
-None
-None
-None
-[1, 2, (3, 4), 5, 6]
-"""
-
 class A:
     def append(self, x):
         print u"appending"
@@ -32,6 +9,28 @@ class B(list):
             list.append(self, arg)
 
 def test_append(L):
+    """
+    >>> test_append([])
+    None
+    None
+    None
+    got error
+    [1, 2, (3, 4)]
+    >>> _ = test_append(A())
+    appending
+    1
+    appending
+    2
+    appending
+    (3, 4)
+    got error
+    >>> test_append(B())
+    None
+    None
+    None
+    None
+    [1, 2, (3, 4), 5, 6]
+    """
     print L.append(1)
     print L.append(2)
     print L.append((3,4))
@@ -40,4 +39,3 @@ def test_append(L):
     except TypeError:
         print u"got error"
     return L
-

tests/run/argdefault.pyx

-__doc__ = u"""
->>> f0()
-(1, 2)
->>> g0()
-(1, 2)
-
->>> f1()
-[1, 2]
->>> g1()
-[1, 2]
-
->>> f2()
-{1: 2}
->>> g2()
-{1: 2}
-
->>> f3() #doctest: +ELLIPSIS
-<argdefault.Foo object at ...>
->>> g3() #doctest: +ELLIPSIS
-<argdefault.Foo object at ...>
-
->>> f4() #doctest: +ELLIPSIS
-<argdefault.Bar object at ...>
->>> g4() #doctest: +ELLIPSIS
-<argdefault.Bar object at ...>
-
->>> f5() #doctest: +ELLIPSIS
-<argdefault.Bla object at ...>
->>> g5() #doctest: +ELLIPSIS
-<argdefault.Bla object at ...>
-
->>> f6()
-7
->>> g6()
-7
-"""
-
 GLB0 = (1, 2)
 def f0(arg=GLB0):
+    """
+    >>> f0()
+    (1, 2)
+    """
     return arg
 def g0(arg=(1, 2)):
+    """
+    >>> g0()
+    (1, 2)
+    """
     return arg
 
 
 GLB1 = [1, 2]
 def f1(arg=GLB1):
+    """
+    >>> f1()
+    [1, 2]
+    """
     return arg
 def g1(arg=[1, 2]):
+    """
+    >>> g1()
+    [1, 2]
+    """
     return arg
 
 
 cdef GLB2 = {1: 2}
 def f2(arg=GLB2):
+    """
+    >>> f2()
+    {1: 2}
+    """
     return arg
 def g2(arg={1: 2}):
+    """
+    >>> g2()
+    {1: 2}
+    """
     return arg
 
 
@@ -60,8 +47,16 @@ class Foo(object):
     pass
 cdef GLB3 = Foo()
 def f3(arg=GLB3):
+    """
+    >>> f3() #doctest: +ELLIPSIS
+    <argdefault.Foo object at ...>
+    """
     return arg
 def g3(arg=Foo()):
+    """
+    >>> g3() #doctest: +ELLIPSIS
+    <argdefault.Foo object at ...>
+    """
     return arg
 
 
@@ -69,8 +64,16 @@ cdef class Bar:
     pass
 cdef Bar GLB4 = Bar()
 def f4(arg=GLB4):
+    """
+    >>> f4() #doctest: +ELLIPSIS
+    <argdefault.Bar object at ...>
+    """
     return arg
 def g4(arg=Bar()):
+    """
+    >>> g4() #doctest: +ELLIPSIS
+    <argdefault.Bar object at ...>
+    """
     return arg
 
 
@@ -78,13 +81,29 @@ cdef class Bla:
     pass
 cdef Bla GLB5 = Bla()
 def f5(Bla arg=GLB5):
+    """
+    >>> f5() #doctest: +ELLIPSIS
+    <argdefault.Bla object at ...>
+    """
     return arg
 def g5(Bla arg=Bla()):
+    """
+    >>> g5() #doctest: +ELLIPSIS
+    <argdefault.Bla object at ...>
+    """
     return arg
 
 
 cdef int GLB6 = 7
 def f6(int arg=GLB6):
+    """
+    >>> f6()
+    7
+    """
     return arg
 def g6(int arg=7):
+    """
+    >>> g6()
+    7
+    """
     return arg

tests/run/arrayassign.pyx

-__doc__ = u"""
->>> test_literal_list_slice_all()
-(1, 2, 3, 4, 5)
->>> test_literal_list_slice_start()
-(1, 2, 3, 4, 5)
->>> test_literal_list_slice_end()
-(1, 2, 3, 4, 5)
->>> test_literal_list_slice_start_end()
-(1, 2, 3, 4, 5)
-
->>> test_literal_list_slice_start_param(4)
-(1, 2, 3, 4, 5)
->>> test_literal_list_slice_start_param(3)
-Traceback (most recent call last):
-ValueError: Assignment to slice of wrong length, expected 5, got 6
->>> test_literal_list_slice_start_param(5)
-Traceback (most recent call last):
-ValueError: Assignment to slice of wrong length, expected 5, got 4
-
->>> test_literal_list_slice_end_param(5)
-(1, 2, 3, 4, 5)
->>> test_literal_list_slice_end_param(4)
-Traceback (most recent call last):
-ValueError: Assignment to slice of wrong length, expected 5, got 4
->>> test_literal_list_slice_end_param(6)
-Traceback (most recent call last):
-ValueError: Assignment to slice of wrong length, expected 5, got 6
-
->>> test_literal_list_slice_start_end_param(2,7)
-(1, 2, 3, 4, 5)
->>> test_literal_list_slice_start_end_param(3,7)
-Traceback (most recent call last):
-ValueError: Assignment to slice of wrong length, expected 5, got 4
->>> test_literal_list_slice_start_end_param(1,7)
-Traceback (most recent call last):
-ValueError: Assignment to slice of wrong length, expected 5, got 6
->>> test_literal_list_slice_start_end_param(2,6)
-Traceback (most recent call last):
-ValueError: Assignment to slice of wrong length, expected 5, got 4
->>> test_literal_list_slice_start_end_param(2,8)
-Traceback (most recent call last):
-ValueError: Assignment to slice of wrong length, expected 5, got 6
->>> test_literal_list_slice_start_end_param(3,6)
-Traceback (most recent call last):
-ValueError: Assignment to slice of wrong length, expected 5, got 3
->>> test_literal_list_slice_start_end_param(1,8)
-Traceback (most recent call last):
-ValueError: Assignment to slice of wrong length, expected 5, got 7
-
->>> test_ptr_literal_list_slice_all()
-(1, 2, 3, 4, 5)
->>> test_ptr_literal_list_slice_start()
-(1, 2, 3, 4, 5)
->>> test_ptr_literal_list_slice_end()
-(1, 2, 3, 4, 5)
-"""
-
 # this doesn't work - it would reassign the array address!
 #
 #def test_literal_list():
@@ -63,54 +6,124 @@ ValueError: Assignment to slice of wrong length, expected 5, got 7
 #    return (a[0], a[1], a[2], a[3], a[4])
 
 def test_literal_list_slice_all():
+    """
+    >>> test_literal_list_slice_all()
+    (1, 2, 3, 4, 5)
+    """
     cdef int a[5] # = [5,4,3,2,1]
     a[:] = [1,2,3,4,5]
     return (a[0], a[1], a[2], a[3], a[4])
 
 def test_literal_list_slice_start():
+    """
+    >>> test_literal_list_slice_start()
+    (1, 2, 3, 4, 5)
+    """
     cdef int a[7] # = [7,6,5,4,3,2,1]
     a[2:] = [1,2,3,4,5]
     return (a[2], a[3], a[4], a[5], a[6])
 
 def test_literal_list_slice_end():
+    """
+    >>> test_literal_list_slice_end()
+    (1, 2, 3, 4, 5)
+    """
     cdef int a[7] # = [7,6,5,4,3,2,1]
     a[:5] = [1,2,3,4,5]
     return (a[0], a[1], a[2], a[3], a[4])
 
 def test_literal_list_slice_start_end():
+    """
+    >>> test_literal_list_slice_start_end()
+    (1, 2, 3, 4, 5)
+    """
     cdef int a[9] # = [9,8,7,6,5,4,3,2,1]
     a[2:7] = [1,2,3,4,5]
     return (a[2], a[3], a[4], a[5], a[6])
 
 def test_literal_list_slice_start_param(s):
+    """
+    >>> test_literal_list_slice_start_param(4)
+    (1, 2, 3, 4, 5)
+    >>> test_literal_list_slice_start_param(3)
+    Traceback (most recent call last):
+    ValueError: Assignment to slice of wrong length, expected 5, got 6
+    >>> test_literal_list_slice_start_param(5)
+    Traceback (most recent call last):
+    ValueError: Assignment to slice of wrong length, expected 5, got 4
+    """
     cdef int a[9] # = [9,8,7,6,5,4,3,2,1]
     a[s:] = [1,2,3,4,5]
     return (a[4], a[5], a[6], a[7], a[8])
 #    return a[s:]
 
 def test_literal_list_slice_end_param(e):
+    """
+    >>> test_literal_list_slice_end_param(5)
+    (1, 2, 3, 4, 5)
+    >>> test_literal_list_slice_end_param(4)
+    Traceback (most recent call last):
+    ValueError: Assignment to slice of wrong length, expected 5, got 4
+    >>> test_literal_list_slice_end_param(6)
+    Traceback (most recent call last):
+    ValueError: Assignment to slice of wrong length, expected 5, got 6
+    """
     cdef int a[9] # = [9,8,7,6,5,4,3,2,1]
     a[:e] = [1,2,3,4,5]
     return (a[0], a[1], a[2], a[3], a[4])
 #    return a[:e]
 
 def test_literal_list_slice_start_end_param(s,e):
+    """
+    >>> test_literal_list_slice_start_end_param(2,7)
+    (1, 2, 3, 4, 5)
+    >>> test_literal_list_slice_start_end_param(3,7)
+    Traceback (most recent call last):
+    ValueError: Assignment to slice of wrong length, expected 5, got 4
+    >>> test_literal_list_slice_start_end_param(1,7)
+    Traceback (most recent call last):
+    ValueError: Assignment to slice of wrong length, expected 5, got 6
+    >>> test_literal_list_slice_start_end_param(2,6)
+    Traceback (most recent call last):
+    ValueError: Assignment to slice of wrong length, expected 5, got 4
+    >>> test_literal_list_slice_start_end_param(2,8)
+    Traceback (most recent call last):
+    ValueError: Assignment to slice of wrong length, expected 5, got 6
+    >>> test_literal_list_slice_start_end_param(3,6)
+    Traceback (most recent call last):
+    ValueError: Assignment to slice of wrong length, expected 5, got 3
+    >>> test_literal_list_slice_start_end_param(1,8)
+    Traceback (most recent call last):
+    ValueError: Assignment to slice of wrong length, expected 5, got 7
+    """
     cdef int a[9] # = [9,8,7,6,5,4,3,2,1]
     a[s:e] = [1,2,3,4,5]
     return (a[2], a[3], a[4], a[5], a[6])
 #    return a[s:e]
 
 def test_ptr_literal_list_slice_all():
+    """
+    >>> test_ptr_literal_list_slice_all()
+    (1, 2, 3, 4, 5)
+    """
     cdef int *a = [6,5,4,3,2]
     a[:] = [1,2,3,4,5]
     return (a[0], a[1], a[2], a[3], a[4])
 
 def test_ptr_literal_list_slice_start():
+    """
+    >>> test_ptr_literal_list_slice_start()
+    (1, 2, 3, 4, 5)
+    """
     cdef int *a = [6,5,4,3,2,1]
     a[1:] = [1,2,3,4,5]
     return (a[1], a[2], a[3], a[4], a[5])
 
 def test_ptr_literal_list_slice_end():
+    """
+    >>> test_ptr_literal_list_slice_end()
+    (1, 2, 3, 4, 5)
+    """
     cdef int *a = [6,5,4,3,2,1]
     a[:5] = [1,2,3,4,5]
     return (a[0], a[1], a[2], a[3], a[4])

tests/run/ass2local.pyx

-__doc__ = u"""
+def f():
+    """
     >>> f()
     42
-"""
-
-def f():
+    """
     a = 42
     return a

tests/run/assert.pyx

-__doc__ = u"""
+def f(a, b, int i):
+    """
     >>> f(1, 2, 1)
     >>> f(0, 2, 1)
     Traceback (most recent call last):
@@ -9,17 +10,16 @@ __doc__ = u"""
     >>> f(1, 2, 0)
     Traceback (most recent call last):
     AssertionError
-
-    >>> g(1, "works")
-    >>> g(0, "fails")
-    Traceback (most recent call last):
-    AssertionError: fails
-"""
-
-def f(a, b, int i):
+    """
     assert a
     assert a+b
     assert i
 
 def g(a, b):
+    """
+    >>> g(1, "works")
+    >>> g(0, "fails")
+    Traceback (most recent call last):
+    AssertionError: fails
+    """
     assert a, b

tests/run/autotestdict.pyx

@@ -109,5 +109,3 @@ cdef class MyCdefClass:
         >>> True
         False
         """
-
-

tests/run/backquote.pyx

-__doc__ = u"""
+def f(obj2):
+    """
     >>> f(20)
     '20'
     >>> f('test')
     "'test'"
-
-    >>> g()
-    '42'
-"""
-
-def f(obj2):
+    """
     obj1 = `obj2`
     return obj1
 
 def g():
+    """
+    >>> g()
+    '42'
+    """
     obj1 = `42`
     return obj1

tests/run/bad_c_struct_T252.pyx

-
 cdef cf(default=None):
     return default
 

tests/run/behnel1.pyx

-__doc__ = u"""
-    >>> viking(5)
-    5
-"""
-
 cdef class Spam:
     cdef eggs(self, a):
         return a
@@ -11,4 +6,8 @@ cdef Spam spam():
     return Spam()
 
 def viking(a):
+    """
+    >>> viking(5)
+    5
+    """
     return spam().eggs(a)

tests/run/big_indices.pyx

-__doc__ = u"""
+def test():
+    """
     >>> test()
     neg False
     pos True
@@ -6,9 +7,7 @@ __doc__ = u"""
     pos
     neg
     pos
-"""
-
-def test():
+    """
     cdef long neg = -1
     cdef unsigned long pos = -2 # will be a large positive number
 
@@ -22,4 +21,3 @@ def test():
 
     print D[neg]
     print D[pos]
-    

tests/run/bint.pyx

-__doc__ = u"""
->>> call_test()
-False
-True
-False
-True
-True
-True
-True
-"""
-
 cdef test(bint value):
     print value
 
 def call_test():
+    """
+    >>> call_test()
+    False
+    True
+    False
+    True
+    True
+    True
+    True
+    """
     test(False)
     test(True)
     test(0)

tests/run/boolop.pyx

-__doc__ = u"""
+def foo(obj1, obj2, obj3, obj4, obj5):
+    """
     >>> foo(True, False, 23, 'test', 1)
     (0.0, 1.0, False, False)
-"""
-
-def foo(obj1, obj2, obj3, obj4, obj5):
+    """
     cdef int bool1, bool2
     cdef float bool3, bool4
     cdef char *ptr1, *ptr2, *ptr0

tests/run/bufaccess.pyx

@@ -1392,4 +1392,3 @@ def buffer_nogil():
     with nogil:
         buf[1] = 10
     return buf[1]
-    

tests/run/builtin_types_none_T166.pyx

@@ -4,11 +4,13 @@ __doc__ = u"""
 Traceback (most recent call last):
 AttributeError: 'NoneType' object has no attribute 'append'
 
->>> append_to_none()
-Traceback (most recent call last):
-AttributeError: 'NoneType' object has no attribute 'append'
 """
 
 def append_to_none():
+    """
+    >>> append_to_none()
+    Traceback (most recent call last):
+    AttributeError: 'NoneType' object has no attribute 'append'
+    """
     cdef list l = None
     l.append(2)

tests/run/builtinnames.pyx

-__doc__ = u"""
->>> test_c('abc')
-fileabc
-typeabc
->>> print(test_file_py('abc'))
-abc
->>> print(range('abc'))
-rangeabc
-"""
-
-
 def test_file_py(file):
     assert isinstance(file, (str, unicode)), \
         u"not a string, found '%s' instead" % file.__class__.__name__
@@ -28,5 +17,14 @@ cdef type(arg):
 
 
 def test_c(arg):
+    """
+    >>> test_c('abc')
+    fileabc
+    typeabc
+    >>> print(test_file_py('abc'))
+    abc
+    >>> print(range('abc'))
+    rangeabc
+    """
     print test_file_c(arg)
     print type(arg)

tests/run/call_crash.pyx

-__doc__ = u"""
+cdef class A:
+    """
     >>> A().test(3)
     9
-"""
-
-cdef class A:
+    """
 
     cdef int (*func_ptr)(int)
     

tests/run/callargs.pyx

-__doc__ = u"""
-  >>> test_pos_args(h)
-  1 2 3 * 0 0
-  1 2 9 * 2 0
-  1 2 7 * 2 0
-  9 8 7 * 0 0
-  7 8 9 * 0 0
-
-  >>> test_kw_args(h)
-  1 2 3 * 0 0
-  1 2 9 * 2 1
-  1 2 7 * 2 1
-  1 2 9 * 2 2
-  1 2 9 * 2 2
-  1 2 9 * 2 3
-
-  >>> test_kw_args(e)
-  2 1
-  5 1
-  5 1
-  5 2
-  5 2
-  5 3
-
-  >>> test_kw(e)
-  0 1
-  0 2
-  0 2
-  0 1
-
-  >>> test_kw(g)
-  1
-  2
-  2
-  1
-
-  >>> test_pos_args(f)
-  3
-  5
-  5
-  3
-  3
-
-  >>> test_noargs(e)
-  0 0
-  >>> test_noargs(f)
-  0
-  >>> test_noargs(g)
-  0
-
-  # and some errors:
-
-  >>> test_noargs(h)
-  Traceback (most recent call last):
-  TypeError: h() takes at least 3 positional arguments (0 given)
-
-  >>> h(1,2, d=5)
-  Traceback (most recent call last):
-  TypeError: h() takes at least 3 positional arguments (2 given)
-
-  >>> f(1,2, d=5)
-  Traceback (most recent call last):
-  TypeError: f() got an unexpected keyword argument 'd'
-  >>> f(1, d=5)
-  Traceback (most recent call last):
-  TypeError: f() got an unexpected keyword argument 'd'
-  >>> f(d=5)
-  Traceback (most recent call last):
-  TypeError: f() got an unexpected keyword argument 'd'
-
-  >>> g(1,2, d=5)
-  Traceback (most recent call last):
-  TypeError: g() takes exactly 0 positional arguments (2 given)
-  >>> g(1,2)
-  Traceback (most recent call last):
-  TypeError: g() takes exactly 0 positional arguments (2 given)
-  >>> g(1)
-  Traceback (most recent call last):
-  TypeError: g() takes exactly 0 positional arguments (1 given)
-
-  >>> test_int_kwargs(e)
-  Traceback (most recent call last):
-  TypeError: e() keywords must be strings
-  >>> test_int_kwargs(f)
-  Traceback (most recent call last):
-  TypeError: f() keywords must be strings
-  >>> test_int_kwargs(g)
-  Traceback (most recent call last):
-  TypeError: g() keywords must be strings
-  >>> test_int_kwargs(h)
-  Traceback (most recent call last):
-  TypeError: h() keywords must be strings
-  
-  >>> d()
-  Traceback (most recent call last):
-  TypeError: d() takes at least 1 positional argument (0 given)
-  >>> d(1)
-  1 1 0 0
-  >>> d(1,2)
-  1 2 0 0
-  >>> d(1,2,3)
-  1 2 1 0
-
-  >>> d(key=None)
-  Traceback (most recent call last):
-  TypeError: d() takes at least 1 positional argument (0 given)
-  >>> d(1, key=None)
-  1 1 0 1
-  >>> d(1,2, key=None)
-  1 2 0 1
-  >>> d(1,2,3, key=None)
-  1 2 1 1
-  
-  >>> c()
-  10 20 0
-  >>> c(1)
-  1 20 0
-  >>> c(1,2)
-  1 2 0
-  >>> c(key=None)
-  10 20 1
-  >>> c(1, key=None)
-  1 20 1
-  >>> c(1,2, key=None)
-  1 2 1
-  
-"""
-
 def c(a=10, b=20, **kwds):
+    """
+    >>> c()
+    10 20 0
+    >>> c(1)
+    1 20 0
+    >>> c(1,2)
+    1 2 0
+    >>> c(key=None)
+    10 20 1
+    >>> c(1, key=None)
+    1 20 1
+    >>> c(1,2, key=None)
+    1 2 1
+    """
     print a, b, len(kwds)
 
 def d(a, b=1, *args, **kwds):
+    """
+    >>> d()
+    Traceback (most recent call last):
+    TypeError: d() takes at least 1 positional argument (0 given)
+    >>> d(1)
+    1 1 0 0
+    >>> d(1,2)
+    1 2 0 0
+    >>> d(1,2,3)
+    1 2 1 0
+    >>> d(key=None)
+    Traceback (most recent call last):
+    TypeError: d() takes at least 1 positional argument (0 given)
+    >>> d(1, key=None)
+    1 1 0 1
+    >>> d(1,2, key=None)
+    1 2 0 1
+    >>> d(1,2,3, key=None)
+    1 2 1 1
+    """
     print a, b, len(args), len(kwds)
 
 def e(*args, **kwargs):
     print len(args), len(kwargs)
 
 def f(*args):
+    """
+    >>> f(1,2, d=5)
+    Traceback (most recent call last):
+    TypeError: f() got an unexpected keyword argument 'd'
+    >>> f(1, d=5)
+    Traceback (most recent call last):
+    TypeError: f() got an unexpected keyword argument 'd'
+    >>> f(d=5)
+    Traceback (most recent call last):
+    TypeError: f() got an unexpected keyword argument 'd'
+    """
     print len(args)
 
 def g(**kwargs):
+    """
+    >>> g(1,2, d=5)
+    Traceback (most recent call last):
+    TypeError: g() takes exactly 0 positional arguments (2 given)
+    >>> g(1,2)
+    Traceback (most recent call last):
+    TypeError: g() takes exactly 0 positional arguments (2 given)
+    >>> g(1)
+    Traceback (most recent call last):
+    TypeError: g() takes exactly 0 positional arguments (1 given)
+    """
     print len(kwargs)
 
 def h(a, b, c, *args, **kwargs):
+    """
+    >>> h(1,2, d=5)
+    Traceback (most recent call last):
+    TypeError: h() takes at least 3 positional arguments (2 given)
+    """
     print a, b, c, u'*', len(args), len(kwargs)
     
 args = (9,8,7)
@@ -153,6 +86,22 @@ else:
     kwargs = {"test" : u"toast"}
 
 def test_kw_args(f):
+    """
+    >>> test_kw_args(h)
+    1 2 3 * 0 0
+    1 2 9 * 2 1
+    1 2 7 * 2 1
+    1 2 9 * 2 2
+    1 2 9 * 2 2
+    1 2 9 * 2 3
+    >>> test_kw_args(e)
+    2 1
+    5 1
+    5 1
+    5 2
+    5 2
+    5 3
+    """
     f(1,2, c=3)
     f(1,2, d=3, *args)
     f(1,2, d=3, *(7,8,9))
@@ -161,6 +110,20 @@ def test_kw_args(f):
     f(1,2, d=3, *args, e=5, **kwargs)
 
 def test_pos_args(f):
+    """
+    >>> test_pos_args(h)
+    1 2 3 * 0 0
+    1 2 9 * 2 0
+    1 2 7 * 2 0
+    9 8 7 * 0 0
+    7 8 9 * 0 0
+    >>> test_pos_args(f)
+    3
+    5
+    5
+    3
+    3
+    """
     f(1,2,3)
     f(1,2, *args)
     f(1,2, *(7,8,9))
@@ -168,13 +131,52 @@ def test_pos_args(f):
     f(*(7,8,9))
 
 def test_kw(f):
+    """
+    >>> test_kw(e)
+    0 1
+    0 2
+    0 2
+    0 1
+    >>> test_kw(g)
+    1
+    2
+    2
+    1
+    """
     f(c=3)
     f(d=3, e=5)
     f(d=3, **kwargs)
     f(**kwargs)
 
 def test_noargs(f):
+    """
+    >>> test_noargs(e)
+    0 0
+    >>> test_noargs(f)
+    0
+    >>> test_noargs(g)
+    0
+    
+    # and some errors:
+    >>> test_noargs(h)
+    Traceback (most recent call last):
+    TypeError: h() takes at least 3 positional arguments (0 given)
+    """
     f()
 
 def test_int_kwargs(f):
+    """
+    >>> test_int_kwargs(e)
+    Traceback (most recent call last):
+    TypeError: e() keywords must be strings
+    >>> test_int_kwargs(f)
+    Traceback (most recent call last):
+    TypeError: f() keywords must be strings
+    >>> test_int_kwargs(g)
+    Traceback (most recent call last):
+    TypeError: g() keywords must be strings
+    >>> test_int_kwargs(h)
+    Traceback (most recent call last):
+    TypeError: h() keywords must be strings
+    """
     f(a=1,b=2,c=3, **{10:20,30:40})

tests/run/carrays.pyx

-__doc__ = u"""
->>> test1()
-2
->>> test2()
-0
->>> test3()
-(2, 3)
-"""
-
 def test1():
+    """
+    >>> test1()
+    2
+    """
     cdef int x[2][2]
     x[0][0] = 1
     x[0][1] = 2
@@ -20,6 +15,10 @@ cdef int* f(int x[2][2]):
 
 
 def test2():
+    """
+    >>> test2()
+    0
+    """
     cdef int a1[5]
     cdef int a2[2+3]
     return sizeof(a1) - sizeof(a2)
@@ -29,6 +28,10 @@ cdef enum:
     MY_SIZE_B = 3
 
 def test3():
+    """
+    >>> test3()
+    (2, 3)
+    """
     cdef int a[MY_SIZE_A]
     cdef int b[MY_SIZE_B]
     return sizeof(a)/sizeof(int), sizeof(b)/sizeof(int)

tests/run/cdef_bool_T227.pyx

-__doc__ = u"""
->>> foo(True)
-True
->>> foo(False)
-False
->>> foo('abc') # doctest: +ELLIPSIS
-Traceback (most recent call last):
-TypeError: ...
-
->>> call_cfoo(True)
-True
->>> call_cfoo(False)
-False
->>> call_cfoo('abc') # doctest: +ELLIPSIS
-Traceback (most recent call last):
-TypeError: ...
-"""
-
 def foo(bool a):
+    """
+    >>> foo(True)
+    True
+    >>> foo(False)
+    False
+    >>> foo('abc') # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    TypeError: ...
+    """
     return a == True
 
 def call_cfoo(a):
+    """
+    >>> call_cfoo(True)
+    True
+    >>> call_cfoo(False)
+    False
+    >>> call_cfoo('abc') # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    TypeError: ...
+    """
     return cfoo(a)
 
 cdef cfoo(bool a):

tests/run/cdef_decorator_directives_T183.pyx

-__doc__ = u"""
-    >>> cdiv_decorator(-12, 5)
-    -2
-    >>> pydiv_decorator(-12, 5)
-    -3
-"""
-
 cimport cython
 
 @cython.cdivision(True)
 cpdef cdiv_decorator(int a, int b):
+    """
+    >>> cdiv_decorator(-12, 5)
+    -2
+    """
     return a / b
 
 @cython.cdivision(False)
 cpdef pydiv_decorator(int a, int b):
+    """
+    >>> pydiv_decorator(-12, 5)
+    -3
+    """
     return a / b

tests/run/cdef_opt.pyx

@@ -7,12 +7,6 @@ __doc__ = u"""
     >>> a.foo(10, u'yes')
     (True, u'yes')
 
-    >>> call0()
-    (True, u'yo')
-    >>> call1()
-    (False, u'yo')
-    >>> call2()
-    (False, u'go')
 """
 
 import sys
@@ -25,13 +19,25 @@ cdef class A:
         return a, b
 
 def call0():
+    """
+    >>> call0()
+    (True, u'yo')
+    """
     a = A()
     return a.foo()
 
 def call1():
+    """
+    >>> call1()
+    (False, u'yo')
+    """
     a = A()
     return a.foo(False)
 
 def call2():
+    """
+    >>> call2()
+    (False, u'go')
+    """
     a = A()
     return a.foo(False, u"go")

tests/run/cdef_setitem_T284.pyx

-__doc__ = u'''
->>> no_cdef()
->>> with_cdef()
->>> test_list(list(range(11)), -2, None)
-[0, 1, 2, 3, 4, 5, 6, 7, 8, None, 10]
->>> test_list(list(range(11)), "invalid index", None) #doctest: +ELLIPSIS
-Traceback (most recent call last):
-...
-TypeError: list indices must be integers...
-'''
-
 def no_cdef():
+    """
+    >>> no_cdef()
+    """
     lst = list(range(11))
     ob = 10L
     lst[ob] = -10
@@ -17,6 +9,9 @@ def no_cdef():
     dd[ob] = -10
 
 def with_cdef():
+    """
+    >>> with_cdef()
+    """
     cdef list lst = list(range(11))
     ob = 10L
     lst[ob] = -10
@@ -24,5 +19,13 @@ def with_cdef():
     dd[ob] = -10
 
 def test_list(list L, object i, object a):
+    """
+    >>> test_list(list(range(11)), -2, None)
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, None, 10]
+    >>> test_list(list(range(11)), "invalid index", None) #doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    ...
+    TypeError: list indices must be integers...
+    """
     L[i] = a
     return L

tests/run/cdefassign.pyx

-__doc__ = u"""
-   >>> test(1, 2)
-   4 1 2 2 0 7 8
-"""
-
 cdef int g = 7
 
 def test(x, int y):
+    """
+    >>> test(1, 2)
+    4 1 2 2 0 7 8
+    """
     if True:
         before = 0
     cdef int a = 4, b = x, c = y, *p = &y

tests/run/cdefoptargs.pyx

-__doc__ = u"""
-    >>> call2()
-    >>> call3()
-    >>> call4()
-    >>> test_foo()
-    2
-    3
-    7
-    26
-"""
-
 # the calls:
 
 def call2():
+    """
+    >>> call2()
+    """
     b(1,2)
 
 def call3():
+    """
+    >>> call3()
+    """
     b(1,2,3)
 
 def call4():
+    """
+    >>> call4()
+    """
     b(1,2,3,4)
 
 # the called function:
@@ -30,6 +28,13 @@ cdef int foo(int a, int b=1, int c=1):
     return a+b*c
     
 def test_foo():
+    """
+    >>> test_foo()
+    2
+    3
+    7
+    26
+    """
     print foo(1)
     print foo(1, 2)
     print foo(1, 2, 3)

tests/run/cdivision_CEP_516.pyx

@@ -36,44 +36,6 @@ True
 >>> import warnings
 >>> warnings.showwarning = simple_warn
 
->>> mod_int_c_warn(-17, 10)
-division with oppositely signed operands, C and Python semantics differ
--7
->>> div_int_c_warn(-17, 10)
-division with oppositely signed operands, C and Python semantics differ
--1
->>> complex_expression(-150, 20, 19, -7)
-verbose_call(20)
-division with oppositely signed operands, C and Python semantics differ
-verbose_call(19)
-division with oppositely signed operands, C and Python semantics differ
--2
-
->>> mod_div_zero_int(25, 10, 2)
-verbose_call(5)
-2
->>> print(mod_div_zero_int(25, 10, 0))
-verbose_call(5)
-integer division or modulo by zero
->>> print(mod_div_zero_int(25, 0, 0))
-integer division or modulo by zero
-
->>> mod_div_zero_float(25, 10, 2)
-2.5
->>> print(mod_div_zero_float(25, 10, 0))
-float division
->>> print(mod_div_zero_float(25, 0, 0))
-float divmod()
-
->>> py_div_long(-5, -1)
-5
-
->>> import sys
->>> maxint = getattr(sys, ((sys.version_info[0] >= 3) and 'maxsize' or 'maxint'))
->>> py_div_long(-maxint-1, -1)
-Traceback (most recent call last):
-...
-OverflowError: value too large to perform division
 """
 
 def _all(seq):
@@ -137,16 +99,34 @@ def test_cdiv_cmod(short a, short b):
 @cython.cdivision(True)
 @cython.cdivision_warnings(True)
 def mod_int_c_warn(int a, int b):
+    """
+    >>> mod_int_c_warn(-17, 10)
+    division with oppositely signed operands, C and Python semantics differ
+    -7
+    """
     return a % b
 
 @cython.cdivision(True)
 @cython.cdivision_warnings(True)
 def div_int_c_warn(int a, int b):
+    """
+    >>> div_int_c_warn(-17, 10)
+    division with oppositely signed operands, C and Python semantics differ
+    -1
+    """
     return a // b
 
 @cython.cdivision(False)
 @cython.cdivision_warnings(True)
 def complex_expression(int a, int b, int c, int d):
+    """
+    >>> complex_expression(-150, 20, 19, -7)
+    verbose_call(20)
+    division with oppositely signed operands, C and Python semantics differ
+    verbose_call(19)
+    division with oppositely signed operands, C and Python semantics differ
+    -2
+    """
     return (a // verbose_call(b)) % (verbose_call(c) // d)
 
 cdef int verbose_call(int x):
@@ -158,6 +138,16 @@ cdef int verbose_call(int x):
 
 @cython.cdivision(False)
 def mod_div_zero_int(int a, int b, int c):
+    """
+    >>> mod_div_zero_int(25, 10, 2)
+    verbose_call(5)
+    2
+    >>> print(mod_div_zero_int(25, 10, 0))
+    verbose_call(5)
+    integer division or modulo by zero
+    >>> print(mod_div_zero_int(25, 0, 0))
+    integer division or modulo by zero
+    """
     try:
         return verbose_call(a % b) / c
     except ZeroDivisionError, ex:
@@ -165,6 +155,14 @@ def mod_div_zero_int(int a, int b, int c):
 
 @cython.cdivision(False)
 def mod_div_zero_float(float a, float b, float c):
+    """
+    >>> mod_div_zero_float(25, 10, 2)
+    2.5
+    >>> print(mod_div_zero_float(25, 10, 0))
+    float division
+    >>> print(mod_div_zero_float(25, 0, 0))
+    float divmod()
+    """
     try:
         return (a % b) / c
     except ZeroDivisionError, ex:
@@ -172,4 +170,14 @@ def mod_div_zero_float(float a, float b, float c):
 
 @cython.cdivision(False)
 def py_div_long(long a, long b):
+    """
+    >>> py_div_long(-5, -1)
+    5
+        >>> import sys
+    >>> maxint = getattr(sys, ((sys.version_info[0] >= 3) and 'maxsize' or 'maxint'))
+    >>> py_div_long(-maxint-1, -1)
+    Traceback (most recent call last):
+    ...
+    OverflowError: value too large to perform division
+    """
     return a / b

tests/run/cfuncdef.pyx

-__doc__ = u"""
-    >>> test()
-"""
-
 cdef void ftang():
     cdef int x
     x = 0
@@ -16,6 +12,9 @@ cdef spam(int i, obj, object object):
     c = 0
 
 def test():
+    """
+    >>> test()
+    """
     ftang()
     foo(0, c'f')
     spam(25, None, None)

tests/run/char_constants_T99.pyx

-__doc__ = u"""
->>> global_c_and_s()
-99
-abcdef
-
->>> local_c_and_s()
-98
-bcdefg
-"""
-
 cdef char c = 'c'
 cdef char* s = 'abcdef'
 
 def global_c_and_s():
+    """
+    >>> global_c_and_s()
+    99
+    abcdef
+    """
     pys = s
     print c
     print (pys.decode(u'ASCII'))
 
 def local_c_and_s():
+    """
+    >>> local_c_and_s()
+    98
+    bcdefg
+    """
     cdef char c = 'b'
     cdef char* s = 'bcdefg'
     pys = s

tests/run/cintop.pyx

@@ -13,11 +13,13 @@ __doc__ = u"""
     >>> (int1, long1) == f()
     True
 
-    >>> f()
-    (45, 111)
 """
 
 def f():
+    """
+    >>> f()
+    (45, 111)
+    """
     cdef int int1, int2, int3
     cdef char char1
     cdef long long1, long2

tests/run/cmp.pyx

-__doc__ = u"""
+def single_py(a, b):
+    """
     >>> single_py(1, 2)
     True
     >>> single_py(2, 1)
     False
+    """
+    return a < b
+
+def cascaded_py(a, b, c):
+    """
     >>> cascaded_py(1, 2, 3)
     True
     >>> cascaded_py(1, 2, -1)
     False
     >>> cascaded_py(10, 2, 3)
     False
+    """
+    return a < b < c
 
+def single_c(int a, int b):
+    """
     >>> single_c(1, 2)
     True
     >>> single_c(2, 1)
     False
+    """
+    return a < b
+
+def cascaded_c(double a, double b, double c):
+    """
     >>> cascaded_c(1, 2, 3)
     True
     >>> cascaded_c(1, 2, -1)
     False
     >>> cascaded_c(10, 2, 3)
     False
-"""
-
-def single_py(a, b):
-    return a < b
-
-def cascaded_py(a, b, c):
-    return a < b < c
-
-def single_c(int a, int b):
-    return a < b
-
-def cascaded_c(double a, double b, double c):
+    """
     return a < b < c
 
 def typed_cmp(list L):

tests/run/coercearraytoptr.pyx

-
 cdef char* cstring = "abcdefg"
 
 cdef void spam(char *target):

tests/run/complex_numbers_T305.pyx

-__doc__ = u"""
+#cdef extern from "complex.h":
+#    pass
+
+cimport cython
+
+def test_object_conversion(o):
+    """
     >>> test_object_conversion(2)
     ((2+0j), (2+0j), (2+0j))
     >>> test_object_conversion(2j - 0.5)
     ((-0.5+2j), (-0.5+2j), (-0.5+2j))
-    
+    """
+    cdef float complex a = o
+    cdef double complex b = o
+    cdef long double complex c = o
+    return (a, b, c)
+
+def test_arithmetic(double complex z, double complex w):
+    """
     >>> test_arithmetic(2j, 4j)
     (2j, -2j, 6j, -2j, (-8+0j), (0.5+0j))
     >>> test_arithmetic(6+12j, 3j)
     ((6+12j), (-6-12j), (6+15j), (6+9j), (-36+18j), (4-2j))
     >>> test_arithmetic(5-10j, 3+4j)
     ((5-10j), (-5+10j), (8-6j), (2-14j), (55-10j), (-1-2j))
+    
+    ## XXX this is not working
+    ## >>> test_div_by_zero(4j)
+    ## -0.25j
+    ## >>> test_div_by_zero(0)
+    ## Traceback (most recent call last):
+    ## ...
+    ## ZeroDivisionError: float division
+    """
+    return +z, -z, z+w, z-w, z*w, z/w
 
 ## XXX this is not working
-## >>> test_div_by_zero(4j)
-## -0.25j
-## >>> test_div_by_zero(0)
-## Traceback (most recent call last):
-## ...
-## ZeroDivisionError: float division
+## @cython.cdivision(False)
+## def test_div_by_zero(double complex z):
+##    return 1/z
 
+def test_coercion(int a, float b, double c, float complex d, double complex e):
+    """
     >>> test_coercion(1, 1.5, 2.5, 4+1j, 10j)
     (1+0j)
     (1.5+0j)
@@ -26,7 +48,17 @@ __doc__ = u"""
     (4+1j)
     10j
     (9+21j)
-    
+    """
+    cdef double complex z
+    z = a; print z
+    z = b; print z
+    z = c; print z
+    z = d; print z
+    z = e; print z
+    return z + a + b + c + d + e
+
+def test_compare(double complex a, double complex b):
+    """
     >>> test_compare(3, 3)
     (True, False)
     >>> test_compare(3j, 3j)
@@ -35,93 +67,62 @@ __doc__ = u"""
     (False, True)
     >>> test_compare(3, 4)
     (False, True)
-    
+    """
+    return a == b, a != b
+
+def test_compare_coerce(double complex a, int b):
+    """
     >>> test_compare_coerce(3, 4)
     (False, True)
     >>> test_compare_coerce(4+1j, 4)
     (False, True)
     >>> test_compare_coerce(4, 4)
     (True, False)
-    
+    """
+    return a == b, a != b
+
+def test_literal():
+    """
     >>> test_literal()
     (5j, (1-2.5j))
-    
+    """
+    return 5j, 1-2.5j
+
+def test_real_imag(double complex z):
+    """
     >>> test_real_imag(1-3j)
     (1.0, -3.0)
     >>> test_real_imag(5)
     (5.0, 0.0)
     >>> test_real_imag(1.5j)
     (0.0, 1.5)
-    
+    """
+    return z.real, z.imag
+
+def test_real_imag_assignment(object a, double b):
+    """
     >>> test_real_imag_assignment(1, 2)
     (1+2j)
     >>> test_real_imag_assignment(1.5, -3.5)
     (1.5-3.5j)
-
-    >>> test_conjugate(2+3j)
-    (2-3j)
-
-    >>> test_conjugate_double(2+3j)
-    (2-3j)
-
-    >>> test_coerce_typedef_multiply(3, 1j)
-    (3j)
-
-    >>> complex_retval()
-    1j
-    
-"""
-
-#cdef extern from "complex.h":
-#    pass
-
-cimport cython
-
-def test_object_conversion(o):
-    cdef float complex a = o
-    cdef double complex b = o
-    cdef long double complex c = o
-    return (a, b, c)
-
-def test_arithmetic(double complex z, double complex w):
-    return +z, -z, z+w, z-w, z*w, z/w
-
-## XXX this is not working
-## @cython.cdivision(False)
-## def test_div_by_zero(double complex z):
-##    return 1/z
-
-def test_coercion(int a, float b, double c, float complex d, double complex e):
-    cdef double complex z
-    z = a; print z
-    z = b; print z
-    z = c; print z
-    z = d; print z
-    z = e; print z
-    return z + a + b + c + d + e
-
-def test_compare(double complex a, double complex b):
-    return a == b, a != b
-
-def test_compare_coerce(double complex a, int b):
-    return a == b, a != b
-
-def test_literal():
-    return 5j, 1-2.5j
-
-def test_real_imag(double complex z):
-    return z.real, z.imag
-
-def test_real_imag_assignment(object a, double b):
+    """
     cdef double complex z
     z.real = a
     z.imag = b
     return z
 
 def test_conjugate(float complex z):
+    """
+    >>> test_conjugate(2+3j)
+    (2-3j)
+    """
     return z.conjugate()
 
 def test_conjugate_double(double complex z):
+    """
+    >>> test_conjugate_double(2+3j)
+    (2-3j)
+    """
     return z.conjugate()
 
 ctypedef double complex cdouble
@@ -130,7 +131,15 @@ def test_conjugate_typedef(cdouble z):
 
 ctypedef double mydouble
 def test_coerce_typedef_multiply(mydouble x, double complex z):
+    """
+    >>> test_coerce_typedef_multiply(3, 1j)
+    (3j)
+    """
     return x * z
 
 cpdef double complex complex_retval():
+    """
+    >>> complex_retval()
+    1j
+    """
     return 1j

tests/run/concatcstrings.pyx

@@ -8,4 +8,3 @@ if sys.version_info[0] >= 3:
     __doc__ = __doc__.replace(u" u'", u" '")
 
 spam = u"C string 1" + u"C string 2"
-

tests/run/consts.pyx

-__doc__ = u"""
->>> add() == 1+2+3+4
-True
->>> add_var(10) == 1+2+10+3+4
-True
->>> neg() == -1 -2 - (-3+4)
-True
->>> long_int_mix() == 1 + (2 * 3) // 2
-True
->>> if IS_PY3: type(long_int_mix()) is int
-... else:      type(long_int_mix()) is long
-True
->>> char_int_mix() == 1 + (ord(' ') * 3) // 2 + ord('A')
-True
->>> int_cast() == 1 + 2 * 6000
-True
->>> mul() == 1*60*1000
-True
->>> arithm() == 9*2+3*8//6-10
-True
->>> parameters() == _func(-1 -2, - (-3+4), 1*2*3)
-True
->>> lists() == [1,2,3] + [4,5,6]
-True
-"""
-
 import sys
 IS_PY3 = sys.version_info[0] >= 3
 
@@ -31,31 +5,74 @@ def _func(a,b,c):
     return a+b+c
 
 def add():
+    """
+    >>> add() == 1+2+3+4
+    True
+    """
     return 1+2+3+4
 
 def add_var(a):
+    """
+    >>> add_var(10) == 1+2+10+3+4
+    True
+    """
     return 1+2 +a+ 3+4
 
 def neg():
+    """
+    >>> neg() == -1 -2 - (-3+4)
+    True
+    """
     return -1 -2 - (-3+4)
 
 def long_int_mix():
+    """
+    >>> long_int_mix() == 1 + (2 * 3) // 2
+    True
+    >>> if IS_PY3: type(long_int_mix()) is int
+    ... else:      type(long_int_mix()) is long
+    True
+    """
     return 1L + (2 * 3L) // 2
 
 def char_int_mix():
+    """
+    >>> char_int_mix() == 1 + (ord(' ') * 3) // 2 + ord('A')
+    True
+    """
     return 1L + (c' ' * 3L) // 2 + c'A'
 
 def int_cast():
+    """
+    >>> int_cast() == 1 + 2 * 6000
+    True
+    """
     return <int>(1 + 2 * 6000)
 
 def mul():
+    """
+    >>> mul() == 1*60*1000
+    True
+    """
     return 1*60*1000
 
 def arithm():
+    """
+    >>> arithm() == 9*2+3*8//6-10
+    True
+    """
     return 9*2+3*8//6-10
 
 def parameters():
+    """
+    >>> parameters() == _func(-1 -2, - (-3+4), 1*2*3)
+    True
+    """
     return _func(-1 -2, - (-3+4), 1*2*3)
 
 def lists():
+    """
+    >>> lists() == [1,2,3] + [4,5,6]
+    True
+    """
     return [1,2,3] + [4,5,6]

tests/run/cpdef_temps_T411.pyx

-__doc__ = """
+cdef class A:
+    """
     >>> A().is_True()
     True
     >>> A().is_False()
     False
-
-    >>> B().is_True()
-    True
-    >>> B().is_False()
-    False
-"""
-
-cdef class A:
+    """
     cpdef is_True(self):
         return True
     cpdef is_False(self):
         return not self.is_True()
 
 class B(A):
+    """
+    >>> B().is_True()
+    True
+    >>> B().is_False()
+    False
+    """
     def is_True(self):
         return True

tests/run/crashT245.pyx

-__doc__ = """
->>> f()
-{'x': 1}
-"""
-
 cimport crashT245_pxd
 
 def f():
+    """
+    >>> f()
+    {'x': 1}
+    """
     cdef crashT245_pxd.MyStruct s
     s.x = 1
     print s
-

tests/run/cstruct.pyx

-__doc__ = u"""
-    >>> test_i()
-    >>> test_c()
-    >>> test_p()
-    >>> test_g()
-"""
-
 cdef struct Grail
 
 cdef struct Spam:
@@ -41,19 +34,31 @@ cdef void eggs_g(Spam s):
 spam = ham
 
 def test_i():
+    """
+    >>> test_i()
+    """
     spam.i = 1
     eggs_i(spam)
 
 def test_c():
+    """
+    >>> test_c()
+    """
     spam.c = c'a'
     eggs_c(spam)
 
 def test_p():
+    """
+    >>> test_p()
+    """
     cdef float f
     spam.p[0] = &f
     eggs_p(spam)
 
 def test_g():
+    """
+    >>> test_g()
+    """
     cdef Grail l
     spam.g = &l
     eggs_g(spam)

tests/run/ct_IF.pyx

-__doc__ = u"""
-    >>> f()
-    1
-    >>> g()
-    2
-    >>> h()
-    3
-"""
-
 DEF NO = 0
 DEF YES = 1
 
 def f():
+    """
+    >>> f()
+    1
+    """
     cdef int i
     IF YES:
         i = 1
@@ -21,6 +16,10 @@ def f():
     return i
 
 def g():
+    """
+    >>> g()
+    2
+    """
     cdef int i
     IF NO:
         i = 1
@@ -31,6 +30,10 @@ def g():
     return i
 
 def h():
+    """
+    >>> h()
+    3
+    """
     cdef int i
     IF NO:
         i = 1

tests/run/ctruthtests.pyx

-__doc__ = u"""
->>> test_int(0)
-False
->>> test_int(1)
-True
-
->>> test_short(0)
-False
->>> test_short(1)
-True
-
->>> test_Py_ssize_t(0)
-False
->>> test_Py_ssize_t(1)
-True
-
->>> test_ptr()
-False
->>> test_ptr2()
-2
-
->>> test_attr_int(TestExtInt(0))
-False
->>> test_attr_int(TestExtInt(1))
-True
-
->>> test_attr_ptr(TestExtPtr(0))
-False
->>> test_attr_ptr(TestExtPtr(1))
-True
-"""
-
 def test_ptr():
+    """
+    >>> test_ptr()
+    False
+    """
     cdef void* p = NULL
     if p:
         return True
@@ -38,6 +10,10 @@ def test_ptr():
         return False
 
 def test_ptr2():
+    """
+    >>> test_ptr2()
+    2
+    """
     cdef char* p1 = NULL
     cdef char* p2 = NULL
     p1 += 1
@@ -50,18 +26,36 @@ def test_ptr2():
         return 3
 
 def test_int(int i):
+    """
+    >>> test_int(0)
+    False
+    >>> test_int(1)
+    True
+    """
     if i:
         return True
     else:
         return False
 
 def test_short(short i):
+    """
+    >>> test_short(0)
+    False
+    >>> test_short(1)
+    True
+    """
     if i:
         return True
     else:
         return False
 
 def test_Py_ssize_t(Py_ssize_t i):
+    """
+    >>> test_Py_ssize_t(0)
+    False
+    >>> test_Py_ssize_t(1)
+    True
+    """
     if i:
         return True
     else:
@@ -72,6 +66,12 @@ cdef class TestExtInt:
     def __init__(self, i): self.i = i
 
 def test_attr_int(TestExtInt e):
+    """
+    >>> test_attr_int(TestExtInt(0))
+    False
+    >>> test_attr_int(TestExtInt(1))
+    True
+    """
     if e.i:
         return True
     else:
@@ -82,6 +82,12 @@ cdef class TestExtPtr:
     def __init__(self, int i): self.p = <void*>i
 
 def test_attr_ptr(TestExtPtr e):
+    """
+    >>> test_attr_ptr(TestExtPtr(0))
+    False
+    >>> test_attr_ptr(TestExtPtr(1))
+    True
+    """
     if e.p:
         return True
     else:

tests/run/cunion.pyx

-__doc__ = u"""
-    >>> test_i()
-    >>> test_c()
-    >>> test_p()
-"""
-
 cdef union Spam:
     int i
     char c
@@ -29,14 +23,23 @@ cdef void eggs_p(Spam s):
 spam = ham
 
 def test_i():
+    """
+    >>> test_i()
+    """
     spam.i = 1
     eggs_i(spam)
 
 def test_c():
+    """
+    >>> test_c()
+    """
     spam.c = c'a'
     eggs_c(spam)
 
 def test_p():
+    """
+    >>> test_p()
+    """
     cdef float f
     spam.p[0] = &f
     eggs_p(spam)

tests/run/cvardef.pyx

-__doc__ = u"""
-    >>> f()
-"""
-
 def f():
+    """
+    >>> f()
+    """
     cdef char a_char
     cdef short a_short
     cdef int i1, i2

tests/run/dict.pyx

-__doc__ = u"""
+def empty():
+    """
     >>> empty()
     {}
+    """
+    d = {}
+    return d
+
+def keyvalue(key, value):
+    """
     >>> keyvalue(1, 2)
     {1: 2}
+    """
+    d = {key:value}
+    return d
 
+def keyvalues(key1, value1, key2, value2):
+    """
     >>> keyvalues(1, 2, 3, 4)
     {1: 2, 3: 4}
+    """
+    d = {key1:value1, key2:value2}
+    return d
+
+def keyvalues2(key1, value1, key2, value2):
+    """
     >>> keyvalues2(1, 2, 3, 4)
     {1: 2, 3: 4}
+    """
+    d = {key1:value1, key2:value2,}
+    return d
 
+def constant():
+    """
     >>> len(constant())
     2
     >>> print(constant()['parrot'])
     resting
     >>> print(constant()['answer'])
     42
+    """
+    d = {u"parrot":u"resting", u"answer":42}
+    return d
 
+def dict_call():
+    """
     >>> print(dict_call()['parrot'])
     resting
     >>> print(dict_call()['answer'])
     42
+    """
+    d = dict(parrot=u"resting", answer=42)
+    return d
 
+def dict_call_dict():
+    """
     >>> print(dict_call_dict()['parrot'])
     resting
     >>> print(dict_call_dict()['answer'])
     42
+    """
+    d = dict(dict(parrot=u"resting", answer=42))
+    return d
 
+def dict_call_kwargs():
+    """
     >>> print(dict_call_kwargs()['parrot1'])
     resting
     >>> print(dict_call_kwargs()['parrot2'])
@@ -34,37 +72,7 @@ __doc__ = u"""
     42
     >>> print(dict_call_kwargs()['answer2'])
     42
-"""
-
-def empty():
-    d = {}
-    return d
-
-def keyvalue(key, value):
-    d = {key:value}
-    return d
-
-def keyvalues(key1, value1, key2, value2):
-    d = {key1:value1, key2:value2}
-    return d
-
-def keyvalues2(key1, value1, key2, value2):
-    d = {key1:value1, key2:value2,}
-    return d
-
-def constant():
-    d = {u"parrot":u"resting", u"answer":42}
-    return d
-
-def dict_call():
-    d = dict(parrot=u"resting", answer=42)
-    return d
-
-def dict_call_dict():
-    d = dict(dict(parrot=u"resting", answer=42))
-    return d
-
-def dict_call_kwargs():
+    """
     kwargs = dict(parrot1=u"resting", answer1=42)
     d = dict(parrot2=u"resting", answer2=42, **kwargs)
     return d

tests/run/dictintindex.pyx

-__doc__ = u"""
->>> test_get_char_neg()
-0
->>> test_get_char_zero()
-1
->>> test_get_char_pos()
-2
->>> test_get_uchar_zero()
-1
->>> test_get_uchar_pos()
-2
->>> test_get_int_neg()
-0
->>> test_get_int_zero()
-1
->>> test_get_int_pos()
-2
->>> test_get_uint_zero()
-1
->>> test_get_uint_pos()
-2
->>> test_get_longlong_neg()
-0
->>> test_get_longlong_zero()
-1
->>> test_get_longlong_pos()
-2
->>> test_get_longlong_big()
-3
->>> test_get_ulonglong_zero()
-1
->>> test_get_ulonglong_pos()
-2
->>> test_get_ulonglong_big()
-3
->>> test_del_char()
-Traceback (most recent call last):
-KeyError: 0
->>> test_del_uchar()
-Traceback (most recent call last):
-KeyError: 0
->>> test_del_int()
-Traceback (most recent call last):
-KeyError: 0
->>> test_del_uint()  #doctest: +ELLIPSIS
-Traceback (most recent call last):
-KeyError: 0...
->>> test_del_longlong() #doctest: +ELLIPSIS
-Traceback (most recent call last):
-KeyError: 0...
->>> test_del_longlong_big() #doctest: +ELLIPSIS
-Traceback (most recent call last):
-KeyError: ...
->>> test_del_ulonglong() #doctest: +ELLIPSIS
-Traceback (most recent call last):
-KeyError: 0...
->>> test_del_ulonglong_big() #doctest: +ELLIPSIS
-Traceback (most recent call last):
-KeyError: ...
-"""
-
 def test_get_char_neg():
+    """
+    >>> test_get_char_neg()
+    0
+    """
     cdef char key = -1
     d = {-1:0}
     return d[key]
 def test_get_char_zero():
+    """
+    >>> test_get_char_zero()
+    1
+    """
     cdef char key = 0
     d = {0:1}
     return d[key]
 def test_get_char_pos():
+    """
+    >>> test_get_char_pos()
+    2
+    """
     cdef char key = 1
     d = {1:2}
     return d[key]
 
 
 def test_get_uchar_zero():
+    """
+    >>> test_get_uchar_zero()
+    1
+    """
     cdef unsigned char key = 0
     d = {0:1}
     return d[key]
 def test_get_uchar_pos():
+    """
+    >>> test_get_uchar_pos()
+    2
+    """
     cdef unsigned char key = 1
     d = {1:2}
     return d[key]
 
 
 def test_get_int_neg():
+    """
+    >>> test_get_int_neg()
+    0
+    """
     cdef int key = -1
     d = {-1:0}
     return d[key]
 def test_get_int_zero():
+    """
+    >>> test_get_int_zero()
+    1
+    """
     cdef int key = 0
     d = {0:1}
     return d[key]
 def test_get_int_pos():
+    """
+    >>> test_get_int_pos()
+    2
+    """
     cdef int key = 1
     d = {1:2}
     return d[key]
 
 
 def test_get_uint_zero():
+    """
+    >>> test_get_uint_zero()
+    1
+    """
     cdef unsigned int key = 0
     d = {0:1}
     return d[key]
 def test_get_uint_pos():
+    """
+    >>> test_get_uint_pos()
+    2
+    """
     cdef unsigned int key = 1
     d = {1:2}
     return d[key]
 
 
 def test_get_longlong_neg():
+    """
+    >>> test_get_longlong_neg()
+    0
+    """
     cdef long long key = -1
     d = {-1:0}
     return d[key]
 def test_get_longlong_zero():
+    """
+    >>> test_get_longlong_zero()
+    1
+    """
     cdef long long key = 0
     d = {0:1}
     return d[key]
 def test_get_longlong_pos():
+    """
+    >>> test_get_longlong_pos()
+    2
+    """
     cdef long long key = 1
     d = {1:2}
     return d[key]
 def test_get_longlong_big():
+    """
+    >>> test_get_longlong_big()
+    3
+    """
     cdef unsigned int shift = sizeof(long)+2
     cdef long long big = 1
     cdef long long key = big<<shift
@@ -127,14 +122,26 @@ def test_get_longlong_big():
     return d[key]
 
 def test_get_ulonglong_zero():
+    """
+    >>> test_get_ulonglong_zero()
+    1
+    """
     cdef unsigned long long key = 0
     d = {0:1}
     return d[key]
 def test_get_ulonglong_pos():
+    """
+    >>> test_get_ulonglong_pos()
+    2
+    """
     cdef unsigned long long key = 1
     d = {1:2}
     return d[key]
 def test_get_ulonglong_big():
+    """
+    >>> test_get_ulonglong_big()
+    3
+    """
     cdef unsigned int shift = sizeof(long)+2
     cdef unsigned long long big = 1
     cdef unsigned long long key = big<<shift
@@ -143,42 +150,77 @@ def test_get_ulonglong_big():
 
 
 def test_del_char():
+    """
+    >>> test_del_char()
+    Traceback (most recent call last):
+    KeyError: 0
+    """
     cdef char key = 0
     d = {0:1}
     del d[key]
     return d[key]
 
 def test_del_uchar():
+    """
+    >>> test_del_uchar()
+    Traceback (most recent call last):
+    KeyError: 0
+    """
     cdef unsigned char key = 0
     d = {0:1}
     del d[key]
     return d[key]
 
 def test_del_int():
+    """
+    >>> test_del_int()
+    Traceback (most recent call last):
+    KeyError: 0
+    """
     cdef int key = 0
     d = {0:1}
     del d[key]
     return d[key]
 
 def test_del_uint():
+    """
+    >>> test_del_uint()  #doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    KeyError: 0...
+    """
     cdef unsigned int key = 0
     d = {0:1}
     del d[key]
     return d[key]
 
 def test_del_longlong():
+    """
+    >>> test_del_longlong() #doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    KeyError: 0...
+    """
     cdef long long key = 0
     d = {0:1}
     del d[key]
     return d[key]
 
 def test_del_ulonglong():
+    """
+    >>> test_del_ulonglong() #doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    KeyError: 0...
+    """
     cdef unsigned long long key = 0
     d = {0:1}
     del d[key]
     return d[key]
 
 def test_del_longlong_big():
+    """
+    >>> test_del_longlong_big() #doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    KeyError: ...
+    """
     cdef int shift = sizeof(long)+2
     cdef long long big = 1
     cdef long long key = big<<shift
@@ -187,6 +229,11 @@ def test_del_longlong_big():
     return d[key]
 
 def test_del_ulonglong_big():
+    """
+    >>> test_del_ulonglong_big() #doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    KeyError: ...
+    """
     cdef unsigned int shift = sizeof(long)+2
     cdef unsigned long long big = 1
     cdef unsigned long long key = big<<shift

tests/run/dietachmayer1.pyx

-__doc__ = u"""
+def test():
+    """
     >>> test()
     1.0
-"""
-
-def test():
+    """
     cdef float v[10][10]
     v[1][2] = 1.0
     return v[1][2]

tests/run/empty_for_loop_T208.pyx

-__doc__ = u"""
-  >>> go_py_empty()
-  20
-  >>> go_c_empty()
-  20
-"""
-
 def go_py_empty():
+    """
+    >>> go_py_empty()
+    20
+    """
     i = 20
     for i in range(4,0):
         print u"Spam!"
     return i
 
 def go_c_empty():
+    """
+    >>> go_c_empty()
+    20
+    """
     cdef int i = 20
     for i in range(4,0):
         print u"Spam!"

tests/run/enumerate_T316.pyx

-__doc__ = u"""
-  >>> go_c_enumerate()
-  0 1
-  1 2
-  2 3
-  3 4
-
-  >>> go_py_enumerate()
-  0 1
-  1 2
-  2 3
-  3 4
-
-  >>> empty_c_enumerate()
-  (55, 99)
-
-  >>> go_c_enumerate_step()
-  0 1
-  1 3
-  2 5
-
-  >>> single_target_enumerate()
-  0 1
-  1 2
-  2 3
-  3 4
-
-  >>> multi_enumerate()
-  0 0 0 1
-  1 1 1 2
-  2 2 2 3
-  3 3 3 4
-
-  >>> multi_c_enumerate()
-  0 0 0 1
-  1 1 1 2
-  2 2 2 3
-  3 3 3 4
-
-  >>> py_enumerate_break(1,2,3,4)
-  0 1
-  :: 0 1
-
-  >>> py_enumerate_return()
-  :: 55 99
-  >>> py_enumerate_return(1,2,3,4)
-  0 1
-
-  >>> py_enumerate_continue(1,2,3,4)
-  0 1
-  1 2
-  2 3
-  3 4
-  :: 3 4
-
-  >>> py_enumerate_dict({})
-  :: 55 99
-  >>> py_enumerate_dict(dict(a=1, b=2, c=3))
-  0 a
-  1 c
-  2 b
-  :: 2 b
-
-"""
-
 cimport cython
 
 @cython.test_fail_if_path_exists("//SimpleCallNode//NameNode[@name = 'enumerate']")
 def go_py_enumerate():
+    """
+    >>> go_py_enumerate()
+    0 1
+    1 2
+    2 3
+    3 4
+    """
     for i,k in enumerate(range(1,5)):
         print i, k
 
 #T442 @cython.test_fail_if_path_exists("//SimpleCallNode//NameNode[@name = 'enumerate']")
 def go_c_enumerate():
+    """
+    >>> go_c_enumerate()
+    0 1
+    1 2
+    2 3
+    3 4
+    """
     cdef int i,k
     for i,k in enumerate(range(1,5)):
         print i, k
 
 #T442 @cython.test_fail_if_path_exists("//SimpleCallNode//NameNode[@name = 'enumerate']")
 def go_c_enumerate_step():
+    """
+    >>> go_c_enumerate_step()
+    0 1
+    1 3
+    2 5
+    """
     cdef int i,k
     for i,k in enumerate(range(1,7,2)):
         print i, k
 
 @cython.test_fail_if_path_exists("//SimpleCallNode//NameNode[@name = 'enumerate']")
 def py_enumerate_dict(dict d):
+    """
+    >>> py_enumerate_dict({})
+    :: 55 99
+    >>> py_enumerate_dict(dict(a=1, b=2, c=3))
+    0 a
+    1 c
+    2 b
+    :: 2 b
+    """
     cdef int i = 55
     k = 99
     for i,k in enumerate(d):
@@ -92,6 +56,11 @@ def py_enumerate_dict(dict d):
 
 @cython.test_fail_if_path_exists("//SimpleCallNode")
 def py_enumerate_break(*t):
+    """
+    >>> py_enumerate_break(1,2,3,4)
+    0 1
+    :: 0 1
+    """
     i,k = 55,99
     for i,k in enumerate(t):
         print i, k
@@ -100,6 +69,12 @@ def py_enumerate_break(*t):
 
 @cython.test_fail_if_path_exists("//SimpleCallNode")
 def py_enumerate_return(*t):
+    """
+    >>> py_enumerate_return()
+    :: 55 99
+    >>> py_enumerate_return(1,2,3,4)
+    0 1
+    """
     i,k = 55,99
     for i,k in enumerate(t):
         print i, k
@@ -108,6 +83,14 @@ def py_enumerate_return(*t):
 
 @cython.test_fail_if_path_exists("//SimpleCallNode")
 def py_enumerate_continue(*t):
+    """
+    >>> py_enumerate_continue(1,2,3,4)
+    0 1
+    1 2
+    2 3
+    3 4
+    :: 3 4
+    """
     i,k = 55,99
     for i,k in enumerate(t):
         print i, k
@@ -116,6 +99,10 @@ def py_enumerate_continue(*t):
 
 # T442 @cython.test_fail_if_path_exists("//SimpleCallNode//NameNode[@name = 'enumerate']")
 def empty_c_enumerate():
+    """
+    >>> empty_c_enumerate()
+    (55, 99)
+    """
     cdef int i = 55, k = 99
     for i,k in enumerate(range(0)):
         print i, k
@@ -123,16 +110,37 @@ def empty_c_enumerate():
 
 # not currently optimised
 def single_target_enumerate():
+    """
+    >>> single_target_enumerate()
+    0 1
+    1 2
+    2 3
+    3 4
+    """
     for t in enumerate(range(1,5)):
         print t[0], t[1]
 
 @cython.test_fail_if_path_exists("//SimpleCallNode//NameNode[@name = 'enumerate']")
 def multi_enumerate():
+    """
+    >>> multi_enumerate()
+    0 0 0 1
+    1 1 1 2
+    2 2 2 3
+    3 3 3 4
+    """
     for a,(b,(c,d)) in enumerate(enumerate(enumerate(range(1,5)))):
         print a,b,c,d
 
 # T442 @cython.test_fail_if_path_exists("//SimpleCallNode")
 def multi_c_enumerate():
+    """
+    >>> multi_c_enumerate()
+    0 0 0 1
+    1 1 1 2
+    2 2 2 3
+    3 3 3 4
+    """
     cdef int a,b,c,d
     for a,(b,(c,d)) in enumerate(enumerate(enumerate(range(1,5)))):
         print a,b,c,d

tests/run/exceptionpropagation.pyx

-__doc__ = u"""
->>> foo(0)
->>> foo(1)
-Traceback (most recent call last):
-RuntimeError
-"""
-
 cdef int CHKERR(int ierr) except -1:
     if ierr==0: return 0
     raise RuntimeError
@@ -13,6 +6,12 @@ cdef int obj2int(object ob) except *:
     return ob
 
 def foo(a):
+    """
+    >>> foo(0)
+    >>> foo(1)
+    Traceback (most recent call last):
+    RuntimeError
+    """
     cdef int i = obj2int(a)
     CHKERR(i)
 

tests/run/ext_instance_type_T232.pyx

-__doc__ = u"""
->>> set_attr(5)
->>> get_attr()
-"""
-
 cdef class MyExt:
     cdef object attr
 
 def set_attr(value):
+    """
+    >>> set_attr(5)
+    """
     MyExt().attr = value
 
 def get_attr():
+    """
+    >>> get_attr()
+    """
     return MyExt().attr

tests/run/extcmethod.pyx

-__doc__ = u"""
->>> test()
-5
-0
-20
-5
-"""
-
 cdef class Spam:
 
     cdef int tons
@@ -25,6 +17,13 @@ cdef class SuperSpam(Spam):
         self.tons = self.tons + 2 * x
 
 def test():
+    """
+    >>> test()
+    5
+    0
+    20
+    5
+    """
     cdef Spam s
     cdef SuperSpam ss
     s = Spam()

tests/run/extended_unpacking_T409.pyx

-
 def simple():
     """
     >>> simple()

tests/run/extinherit.pyx

-__doc__ = u"""
-    >>> p = create()
-    >>> rest(p)
-    0
-"""
-
 cdef class Parrot:
     cdef object name
     cdef int alive
@@ -18,6 +12,11 @@ def create():
     return p
 
 def rest(Norwegian polly):
+    """
+    >>> p = create()
+    >>> rest(p)
+    0
+    """
     cdef Parrot fred
     cdef object spam
     spam = None

tests/run/extkwonlyargs.pyx

@@ -2,27 +2,46 @@ __doc__ = u"""
     >>> ext = Ext()
     >>> b,c,d,e,f,g,h,k = ext.b,ext.c,ext.d,ext.e,ext.f,ext.g,ext.h,ext.k
 
-    >>> b(1,2,3)
-    >>> b(1,2,3,4)
-    Traceback (most recent call last):
-    TypeError: b() takes exactly 3 positional arguments (4 given)
+"""
+
+cdef class Ext:
+    def b(self, a, b, c):
+        pass
+
+    def c(self, a, b, c=1):
+        pass
+
+    def d(self, a, b, *, c = 88):
+        pass
+
+    def e(self, a, b, c = 88, **kwds):
+        pass
+
+    def f(self, a, b, *, c, d = 42):
+        pass
+
+    def g(self, a, b, *, c, d = 42, e = 17, f, **kwds):
+        pass
 
+    def h(self, a, b, *args, c, d = 42, e = 17, f, **kwds):
+        pass
+
+    def k(self, a, b, c=1, *args, d = 42, e = 17, f, **kwds):
+        pass
+"""# c
     >>> c(1,2)
     >>> c(1,2,3)
     >>> c(1,2,3,4)
     Traceback (most recent call last):
     TypeError: c() takes at most 3 positional arguments (4 given)
 
-    >>> d(1,2)
-    >>> d(1,2, c=1)
-
-    >>> d(1,2,3)
-    Traceback (most recent call last):
-    TypeError: d() takes exactly 2 positional arguments (3 given)
-    >>> d(1,2, d=1)
+# b
+    >>> b(1,2,3)
+    >>> b(1,2,3,4)
     Traceback (most recent call last):
-    TypeError: d() got an unexpected keyword argument 'd'
+    TypeError: b() takes exactly 3 positional arguments (4 given)
 
+# e
     >>> e(1,2)
     >>> e(1,2, c=1)
     >>> e(1,2, d=1)
@@ -32,19 +51,18 @@ __doc__ = u"""
     Traceback (most recent call last):
     TypeError: e() takes at most 3 positional arguments (4 given)
 
-    >>> f(1,2, c=1)
-    >>> f(1,2, c=1, d=2)
+# d
+    >>> d(1,2)
+    >>> d(1,2, c=1)
 
-    >>> f(1,2,3)
-    Traceback (most recent call last):
-    TypeError: f() takes exactly 2 positional arguments (3 given)
-    >>> f(1,2)
+    >>> d(1,2,3)
     Traceback (most recent call last):
-    TypeError: f() needs keyword-only argument c
-    >>> f(1,2, c=1, e=2)
+    TypeError: d() takes exactly 2 positional arguments (3 given)
+    >>> d(1,2, d=1)
     Traceback (most recent call last):
-    TypeError: f() got an unexpected keyword argument 'e'
+    TypeError: d() got an unexpected keyword argument 'd'
 
+# g
     >>> g(1,2, c=1, f=2)
     >>> g(1,2, c=1, e=0, f=2, d=11)
     >>> g(1,2, c=1, f=2, e=0, x=25)
@@ -59,6 +77,21 @@ __doc__ = u"""
     Traceback (most recent call last):
     TypeError: g() needs keyword-only argument f
 
+# f
+    >>> f(1,2, c=1)
+    >>> f(1,2, c=1, d=2)
+
+    >>> f(1,2,3)
+    Traceback (most recent call last):
+    TypeError: f() takes exactly 2 positional arguments (3 given)
+    >>> f(1,2)
+    Traceback (most recent call last):
+    TypeError: f() needs keyword-only argument c
+    >>> f(1,2, c=1, e=2)
+    Traceback (most recent call last):
+    TypeError: f() got an unexpected keyword argument 'e'
+
+# h
     >>> h(1,2, c=1, f=2)
     >>> h(1,2, c=1, f=2, e=3)
     >>> h(1,2,3,4,5,6, c=1, f=2)
@@ -71,6 +104,7 @@ __doc__ = u"""
     Traceback (most recent call last):
     TypeError: h() needs keyword-only argument c
 
+# k
     >>> k(1,2, c=1, f=2)
     >>> k(1,2, c=1, f=2, e=3)
     >>> k(1,2,3,4,5,6, d=1, f=2)
@@ -83,28 +117,3 @@ __doc__ = u"""
     Traceback (most recent call last):
     TypeError: k() needs keyword-only argument f
 """
-
-cdef class Ext:
-    def b(self, a, b, c):
-        pass
-
-    def c(self, a, b, c=1):
-        pass
-
-    def d(self, a, b, *, c = 88):
-        pass
-
-    def e(self, a, b, c = 88, **kwds):
-        pass
-
-    def f(self, a, b, *, c, d = 42):
-        pass
-
-    def g(self, a, b, *, c, d = 42, e = 17, f, **kwds):
-        pass
-
-    def h(self, a, b, *args, c, d = 42, e = 17, f, **kwds):
-        pass
-
-    def k(self, a, b, c=1, *args, d = 42, e = 17, f, **kwds):
-        pass

tests/run/extlen.pyx

@@ -7,4 +7,3 @@ cdef class Spam:
 
     def __len__(self):
         return 0
-

tests/run/extpropertyref.pyx

-__doc__ = u"""
->>> tomato()
-42
-"""
-
 cdef class Spam:
 
     property eggs:
@@ -11,6 +6,10 @@ cdef class Spam:
             return 42
 
 def tomato():
+    """
+    >>> tomato()
+    42
+    """
     cdef Spam spam
     cdef object lettuce
     spam = Spam()

tests/run/exttype.pyx

-__doc__ = u"""
-    >>> s = Spam(12)
-    >>> s.eat()
-    12 42
-    >>> f(s)
-    Traceback (most recent call last):
-    AttributeError: 'exttype.Spam' object has no attribute 'foo'
-    >>> s.eat()
-    12 42
-
-    >>> class Spam2(Spam):
-    ...     foo = 1
-    >>> s = Spam2(12)
-    >>> s.eat()
-    12 42
-    >>> f(s)
-    >>> s.eat()
-    12 42
-"""
 
 cdef gobble(a, b):
     print a, b
 
 cdef class Spam:
-
+    """
+    >>> s = Spam(12)
+    >>> s.eat()
+    12 42
+    """
     cdef eggs
     cdef int ham
 
@@ -37,6 +22,22 @@ cdef class Spam:
         gobble(self.eggs, self.ham)
 
 def f(Spam spam):
+    """
+    >>> s = Spam(12)
+    >>> f(s)
+    Traceback (most recent call last):
+    AttributeError: 'exttype.Spam' object has no attribute 'foo'
+    >>> s.eat()
+    12 42
+    >>> class Spam2(Spam):
+    ...     foo = 1
+    >>> s = Spam2(12)
+    >>> s.eat()
+    12 42
+    >>> f(s)
+    >>> s.eat()
+    12 42
+    """
     x = spam.eggs
     y = spam.ham
     z = spam.foo

tests/run/filenames.pyx

@@ -8,4 +8,3 @@ ftang
 include "filenames.pxi"
 
 foo = 42
-

tests/run/flatin.pyx

-__doc__ = u"""
->>> test_in('ABC')
-1
->>> test_in('abc')
-2
->>> test_in('X')
-3
->>> test_in('XYZ')
-4
->>> test_in('ABCXYZ')
-5
->>> test_in('')
-5
-
->>> test_not_in('abc')
-1
->>> test_not_in('CDE')
-2
->>> test_not_in('CDEF')
-3
->>> test_not_in('BCD')
-4
-"""
-
 def test_in(s):
+    """
+    >>> test_in('ABC')
+    1
+    >>> test_in('abc')
+    2
+    >>> test_in('X')
+    3
+    >>> test_in('XYZ')
+    4
+    >>> test_in('ABCXYZ')
+    5
+    >>> test_in('')
+    5
+    """
     if s in (u'ABC', u'BCD'):
         return 1
     elif s.upper() in (u'ABC', u'BCD'):
@@ -35,6 +25,16 @@ def test_in(s):
         return 5
 
 def test_not_in(s):
+    """
+    >>> test_not_in('abc')
+    1
+    >>> test_not_in('CDE')
+    2
+    >>> test_not_in('CDEF')
+    3
+    >>> test_not_in('BCD')
+    4
+    """
     if s not in (u'ABC', u'BCD', u'CDE', u'CDEF'):
         return 1
     elif s.upper() not in (u'ABC', u'BCD', u'CDEF'):

tests/run/float_floor_division_T260.pyx

-__doc__ = u"""
+def floor_div_float(double a, double b):
+    """
     >>> floor_div_float(2, 1.5)
     1.0
     >>> floor_div_float(2, -1.5)
@@ -7,7 +8,5 @@ __doc__ = u"""
     -2.0
     >>> floor_div_float(1e10, 1e-10)
     1e+20
-"""
-
-def floor_div_float(double a, double b):
+    """
     return a // b

tests/run/fmod.pyx

-__doc__ = u"""
+def fmod(double a, double b):
+    """
     >>> fmod(7, 1.25)
     0.75
-"""
-
-def fmod(double a, double b):
+    """
     return a % b

tests/run/for_from_float_T254.pyx

-__doc__ = u"""
+def double_target(a, b):
+    """
     >>> double_target(0, 4)
     at 0.0
     at 1.0
     at 2.0
     at 3.0
     4.0
-    >>> double_step(0, 2, .5)
-    at 0.0
-    at 0.5
-    at 1.0
-    at 1.5
-    2.0
-    >>> double_step_typed(0, 2, .5)
-    at 0.0
-    at 0.5
-    at 1.0
-    at 1.5
-    2.0
-    >>> double_step_py_target(0, 2, .5)
-    at 0.0
-    at 0.5
-    at 1.0
-    at 1.5
-    2.0
-    >>> int_step_py_target(0, 2, 1)
-    at 0
-    at 1
-    2
-"""
-
-def double_target(a, b):
+    """
     cdef double x
     for x from a <= x < b:
         print u"at", x
     return x
 
 def double_step(a, b, dx):
+    """
+    >>> double_step(0, 2, .5)
+    at 0.0
+    at 0.5
+    at 1.0
+    at 1.5
+    2.0
+    """
     cdef double x
     for x from a <= x < b by dx:
         print u"at", x
     return x
 
 def double_step_typed(a, b, double dx):
+    """
+    >>> double_step_typed(0, 2, .5)
+    at 0.0
+    at 0.5
+    at 1.0
+    at 1.5
+    2.0
+    """
     cdef double x
     for x from a <= x < b by dx:
         print u"at", x
     return x
 
 def double_step_py_target(a, b, double dx):
+    """
+    >>> double_step_py_target(0, 2, .5)
+    at 0.0
+    at 0.5
+    at 1.0
+    at 1.5
+    2.0
+    """
     cdef object x
     for x from a <= x < b by dx:
         print u"at", x
     return x
 
 def int_step_py_target(a, b, int dx):
+    """
+    >>> int_step_py_target(0, 2, 1)
+    at 0
+    at 1
+    2
+    """
     cdef object x
     for x from a <= x < b by dx:
         print u"at", x

tests/run/for_in_range_T372.pyx

-__doc__ = u"""
->>> test_modify()
-0
-1
-2
-3
-4
-<BLANKLINE>
-(4, 0)
->>> test_fix()
-0
-1
-2
-3
-4
-<BLANKLINE>
-4
->>> test_break()
-0
-1
-2
-<BLANKLINE>
-(2, 0)
->>> test_return()
-0
-1
-2
-(2, 0)
-"""
-
 cimport cython
 
 @cython.test_assert_path_exists("//ForFromStatNode")
 @cython.test_fail_if_path_exists("//ForInStatNode")
 def test_modify():
+    """
+    >>> test_modify()
+    0
+    1
+    2
+    3
+    4
+    <BLANKLINE>
+    (4, 0)
+    """
     cdef int i, n = 5
     for i in range(n):
         print i
@@ -43,6 +23,16 @@ def test_modify():
 @cython.test_assert_path_exists("//ForFromStatNode")
 @cython.test_fail_if_path_exists("//ForInStatNode")
 def test_fix():
+    """
+    >>> test_fix()
+    0
+    1
+    2
+    3
+    4
+    <BLANKLINE>
+    4
+    """
     cdef int i
     for i in range(5):
         print i
@@ -52,6 +42,14 @@ def test_fix():
 @cython.test_assert_path_exists("//ForFromStatNode")
 @cython.test_fail_if_path_exists("//ForInStatNode")
 def test_break():
+    """
+    >>> test_break()
+    0
+    1
+    2
+    <BLANKLINE>
+    (2, 0)
+    """
     cdef int i, n = 5
     for i in range(n):
         print i
@@ -66,6 +64,13 @@ def test_break():
 @cython.test_assert_path_exists("//ForFromStatNode")
 @cython.test_fail_if_path_exists("//ForInStatNode")
 def test_return():
+    """
+    >>> test_return()
+    0
+    1
+    2
+    (2, 0)
+    """
     cdef int i, n = 5
     for i in range(n):
         print i

tests/run/forfrom.pyx

-__doc__ = u"""
->>> for_else()
-30
->>> print( u'*'.join(int_comp()) )
-00*01*02
-"""
-
 import sys
 if sys.version_info[0] >= 3:
     __doc__ = __doc__.replace(u" u'", u" '").replace(u' u"', u' "')
 
 def for_else():
+    """
+    >>> for_else()
+    30
+    >>> print( u'*'.join(int_comp()) )
+    00*01*02
+    """
     cdef int i, j=0, k=2
     for i from 0 <= i < 10:
         j += k

tests/run/funcexceptreraise.pyx

-
 import sys
 
 def reraise(f, exc):

tests/run/hash_T326.pyx

@@ -11,8 +11,6 @@ __doc__ = u"""
     ...
     TypeError: That's kind of a round number...
     
-    >>> __hash__(-1)
-    -1
 """
 
 cdef class A:
@@ -26,4 +24,8 @@ cdef class A:
             return self.a
 
 cpdef long __hash__(long x):
+    """
+    >>> __hash__(-1)
+    -1
+    """
     return x

tests/run/if.pyx

-__doc__ = u"""
+def f(a, b):
+    """
     >>> f(0,0)
     0
     >>> f(1,2)
     2
     >>> f(1,-1)
     1
-
-    >>> g(1,2)
-    1
-    >>> g(0,2)
-    2
-    >>> g(0,0)
-    0
-
-    >>> h(1,2)
-    1
-    >>> h(0,2)
-    2
-    >>> h(0,0)
-    3
-
-    >>> i(1,2)
-    1
-    >>> i(2,2)
-    2
-    >>> i(2,1)
-    0
-"""
-
-def f(a, b):
+    """
     x = 0
     if a:
         x = 1
@@ -37,6 +15,14 @@ def f(a, b):
     return x
 
 def g(a, b):
+    """
+    >>> g(1,2)
+    1
+    >>> g(0,2)
+    2
+    >>> g(0,0)
+    0
+    """
     x = 0
     if a:
         x = 1
@@ -45,6 +31,14 @@ def g(a, b):
     return x
     
 def h(a, b):
+    """
+    >>> h(1,2)
+    1
+    >>> h(0,2)
+    2
+    >>> h(0,0)
+    3
+    """
     x = 0
     if a:
         x = 1
@@ -60,6 +54,14 @@ except ImportError:
     import builtins
 
 def i(a, b):
+    """
+    >>> i(1,2)
+    1
+    >>> i(2,2)
+    2
+    >>> i(2,1)
+    0
+    """
     x = 0
     if builtins.str(a).upper() == u"1":
         x = 1

tests/run/importfrom.pyx

-__doc__ = u"""
->>> from distutils import cmd, core, version
->>> import1() == (cmd, core, version)
-True
->>> import2() == (cmd, core, version)
-True
->>> import3() == (cmd, core, version)
-True
->>> import4() == (cmd, core, version)
-True
->>> typed_imports()
-True
-True
-an integer is required
-Expected type, got int
-"""
+from distutils import cmd, core, version
 
 def import1():
+    """
+    >>> import1() == (cmd, core, version)
+    True
+    """
     from distutils import (
 
         cmd,
@@ -25,6 +14,10 @@ core,                    version)
 
 
 def import2():
+    """
+    >>> import2() == (cmd, core, version)
+    True
+    """
     from distutils import (cmd,
 
 core,
@@ -36,16 +29,31 @@ core,
 
 
 def import3():
+    """
+    >>> import3() == (cmd, core, version)
+    True
+    """
     from distutils import (cmd, core,version)
     return cmd, core, version
 
 def import4():
+    """
+    >>> import4() == (cmd, core, version)
+    True
+    """
     from distutils import cmd, core, version
     return cmd, core, version
 
 
 
 def typed_imports():
+    """
+    >>> typed_imports()
+    True
+    True
+    an integer is required
+    Expected type, got int
+    """
 
     import sys
     import types
@@ -66,4 +74,3 @@ def typed_imports():
         from sys import maxunicode as t
     except TypeError, e:
         print e
-

tests/run/index.pyx

-__doc__ = u"""
->>> index_tuple((1,1,2,3,5), 0)
-1
->>> index_tuple((1,1,2,3,5), 3)
-3
->>> index_tuple((1,1,2,3,5), -1)
-5
->>> index_tuple((1,1,2,3,5), 100)
-Traceback (most recent call last):
-...
-IndexError: tuple index out of range
-
->>> index_list([2,3,5,7,11,13,17,19], 0)
-2
->>> index_list([2,3,5,7,11,13,17,19], 5)
-13
->>> index_list([2,3,5,7,11,13,17,19], -1)
-19
->>> index_list([2,3,5,7,11,13,17,19], 100)
-Traceback (most recent call last):
-...
-IndexError: list index out of range
-
->>> index_object([2,3,5,7,11,13,17,19], 1)
-3
->>> index_object([2,3,5,7,11,13,17,19], -1)
-19
->>> index_object((1,1,2,3,5), 2)
-2
->>> index_object((1,1,2,3,5), -2)
-3
->>> index_object("abcdef...z", 0)
-'a'
->>> index_object("abcdef...z", -1)
-'z'
->>> index_object("abcdef...z", 100)
-Traceback (most recent call last):
-...
-IndexError: string index out of range
-
->>> index_object(100, 100)
-Traceback (most recent call last):
-...
-TypeError: 'int' object is unsubscriptable
-
->>> test_unsigned_long()
->>> test_unsigned_short()
->>> test_long_long()
-"""
-
 import sys
 if sys.version_info[0] >= 3:
     __doc__ = __doc__.replace(u'is unsubscriptable', u'is not subscriptable')
@@ -55,18 +5,67 @@ elif sys.version_info < (2,5):
     __doc__ = __doc__.replace(u"'int' object is unsubscriptable", u'unsubscriptable object')
 
 def index_tuple(tuple t, int i):
+    """
+    >>> index_tuple((1,1,2,3,5), 0)
+    1
+    >>> index_tuple((1,1,2,3,5), 3)
+    3
+    >>> index_tuple((1,1,2,3,5), -1)
+    5
+    >>> index_tuple((1,1,2,3,5), 100)
+    Traceback (most recent call last):
+    ...
+    IndexError: tuple index out of range
+    """
     return t[i]
 
 def index_list(list L, int i):
+    """
+    >>> index_list([2,3,5,7,11,13,17,19], 0)
+    2
+    >>> index_list([2,3,5,7,11,13,17,19], 5)
+    13
+    >>> index_list([2,3,5,7,11,13,17,19], -1)
+    19
+    >>> index_list([2,3,5,7,11,13,17,19], 100)
+    Traceback (most recent call last):
+    ...
+    IndexError: list index out of range
+    """
     return L[i]
 
 def index_object(object o, int i):
+    """
+    >>> index_object([2,3,5,7,11,13,17,19], 1)
+    3
+    >>> index_object([2,3,5,7,11,13,17,19], -1)
+    19
+    >>> index_object((1,1,2,3,5), 2)
+    2
+    >>> index_object((1,1,2,3,5), -2)
+    3
+    >>> index_object("abcdef...z", 0)
+    'a'
+    >>> index_object("abcdef...z", -1)
+    'z'
+    >>> index_object("abcdef...z", 100)
+    Traceback (most recent call last):
+    ...
+    IndexError: string index out of range
+    >>> index_object(100, 100)
+    Traceback (most recent call last):
+    ...
+    TypeError: 'int' object is unsubscriptable
+    """
     return o[i]
 
 
 # These make sure that our fast indexing works with large and unsigned types. 
 
 def test_unsigned_long():
+    """
+    >>> test_unsigned_long()
+    """
     cdef int i
     cdef unsigned long ix
     cdef D = {}
@@ -80,6 +79,9 @@ def test_unsigned_long():
     assert len(D) == 0
 
 def test_unsigned_short():
+    """
+    >>> test_unsigned_short()
+    """
     cdef int i
     cdef unsigned short ix
     cdef D = {}
@@ -93,6 +95,9 @@ def test_unsigned_short():
     assert len(D) == 0
 
 def test_long_long():
+    """
+    >>> test_long_long()
+    """
     cdef int i
     cdef long long ix
     cdef D = {}

tests/run/inline.pyx

-__doc__ = u"""
->>> test(3)
-3
-"""
-
 def test(x):
+    """
+    >>> test(3)
+    3
+    """
     return retinput(x)
 
 cdef inline int retinput(int x):
     o = x
     return o
-

tests/run/inop.pyx

-__doc__ = u"""
+def f(a,b):
+    """
     >>> f(1,[1,2,3])
     True
     >>> f(5,[1,2,3])
     False
     >>> f(2,(1,2,3))
     True
+    """
+    result = a in b
+    return result
 
+def g(a,b):
+    """
     >>> g(1,[1,2,3])
     1
     >>> g(5,[1,2,3])
     0
     >>> g(2,(1,2,3))
     1
+    """
+    cdef int result
+    result = a in b
+    return result
 
+def h(b):
+    """
     >>> h([1,2,3,4])
     True
     >>> h([1,3,4])
     False
+    """
+    result = 2 in b
+    return result
 
+def j(b):
+    """
     >>> j([1,2,3,4])
     1
     >>> j([1,3,4])
     0
+    """
+    cdef int result
+    result = 2 in b
+    return result
 
+def k(a):
+    """
     >>> k(1)
     1
     >>> k(5)
     0
+    """
+    cdef int result = a in [1,2,3,4]
+    return result
 
+def m(int a):
+    """
     >>> m(2)
     1
     >>> m(5)
     0
+    """
+    cdef int result = a in [1,2,3,4]
+    return result
 
+def n(a):
+    """
     >>> n('d *')
     1
     >>> n('xxx')
     0
+    """
+    cdef int result = a.lower() in [u'a *',u'b *',u'c *',u'd *']
+    return result
 
+def p(a):
+    """
     >>> p(1)
     0
     >>> p('a')
     1
+    """
+    cdef dict d = {u'a': 1, u'b': 2}
+    cdef int result = a in d
+    return result
 
+def q(a):
+    """
     >>> q(1)
     Traceback (most recent call last):
     TypeError: 'NoneType' object is not iterable
-
-    >>> l = [1,2,3,4]
+        >>> l = [1,2,3,4]
     >>> l2 = [l[1:],l[:-1],l]
     >>> 2 in l in l2
     True
-    >>> r(2)
-    1
-    >>> s(2)
-    1
-"""
-
-def f(a,b):
-    result = a in b
-    return result
-
-def g(a,b):
-    cdef int result
-    result = a in b
-    return result
-
-def h(b):
-    result = 2 in b
-    return result
-
-def j(b):
-    cdef int result
-    result = 2 in b
-    return result
-
-def k(a):
-    cdef int result = a in [1,2,3,4]
-    return result
-
-def m(int a):
-    cdef int result = a in [1,2,3,4]
-    return result
-
-def n(a):
-    cdef int result = a.lower() in [u'a *',u'b *',u'c *',u'd *']
-    return result
-
-def p(a):
-    cdef dict d = {u'a': 1, u'b': 2}
-    cdef int result = a in d
-    return result
-
-def q(a):
+    """
     cdef dict d = None
     cdef int result = a in d # should fail with a TypeError
     return result
 
 def r(a):
+    """
+    >>> r(2)
+    1
+    """
     l = [1,2,3,4]
     l2 = [l[1:],l[:-1],l]
     cdef int result = a in l in l2
     return result
 
 def s(a):
+    """
+    >>> s(2)
+    1
+    """
     cdef int result = a in [1,2,3,4] in [[1,2,3],[2,3,4],[1,2,3,4]]
     return result

tests/run/inplace.pyx

@@ -2,27 +2,6 @@ __doc__ = u"""
     >>> str(f(5, 7))
     '29509034655744'
 
-    >>> g(13, 4)
-    32
-
-    >>> h(56, 7)
-    105.0
-
-    >>> arrays()
-    19
-
-    >>> attributes()
-    26 26 26
-
-    >>> smoketest()
-    10
-
-    >>> test_side_effects()
-    side effect 1
-    c side effect 2
-    side effect 3
-    c side effect 4
-    ([0, 11, 102, 3, 4], [0, 1, 2, 13, 104])
 """
 
 def f(a,b):
@@ -32,12 +11,20 @@ def f(a,b):
     return a
 
 def g(int a, int b):
+    """
+    >>> g(13, 4)
+    32
+    """
     a -= b
     a /= b
     a <<= b
     return a
 
 def h(double a, double b):
+    """
+    >>> h(56, 7)
+    105.0
+    """
     a /= b
     a += b
     a *= b
@@ -46,6 +33,10 @@ def h(double a, double b):
 cimport stdlib
 
 def arrays():
+    """
+    >>> arrays()
+    19
+    """
     cdef char* buf = <char*>stdlib.malloc(10)
     cdef int i = 2
     cdef object j = 2
@@ -68,6 +59,10 @@ class B:
     attr = 3
 
 def attributes():
+    """
+    >>> attributes()
+    26 26 26
+    """
     cdef A a = A()
     b = B()
     a.attr += 10
@@ -82,6 +77,10 @@ def get_2(): return 2
 cdef int identity(int value): return value
 
 def smoketest():
+    """
+    >>> smoketest()
+    10
+    """
     cdef char* buf = <char*>stdlib.malloc(10)
     cdef A a = A()
     a.buf = buf
@@ -100,6 +99,14 @@ cdef int c_side_effect(int x):
     return x
     
 def test_side_effects():
+    """
+    >>> test_side_effects()
+    side effect 1
+    c side effect 2
+    side effect 3
+    c side effect 4
+    ([0, 11, 102, 3, 4], [0, 1, 2, 13, 104])
+    """
     a = list(range(5))
     a[side_effect(1)] += 10
     a[c_side_effect(2)] += 100

tests/run/int_literals.pyx

-__doc__ = u"""
-    >>> c_longs()
-    (1, 1L, -1L, 18446744073709551615L)
-    >>> py_longs()
-    (1, 1L, 100000000000000000000000000000000L, -100000000000000000000000000000000L)
-"""
-
 import sys
 
 if sys.version_info[0] >= 3:
     __doc__ = __doc__.replace(u'L', u'')
 
 def c_longs():
+    """
+    >>> c_longs()
+    (1, 1L, -1L, 18446744073709551615L)
+    """
     cdef long a = 1L
     cdef unsigned long ua = 1UL
     cdef long long aa = 0xFFFFFFFFFFFFFFFFLL
@@ -19,4 +16,8 @@ def c_longs():
     return a, ua, aa, uaa
     
 def py_longs():
+    """
+    >>> py_longs()
+    (1, 1L, 100000000000000000000000000000000L, -100000000000000000000000000000000L)
+    """
     return 1, 1L, 100000000000000000000000000000000, -100000000000000000000000000000000

tests/run/ishimoto2.pyx

-__doc__ = u"""
+import sys
+if sys.version_info[0] >= 3:
+    __doc__ = __doc__.replace(u" u'", u" '")
+
+class C:
+    """
     >>> C().xxx(5)
     5
     >>> C().xxx()
@@ -7,12 +12,6 @@ __doc__ = u"""
     42
     >>> C().xxx()
     u'a b'
-"""
-
-import sys
-if sys.version_info[0] >= 3:
-    __doc__ = __doc__.replace(u" u'", u" '")
-
-class C:
+    """
     def xxx(self, p=u"a b"):
         return p

tests/run/isinstance.pyx

-__doc__ = u"""
->>> test_all()
-True
-"""
 cdef class A:
     pass
 
@@ -9,6 +5,10 @@ import sys
 IS_PY3 = sys.version_info[0] >= 3
 
 def test_all():
+    """
+    >>> test_all()
+    True
+    """
     if IS_PY3:
         new_type = type(u'a',(),{})
     else:

tests/run/isnonebool.pyx

-__doc__ = u"""
+def test_and(a,b):
+    """
     >>> test_and(None, None)
     True
     >>> test_and(None, 1)
     False
     >>> test_and(1, None)
     False
+    """
+    return a is None and b is None
 
+def test_more(a,b):
+    """
     >>> test_more(None, None)
     True
     >>> test_more(None, 1)
@@ -14,7 +19,11 @@ __doc__ = u"""
     False
     >>> test_more(None, 0)
     False
+    """
+    return a is None and (b is None or b == 1)
 
+def test_more_c(a,b):
+    """
     >>> test_more_c(None, None)
     True
     >>> test_more_c(None, 1)
@@ -23,13 +32,5 @@ __doc__ = u"""
     False
     >>> test_more_c(None, 0)
     False
-"""
-
-def test_and(a,b):
-    return a is None and b is None
-
-def test_more(a,b):
-    return a is None and (b is None or b == 1)
-
-def test_more_c(a,b):
+    """
     return (a is None or 1 == 2) and (b is None or b == 1)

tests/run/iteratorexception.pyx

-__doc__ = u"""
-    >>> f()
-"""
-
 class IteratorAndIterateable:
     def next(self):
         raise ValueError
@@ -11,6 +7,9 @@ class IteratorAndIterateable:
         return self
 
 def f():
+    """
+    >>> f()
+    """
     try:
         for x in IteratorAndIterateable():
             pass

tests/run/iterdict.pyx

-__doc__ = u"""
->>> dict_size = 4
->>> d = dict(zip(range(10,dict_size+10), range(dict_size)))
-
->>> items(d)
-[(10, 0), (11, 1), (12, 2), (13, 3)]
->>> iteritems(d)
-[(10, 0), (11, 1), (12, 2), (13, 3)]
->>> iteritems_int(d)
-[(10, 0), (11, 1), (12, 2), (13, 3)]
->>> iteritems_tuple(d)
-[(10, 0), (11, 1), (12, 2), (13, 3)]
->>> iterkeys(d)
-[10, 11, 12, 13]
->>> iterkeys_int(d)
-[10, 11, 12, 13]
->>> iterdict(d)
-[10, 11, 12, 13]
->>> iterdict_reassign(d)
-[10, 11, 12, 13]
->>> iterdict_int(d)
-[10, 11, 12, 13]
->>> itervalues(d)
-[0, 1, 2, 3]
->>> itervalues_int(d)
-[0, 1, 2, 3]
-"""
+dict_size = 4
+d = dict(zip(range(10,dict_size+10), range(dict_size)))
 
 def items(dict d):
+    """
+    >>> items(d)
+    [(10, 0), (11, 1), (12, 2), (13, 3)]
+    """
     l = []
     for k,v in d.items():
         l.append((k,v))
@@ -34,6 +13,10 @@ def items(dict d):
     return l
 
 def iteritems(dict d):
+    """
+    >>> iteritems(d)
+    [(10, 0), (11, 1), (12, 2), (13, 3)]
+    """
     l = []
     for k,v in d.iteritems():
         l.append((k,v))
@@ -41,6 +24,10 @@ def iteritems(dict d):
     return l
 
 def iteritems_int(dict d):
+    """
+    >>> iteritems_int(d)
+    [(10, 0), (11, 1), (12, 2), (13, 3)]
+    """
     cdef int k,v
     l = []
     for k,v in d.iteritems():
@@ -49,6 +36,10 @@ def iteritems_int(dict d):
     return l
 
 def iteritems_tuple(dict d):
+    """
+    >>> iteritems_tuple(d)
+    [(10, 0), (11, 1), (12, 2), (13, 3)]
+    """
     l = []
     for t in d.iteritems():
         l.append(t)
@@ -61,6 +52,10 @@ def iteritems_listcomp(dict d):
     return l
 
 def iterkeys(dict d):
+    """
+    >>> iterkeys(d)
+    [10, 11, 12, 13]
+    """
     l = []
     for k in d.iterkeys():
         l.append(k)
@@ -68,6 +63,10 @@ def iterkeys(dict d):
     return l
 
 def iterkeys_int(dict d):
+    """
+    >>> iterkeys_int(d)
+    [10, 11, 12, 13]
+    """
     cdef int k
     l = []
     for k in d.iterkeys():
@@ -76,6 +75,10 @@ def iterkeys_int(dict d):
     return l
 
 def iterdict(dict d):
+    """
+    >>> iterdict(d)
+    [10, 11, 12, 13]
+    """
     l = []
     for k in d:
         l.append(k)
@@ -83,6 +86,10 @@ def iterdict(dict d):
     return l
 
 def iterdict_int(dict d):
+    """
+    >>> iterdict_int(d)
+    [10, 11, 12, 13]
+    """
     cdef int k
     l = []
     for k in d:
@@ -91,6 +98,10 @@ def iterdict_int(dict d):
     return l
 
 def iterdict_reassign(dict d):
+    """
+    >>> iterdict_reassign(d)
+    [10, 11, 12, 13]
+    """
     cdef dict d_new = {}
     l = []
     for k in d:
@@ -105,6 +116,10 @@ def iterdict_listcomp(dict d):
     return l
 
 def itervalues(dict d):
+    """
+    >>> itervalues(d)
+    [0, 1, 2, 3]
+    """
     l = []
     for v in d.itervalues():
         l.append(v)
@@ -112,6 +127,10 @@ def itervalues(dict d):
     return l
 
 def itervalues_int(dict d):
+    """
+    >>> itervalues_int(d)
+    [0, 1, 2, 3]
+    """
     cdef int v
     l = []
     for v in d.itervalues():

tests/run/king1.pyx

-__doc__ = u"""
->>> uf()
-It works!
->>> bf()
-It works!
-"""
-
 DEF USTUFF = u"Spam"
 
 def uf():
+    """
+    >>> uf()
+    It works!
+    """
     IF USTUFF == u"Spam":
         print "It works!"
     ELSE:
@@ -16,6 +13,10 @@ def uf():
 DEF BSTUFF = b"Spam"
 
 def bf():
+    """
+    >>> bf()
+    It works!
+    """
     IF BSTUFF == b"Spam":
         print "It works!"
     ELSE:

tests/run/kwargproblems.pyx

-__doc__ = u"""
+import sys
+
+def test(**kw):
+    """
     >>> d = {1 : 2}
     >>> test(**d)
     Traceback (most recent call last):
     TypeError: test() keywords must be strings
     >>> d
     {1: 2}
-
     >>> d = {}
     >>> test(**d)
     {'arg': 3}
     >>> d
     {}
-
     >>> d = {'arg' : 2} # this should be u'arg', but Py2 can't handle it...
     >>> test(**d)
     {'arg': 3}
     >>> d
     {'arg': 2}
-"""
-
-import sys
-
-def test(**kw):
+    """
     if sys.version_info[0] >= 3:
         kw[u'arg'] = 3
     else:

tests/run/kwonlyargs.pyx

-__doc__ = u"""
+def b(a, b, c):
+    """
     >>> b(1,2,3)
     >>> b(1,2,3,4)
     Traceback (most recent call last):
     TypeError: b() takes exactly 3 positional arguments (4 given)
+    """
+    a, b, c = b, c, a
 
+def c(a, b, c=1):
+    """
     >>> c(1,2)
     >>> c(1,2,3)
     >>> c(1,2,3,4)
     Traceback (most recent call last):
     TypeError: c() takes at most 3 positional arguments (4 given)
+    """
+    a, b, c = b, c, a
 
+def d(a, b, *, c = 88):
+    """
     >>> d(1,2)
     >>> d(1,2, c=1)
-
     >>> d(1,2,3)
     Traceback (most recent call last):
     TypeError: d() takes exactly 2 positional arguments (3 given)
     >>> d(1,2, d=1)
     Traceback (most recent call last):
     TypeError: d() got an unexpected keyword argument 'd'
+    """
+    a, b, c = b, c, a
 
+def e(a, b, c = 88, **kwds):
+    """
     >>> e(1,2)
     >>> e(1,2, c=1)
     >>> e(1,2, d=1)
@@ -28,10 +40,13 @@ __doc__ = u"""
     >>> e(1,2,3,4)
     Traceback (most recent call last):
     TypeError: e() takes at most 3 positional arguments (4 given)
+    """
+    a, b, c = b, c, a
 
+def f(a, b, *, c, d = 42):
+    """
     >>> f(1,2, c=1)
     >>> f(1,2, c=1, d=2)
-
     >>> f(1,2,3)
     Traceback (most recent call last):
     TypeError: f() takes exactly 2 positional arguments (3 given)
@@ -41,11 +56,14 @@ __doc__ = u"""
     >>> f(1,2, c=1, e=2)
     Traceback (most recent call last):
     TypeError: f() got an unexpected keyword argument 'e'
+    """
+    a, b, c, d = b, c, d, a
 
+def g(a, b, *, c, d = 42, e = 17, f, **kwds):
+    """
     >>> g(1,2, c=1, f=2)
     >>> g(1,2, c=1, e=0, f=2, d=11)
     >>> g(1,2, c=1, f=2, e=0, x=25)
-
     >>> g(1,2,3)
     Traceback (most recent call last):
     TypeError: g() takes exactly 2 positional arguments (3 given)
@@ -55,81 +73,64 @@ __doc__ = u"""
     >>> g(1,2, c=1)
     Traceback (most recent call last):
     TypeError: g() needs keyword-only argument f
+    """
+    a, b, c, d, e, f = b, c, d, e, f, a
 
+def h(a, b, *args, c, d = 42, e = 17, f, **kwds):
+    """
     >>> h(1,2, c=1, f=2)
     >>> h(1,2, c=1, f=2, e=3)
     >>> h(1,2,3,4,5,6, c=1, f=2)
     >>> h(1,2,3,4,5,6, c=1, f=2, e=3, x=25, y=11)
-
     >>> h(1,2,3)
     Traceback (most recent call last):
     TypeError: h() needs keyword-only argument c
     >>> h(1,2, d=1)
     Traceback (most recent call last):
     TypeError: h() needs keyword-only argument c
+    """
+    a, b, c, d, e, f = b, c, d, e, f, a
 
+def k(a, b, c=1, *args, d = 42, e = 17, f, **kwds):
+    """
     >>> k(1,2, c=1, f=2)
     >>> k(1,2, c=1, f=2, e=3)
     >>> k(1,2,3,4,5,6, d=1, f=2)
     >>> k(1,2,3,4,5,6, d=1, f=2, e=3, x=25, y=11)
-
     >>> k(1,2,3)
     Traceback (most recent call last):
     TypeError: k() needs keyword-only argument f
     >>> k(1,2, d=1)
     Traceback (most recent call last):
     TypeError: k() needs keyword-only argument f
+    """
+    a, b, c, d, e, f = b, c, d, e, f, a
 
+def l(*, a, b, c = 88):
+    """
     >>> l(a=1, b=2)
     >>> l(a=1, b=2, c=1)
-
     >>> l(1,2,3)
     Traceback (most recent call last):
     TypeError: l() takes exactly 0 positional arguments (3 given)
     >>> l(1,2, d=1)
     Traceback (most recent call last):
     TypeError: l() takes exactly 0 positional arguments (2 given)
-
-    >>> m(1, b=2)
-    >>> m(a=1, b=2)
-    >>> m(a=1, b=2, c=1)
-
     >>> l(1,2,3)
     Traceback (most recent call last):
     TypeError: l() takes exactly 0 positional arguments (3 given)
     >>> l(1,2, d=1)
     Traceback (most recent call last):
     TypeError: l() takes exactly 0 positional arguments (2 given)
-"""
-
-def b(a, b, c):
-    a, b, c = b, c, a
-
-def c(a, b, c=1):
-    a, b, c = b, c, a
-
-def d(a, b, *, c = 88):
-    a, b, c = b, c, a
-
-def e(a, b, c = 88, **kwds):
-    a, b, c = b, c, a
-
-def f(a, b, *, c, d = 42):
-    a, b, c, d = b, c, d, a
-
-def g(a, b, *, c, d = 42, e = 17, f, **kwds):
-    a, b, c, d, e, f = b, c, d, e, f, a
-
-def h(a, b, *args, c, d = 42, e = 17, f, **kwds):
-    a, b, c, d, e, f = b, c, d, e, f, a
-
-def k(a, b, c=1, *args, d = 42, e = 17, f, **kwds):
-    a, b, c, d, e, f = b, c, d, e, f, a
-
-def l(*, a, b, c = 88):
+    """
     a, b, c = b, c, a
 
 def m(a, *, b, c = 88):
+    """
+    >>> m(1, b=2)
+    >>> m(a=1, b=2)
+    >>> m(a=1, b=2, c=1)
+    """
     a, b, c = b, c, a
 
 def n(a, *, b, c = 88):