diff --git a/Lib/test/output/test_extcall b/Lib/test/output/test_extcall
deleted file mode 100644
index a569e53..0000000
--- a/Lib/test/output/test_extcall
+++ /dev/null
@@ -1,115 +0,0 @@
-test_extcall
-() {}
-(1,) {}
-(1, 2) {}
-(1, 2, 3) {}
-(1, 2, 3, 4, 5) {}
-(1, 2, 3, 4, 5) {}
-(1, 2, 3, 4, 5) {}
-(1, 2, 3) {'a': 4, 'b': 5}
-(1, 2, 3, 4, 5) {'a': 6, 'b': 7}
-(1, 2, 3, 6, 7) {'a': 8, 'b': 9, 'x': 4, 'y': 5}
-(1, 2, 3) {'a': 4, 'b': 5}
-(1, 2, 3, 4, 5) {'a': 6, 'b': 7}
-(1, 2, 3, 6, 7) {'a': 8, 'b': 9, 'x': 4, 'y': 5}
-TypeError: g() takes at least 1 argument (0 given)
-TypeError: g() takes at least 1 argument (0 given)
-TypeError: g() takes at least 1 argument (0 given)
-1 () {}
-1 (2,) {}
-1 (2, 3) {}
-1 (2, 3, 4, 5) {}
-0 (1, 2) {}
-0 (1, 2, 3) {}
-1 () {'a': 1, 'b': 2, 'c': 3, 'd': 4}
-{'a': 1, 'b': 2, 'c': 3}
-{'a': 1, 'b': 2, 'c': 3}
-g() got multiple values for keyword argument 'x'
-g() got multiple values for keyword argument 'b'
-f() keywords must be strings
-h() got an unexpected keyword argument 'e'
-h() argument after * must be a sequence, not function
-dir() argument after * must be a sequence, not function
-NoneType object argument after * must be a sequence, not function
-h() argument after ** must be a mapping, not function
-dir() argument after ** must be a mapping, not function
-NoneType object argument after ** must be a mapping, not function
-dir() got multiple values for keyword argument 'b'
-3 512 True
-3
-3
-za () {} -> za() takes exactly 1 argument (0 given)
-za () {'a': 'aa'} -> ok za aa B D E V a
-za () {'d': 'dd'} -> za() got an unexpected keyword argument 'd'
-za () {'a': 'aa', 'd': 'dd'} -> za() got an unexpected keyword argument 'd'
-za () {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> za() got an unexpected keyword argument 'b'
-za (1, 2) {} -> za() takes exactly 1 argument (2 given)
-za (1, 2) {'a': 'aa'} -> za() takes exactly 1 non-keyword argument (2 given)
-za (1, 2) {'d': 'dd'} -> za() takes exactly 1 non-keyword argument (2 given)
-za (1, 2) {'a': 'aa', 'd': 'dd'} -> za() takes exactly 1 non-keyword argument (2 given)
-za (1, 2) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> za() takes exactly 1 non-keyword argument (2 given)
-za (1, 2, 3, 4, 5) {} -> za() takes exactly 1 argument (5 given)
-za (1, 2, 3, 4, 5) {'a': 'aa'} -> za() takes exactly 1 non-keyword argument (5 given)
-za (1, 2, 3, 4, 5) {'d': 'dd'} -> za() takes exactly 1 non-keyword argument (5 given)
-za (1, 2, 3, 4, 5) {'a': 'aa', 'd': 'dd'} -> za() takes exactly 1 non-keyword argument (5 given)
-za (1, 2, 3, 4, 5) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> za() takes exactly 1 non-keyword argument (5 given)
-zade () {} -> zade() takes at least 1 argument (0 given)
-zade () {'a': 'aa'} -> ok zade aa B d e V a
-zade () {'d': 'dd'} -> zade() takes at least 1 non-keyword argument (0 given)
-zade () {'a': 'aa', 'd': 'dd'} -> ok zade aa B dd e V d
-zade () {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zade() got an unexpected keyword argument 'b'
-zade (1, 2) {} -> ok zade 1 B 2 e V e
-zade (1, 2) {'a': 'aa'} -> zade() got multiple values for keyword argument 'a'
-zade (1, 2) {'d': 'dd'} -> zade() got multiple values for keyword argument 'd'
-zade (1, 2) {'a': 'aa', 'd': 'dd'} -> zade() got multiple values for keyword argument 'a'
-zade (1, 2) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zade() got multiple values for keyword argument 'a'
-zade (1, 2, 3, 4, 5) {} -> zade() takes at most 3 arguments (5 given)
-zade (1, 2, 3, 4, 5) {'a': 'aa'} -> zade() takes at most 3 non-keyword arguments (5 given)
-zade (1, 2, 3, 4, 5) {'d': 'dd'} -> zade() takes at most 3 non-keyword arguments (5 given)
-zade (1, 2, 3, 4, 5) {'a': 'aa', 'd': 'dd'} -> zade() takes at most 3 non-keyword arguments (5 given)
-zade (1, 2, 3, 4, 5) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zade() takes at most 3 non-keyword arguments (5 given)
-zabk () {} -> zabk() takes exactly 2 arguments (0 given)
-zabk () {'a': 'aa'} -> zabk() takes exactly 2 non-keyword arguments (1 given)
-zabk () {'d': 'dd'} -> zabk() takes exactly 2 non-keyword arguments (0 given)
-zabk () {'a': 'aa', 'd': 'dd'} -> zabk() takes exactly 2 non-keyword arguments (1 given)
-zabk () {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> ok zabk aa bb D E V {'d': 'dd', 'e': 'ee'}
-zabk (1, 2) {} -> ok zabk 1 2 D E V {}
-zabk (1, 2) {'a': 'aa'} -> zabk() got multiple values for keyword argument 'a'
-zabk (1, 2) {'d': 'dd'} -> ok zabk 1 2 D E V {'d': 'dd'}
-zabk (1, 2) {'a': 'aa', 'd': 'dd'} -> zabk() got multiple values for keyword argument 'a'
-zabk (1, 2) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zabk() got multiple values for keyword argument 'a'
-zabk (1, 2, 3, 4, 5) {} -> zabk() takes exactly 2 arguments (5 given)
-zabk (1, 2, 3, 4, 5) {'a': 'aa'} -> zabk() takes exactly 2 non-keyword arguments (5 given)
-zabk (1, 2, 3, 4, 5) {'d': 'dd'} -> zabk() takes exactly 2 non-keyword arguments (5 given)
-zabk (1, 2, 3, 4, 5) {'a': 'aa', 'd': 'dd'} -> zabk() takes exactly 2 non-keyword arguments (5 given)
-zabk (1, 2, 3, 4, 5) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zabk() takes exactly 2 non-keyword arguments (5 given)
-zabdv () {} -> zabdv() takes at least 2 arguments (0 given)
-zabdv () {'a': 'aa'} -> zabdv() takes at least 2 non-keyword arguments (1 given)
-zabdv () {'d': 'dd'} -> zabdv() takes at least 2 non-keyword arguments (0 given)
-zabdv () {'a': 'aa', 'd': 'dd'} -> zabdv() takes at least 2 non-keyword arguments (1 given)
-zabdv () {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zabdv() got an unexpected keyword argument 'e'
-zabdv (1, 2) {} -> ok zabdv 1 2 d E () e
-zabdv (1, 2) {'a': 'aa'} -> zabdv() got multiple values for keyword argument 'a'
-zabdv (1, 2) {'d': 'dd'} -> ok zabdv 1 2 dd E () d
-zabdv (1, 2) {'a': 'aa', 'd': 'dd'} -> zabdv() got multiple values for keyword argument 'a'
-zabdv (1, 2) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zabdv() got multiple values for keyword argument 'a'
-zabdv (1, 2, 3, 4, 5) {} -> ok zabdv 1 2 3 E (4, 5) e
-zabdv (1, 2, 3, 4, 5) {'a': 'aa'} -> zabdv() got multiple values for keyword argument 'a'
-zabdv (1, 2, 3, 4, 5) {'d': 'dd'} -> zabdv() got multiple values for keyword argument 'd'
-zabdv (1, 2, 3, 4, 5) {'a': 'aa', 'd': 'dd'} -> zabdv() got multiple values for keyword argument 'a'
-zabdv (1, 2, 3, 4, 5) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zabdv() got multiple values for keyword argument 'a'
-zabdevk () {} -> zabdevk() takes at least 2 arguments (0 given)
-zabdevk () {'a': 'aa'} -> zabdevk() takes at least 2 non-keyword arguments (1 given)
-zabdevk () {'d': 'dd'} -> zabdevk() takes at least 2 non-keyword arguments (0 given)
-zabdevk () {'a': 'aa', 'd': 'dd'} -> zabdevk() takes at least 2 non-keyword arguments (1 given)
-zabdevk () {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> ok zabdevk aa bb dd ee () {}
-zabdevk (1, 2) {} -> ok zabdevk 1 2 d e () {}
-zabdevk (1, 2) {'a': 'aa'} -> zabdevk() got multiple values for keyword argument 'a'
-zabdevk (1, 2) {'d': 'dd'} -> ok zabdevk 1 2 dd e () {}
-zabdevk (1, 2) {'a': 'aa', 'd': 'dd'} -> zabdevk() got multiple values for keyword argument 'a'
-zabdevk (1, 2) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zabdevk() got multiple values for keyword argument 'a'
-zabdevk (1, 2, 3, 4, 5) {} -> ok zabdevk 1 2 3 4 (5,) {}
-zabdevk (1, 2, 3, 4, 5) {'a': 'aa'} -> zabdevk() got multiple values for keyword argument 'a'
-zabdevk (1, 2, 3, 4, 5) {'d': 'dd'} -> zabdevk() got multiple values for keyword argument 'd'
-zabdevk (1, 2, 3, 4, 5) {'a': 'aa', 'd': 'dd'} -> zabdevk() got multiple values for keyword argument 'a'
-zabdevk (1, 2, 3, 4, 5) {'a': 'aa', 'b': 'bb', 'd': 'dd', 'e': 'ee'} -> zabdevk() got multiple values for keyword argument 'a'
diff --git a/Lib/test/test_extcall.py b/Lib/test/test_extcall.py
index bdf8e03..b6dc144 100644
--- a/Lib/test/test_extcall.py
+++ b/Lib/test/test_extcall.py
@@ -1,286 +1,262 @@
-from test.test_support import verify, TestFailed, sortdict
-from UserList import UserList
-from UserDict import UserDict
+"""Doctest for method/function calls.
 
-def e(a, b):
-    print a, b
+We're going the use these types for extra testing
 
-def f(*a, **k):
-    print a, sortdict(k)
+    >>> from UserList import UserList
+    >>> from UserDict import UserDict
 
-def g(x, *y, **z):
-    print x, y, sortdict(z)
+We're defining four helper functions
 
-def h(j=1, a=2, h=3):
-    print j, a, h
+    >>> def e(a,b):
+    ...     print a, b
 
-f()
-f(1)
-f(1, 2)
-f(1, 2, 3)
+    >>> def f(*a, **k):
+    ...     print a, test_support.sortdict(k)
 
-f(1, 2, 3, *(4, 5))
-f(1, 2, 3, *[4, 5])
-f(1, 2, 3, *UserList([4, 5]))
-f(1, 2, 3, **{'a':4, 'b':5})
-f(1, 2, 3, *(4, 5), **{'a':6, 'b':7})
-f(1, 2, 3, x=4, y=5, *(6, 7), **{'a':8, 'b':9})
+    >>> def g(x, *y, **z):
+    ...     print x, y, test_support.sortdict(z)
+
+    >>> def h(j=1, a=2, h=3):
+    ...     print j, a, h
+
+Argument list examples
+
+    >>> f()
+    () {}
+    >>> f(1)
+    (1,) {}
+    >>> f(1, 2)
+    (1, 2) {}
+    >>> f(1, 2, 3)
+    (1, 2, 3) {}
+    >>> f(1, 2, 3, *(4, 5))
+    (1, 2, 3, 4, 5) {}
+    >>> f(1, 2, 3, *[4, 5])
+    (1, 2, 3, 4, 5) {}
+    >>> f(1, 2, 3, *UserList([4, 5]))
+    (1, 2, 3, 4, 5) {}
+
+Here we add keyword arguments
+
+    >>> f(1, 2, 3, **{'a':4, 'b':5})
+    (1, 2, 3) {'a': 4, 'b': 5}
+    >>> f(1, 2, 3, *[4, 5], **{'a':6, 'b':7})
+    (1, 2, 3, 4, 5) {'a': 6, 'b': 7}
+    >>> f(1, 2, 3, x=4, y=5, *(6, 7), **{'a':8, 'b': 9})
+    (1, 2, 3, 6, 7) {'a': 8, 'b': 9, 'x': 4, 'y': 5}
+
+    >>> f(1, 2, 3, **UserDict(a=4, b=5))
+    (1, 2, 3) {'a': 4, 'b': 5}
+    >>> f(1, 2, 3, *(4, 5), **UserDict(a=6, b=7))
+    (1, 2, 3, 4, 5) {'a': 6, 'b': 7}
+    >>> f(1, 2, 3, x=4, y=5, *(6, 7), **UserDict(a=8, b=9))
+    (1, 2, 3, 6, 7) {'a': 8, 'b': 9, 'x': 4, 'y': 5}
+
+Examples with invalid arguments (TypeErrors). We're also testing the function
+names in the exception messages.
+
+Verify clearing of SF bug #733667
+
+    >>> e(c=4)
+    Traceback (most recent call last):
+      ...
+    TypeError: e() got an unexpected keyword argument 'c'
+
+    >>> g()
+    Traceback (most recent call last):
+      ...
+    TypeError: g() takes at least 1 argument (0 given)
+
+    >>> g(*())
+    Traceback (most recent call last):
+      ...
+    TypeError: g() takes at least 1 argument (0 given)
+
+    >>> g(*(), **{})
+    Traceback (most recent call last):
+      ...
+    TypeError: g() takes at least 1 argument (0 given)
+
+    >>> g(1)
+    1 () {}
+    >>> g(1, 2)
+    1 (2,) {}
+    >>> g(1, 2, 3)
+    1 (2, 3) {}
+    >>> g(1, 2, 3, *(4, 5))
+    1 (2, 3, 4, 5) {}
+
+    >>> class Nothing: pass
+    ...
+    >>> g(*Nothing())
+    Traceback (most recent call last):
+      ...
+    TypeError: g() argument after * must be a sequence, not instance
+
+    >>> class Nothing:
+    ...     def __len__(self): return 5
+    ...
+
+    >>> g(*Nothing())
+    Traceback (most recent call last):
+      ...
+    TypeError: g() argument after * must be a sequence, not instance
+
+    >>> class Nothing():
+    ...     def __len__(self): return 5
+    ...     def __getitem__(self, i):
+    ...         if i<3: return i
+    ...         else: raise IndexError(i)
+    ...
+
+    >>> g(*Nothing())
+    0 (1, 2) {}
+
+    >>> class Nothing:
+    ...     def __init__(self): self.c = 0
+    ...     def __iter__(self): return self
+    ...     def next(self):
+    ...         if self.c == 4:
+    ...             raise StopIteration
+    ...         c = self.c
+    ...         self.c += 1
+    ...         return c
+    ...
+
+    >>> g(*Nothing())
+    0 (1, 2, 3) {}
+
+Make sure that the function doesn't stomp the dictionary
+
+    >>> d = {'a': 1, 'b': 2, 'c': 3}
+    >>> d2 = d.copy()
+    >>> g(1, d=4, **d)
+    1 () {'a': 1, 'b': 2, 'c': 3, 'd': 4}
+    >>> d == d2
+    True
+
+What about willful misconduct?
+
+    >>> def saboteur(**kw):
+    ...     kw['x'] = 'm'
+    ...     return kw
+
+    >>> d = {}
+    >>> kw = saboteur(a=1, **d)
+    >>> d
+    {}
 
 
-f(1, 2, 3, **UserDict(a=4, b=5))
-f(1, 2, 3, *(4, 5), **UserDict(a=6, b=7))
-f(1, 2, 3, x=4, y=5, *(6, 7), **UserDict(a=8, b=9))
+    >>> g(1, 2, 3, **{'x': 4, 'y': 5})
+    Traceback (most recent call last):
+      ...
+    TypeError: g() got multiple values for keyword argument 'x'
+
+    >>> f(**{1:2})
+    Traceback (most recent call last):
+      ...
+    TypeError: f() keywords must be strings
+
+    >>> h(**{'e': 2})
+    Traceback (most recent call last):
+      ...
+    TypeError: h() got an unexpected keyword argument 'e'
+
+    >>> h(*h)
+    Traceback (most recent call last):
+      ...
+    TypeError: h() argument after * must be a sequence, not function
+
+    >>> dir(*h)
+    Traceback (most recent call last):
+      ...
+    TypeError: dir() argument after * must be a sequence, not function
+
+    >>> None(*h)
+    Traceback (most recent call last):
+      ...
+    TypeError: NoneType object argument after * must be a sequence, \
+not function
+
+    >>> h(**h)
+    Traceback (most recent call last):
+      ...
+    TypeError: h() argument after ** must be a mapping, not function
+
+    >>> dir(**h)
+    Traceback (most recent call last):
+      ...
+    TypeError: dir() argument after ** must be a mapping, not function
+
+    >>> None(**h)
+    Traceback (most recent call last):
+      ...
+    TypeError: NoneType object argument after ** must be a mapping, \
+not function
+
+    >>> dir(b=1, **{'b': 1})
+    Traceback (most recent call last):
+      ...
+    TypeError: dir() got multiple values for keyword argument 'b'
+
+Another helper function
+
+    >>> def f2(*a, **b):
+    ...     return a, b
 
 
-# Verify clearing of SF bug #733667
-try:
-    e(c=3)
-except TypeError:
-    pass
-else:
-    print "should raise TypeError: e() got an unexpected keyword argument 'c'"
+    >>> d = {}
+    >>> for i in xrange(512):
+    ...     key = 'k%d' % i
+    ...     d[key] = i
+    >>> a, b = f2(1, *(2,3), **d)
+    >>> len(a), len(b), b == d
+    (3, 512, True)
 
-try:
-    g()
-except TypeError, err:
-    print "TypeError:", err
-else:
-    print "should raise TypeError: not enough arguments; expected 1, got 0"
+    >>> class Foo:
+    ...     def method(self, arg1, arg2):
+    ...         return arg1+arg2
 
-try:
-    g(*())
-except TypeError, err:
-    print "TypeError:", err
-else:
-    print "should raise TypeError: not enough arguments; expected 1, got 0"
+    >>> x = Foo()
+    >>> Foo.method(*(x, 1, 2))
+    3
+    >>> Foo.method(x, *(1, 2))
+    3
+    >>> Foo.method(*(1, 2, 3))
+    Traceback (most recent call last):
+      ...
+    TypeError: unbound method method() must be called with Foo instance as \
+first argument (got int instance instead)
 
-try:
-    g(*(), **{})
-except TypeError, err:
-    print "TypeError:", err
-else:
-    print "should raise TypeError: not enough arguments; expected 1, got 0"
+    >>> Foo.method(1, *[2, 3])
+    Traceback (most recent call last):
+      ...
+    TypeError: unbound method method() must be called with Foo instance as \
+first argument (got int instance instead)
 
-g(1)
-g(1, 2)
-g(1, 2, 3)
-g(1, 2, 3, *(4, 5))
-class Nothing: pass
-try:
-    g(*Nothing())
-except TypeError, attr:
-    pass
-else:
-    print "should raise TypeError"
+A PyCFunction that takes only positional parameters shoud allow an
+empty keyword dictionary to pass without a complaint, but raise a
+TypeError if te dictionary is not empty
 
-class Nothing:
-    def __len__(self):
-        return 5
-try:
-    g(*Nothing())
-except TypeError, attr:
-    pass
-else:
-    print "should raise TypeError"
+    >>> try:
+    ...     silence = id(1, *{})
+    ...     True
+    ... except:
+    ...     False
+    True
 
-class Nothing:
-    def __len__(self):
-        return 5
-    def __getitem__(self, i):
-        if i < 3:
-            return i
-        else:
-            raise IndexError, i
-g(*Nothing())
+    >>> id(1, **{'foo': 1})
+    Traceback (most recent call last):
+      ...
+    TypeError: id() takes no keyword arguments
 
-class Nothing:
-    def __init__(self):
-        self.c = 0
-    def __iter__(self):
-        return self
-try:
-    g(*Nothing())
-except TypeError, attr:
-    pass
-else:
-    print "should raise TypeError"
+"""
 
-class Nothing:
-    def __init__(self):
-        self.c = 0
-    def __iter__(self):
-        return self
-    def next(self):
-        if self.c == 4:
-            raise StopIteration
-        c = self.c
-        self.c += 1
-        return c
-g(*Nothing())
+from test import test_support
 
-# make sure the function call doesn't stomp on the dictionary?
-d = {'a': 1, 'b': 2, 'c': 3}
-d2 = d.copy()
-verify(d == d2)
-g(1, d=4, **d)
-print sortdict(d)
-print sortdict(d2)
-verify(d == d2, "function call modified dictionary")
+def test_main():
+    import test_extcall # self import
+    test_support.run_doctest(test_extcall, True)
 
-# what about willful misconduct?
-def saboteur(**kw):
-    kw['x'] = locals() # yields a cyclic kw
-    return kw
-d = {}
-kw = saboteur(a=1, **d)
-verify(d == {})
-# break the cycle
-del kw['x']
-
-try:
-    g(1, 2, 3, **{'x':4, 'y':5})
-except TypeError, err:
-    print err
-else:
-    print "should raise TypeError: keyword parameter redefined"
-
-try:
-    g(1, 2, 3, a=4, b=5, *(6, 7), **{'a':8, 'b':9})
-except TypeError, err:
-    print err
-else:
-    print "should raise TypeError: keyword parameter redefined"
-
-try:
-    f(**{1:2})
-except TypeError, err:
-    print err
-else:
-    print "should raise TypeError: keywords must be strings"
-
-try:
-    h(**{'e': 2})
-except TypeError, err:
-    print err
-else:
-    print "should raise TypeError: unexpected keyword argument: e"
-
-try:
-    h(*h)
-except TypeError, err:
-    print err
-else:
-    print "should raise TypeError: * argument must be a tuple"
-
-try:
-    dir(*h)
-except TypeError, err:
-    print err
-else:
-    print "should raise TypeError: * argument must be a tuple"
-
-try:
-    None(*h)
-except TypeError, err:
-    print err
-else:
-    print "should raise TypeError: * argument must be a tuple"
-
-try:
-    h(**h)
-except TypeError, err:
-    print err
-else:
-    print "should raise TypeError: ** argument must be a dictionary"
-
-try:
-    dir(**h)
-except TypeError, err:
-    print err
-else:
-    print "should raise TypeError: ** argument must be a dictionary"
-
-try:
-    None(**h)
-except TypeError, err:
-    print err
-else:
-    print "should raise TypeError: ** argument must be a dictionary"
-
-try:
-    dir(b=1,**{'b':1})
-except TypeError, err:
-    print err
-else:
-    print "should raise TypeError: dir() got multiple values for keyword argument 'b'"
-
-def f2(*a, **b):
-    return a, b
-
-d = {}
-for i in range(512):
-    key = 'k%d' % i
-    d[key] = i
-a, b = f2(1, *(2, 3), **d)
-print len(a), len(b), b == d
-
-class Foo:
-    def method(self, arg1, arg2):
-        return arg1 + arg2
-
-x = Foo()
-print Foo.method(*(x, 1, 2))
-print Foo.method(x, *(1, 2))
-try:
-    print Foo.method(*(1, 2, 3))
-except TypeError, err:
-    pass
-else:
-    print 'expected a TypeError for unbound method call'
-try:
-    print Foo.method(1, *(2, 3))
-except TypeError, err:
-    pass
-else:
-    print 'expected a TypeError for unbound method call'
-
-# A PyCFunction that takes only positional parameters should allow an
-# empty keyword dictionary to pass without a complaint, but raise a
-# TypeError if the dictionary is non-empty.
-id(1, **{})
-try:
-    id(1, **{"foo": 1})
-except TypeError:
-    pass
-else:
-    raise TestFailed, 'expected TypeError; no exception raised'
-
-a, b, d, e, v, k = 'A', 'B', 'D', 'E', 'V', 'K'
-funcs = []
-maxargs = {}
-for args in ['', 'a', 'ab']:
-    for defargs in ['', 'd', 'de']:
-        for vararg in ['', 'v']:
-            for kwarg in ['', 'k']:
-                name = 'z' + args + defargs + vararg + kwarg
-                arglist = list(args) + map(
-                    lambda x: '%s="%s"' % (x, x), defargs)
-                if vararg: arglist.append('*' + vararg)
-                if kwarg: arglist.append('**' + kwarg)
-                decl = (('def %s(%s): print "ok %s", a, b, d, e, v, ' +
-                         'type(k) is type ("") and k or sortdict(k)')
-                         % (name, ', '.join(arglist), name))
-                exec(decl)
-                func = eval(name)
-                funcs.append(func)
-                maxargs[func] = len(args + defargs)
-
-for name in ['za', 'zade', 'zabk', 'zabdv', 'zabdevk']:
-    func = eval(name)
-    for args in [(), (1, 2), (1, 2, 3, 4, 5)]:
-        for kwargs in ['', 'a', 'd', 'ad', 'abde']:
-            kwdict = {}
-            for k in kwargs: kwdict[k] = k + k
-            print func.func_name, args, sortdict(kwdict), '->',
-            try: func(*args, **kwdict)
-            except TypeError, err: print err
+if __name__ == '__main__':
+    test_main()
diff --git a/Misc/NEWS b/Misc/NEWS
index 4fb4a82..03597a5 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -75,6 +75,8 @@
 Tests
 -----
 
+- GHOP 234: Convert test_extcall to doctest.
+
 - GHOP 290: Convert test_dbm and test_dummy_threading to unittest.
 
 - GHOP 293: Convert test_strftime, test_getargs, and test_pep247 to unittest.