diff --git a/Lib/doctest.py b/Lib/doctest.py
index 26a8914..a8162f3 100644
--- a/Lib/doctest.py
+++ b/Lib/doctest.py
@@ -962,7 +962,9 @@
                 if obj.__doc__ is None:
                     docstring = ''
                 else:
-                    docstring = str(obj.__doc__)
+                    docstring = obj.__doc__
+                    if not isinstance(docstring, basestring):
+                        docstring = str(docstring)
             except (TypeError, AttributeError):
                 docstring = ''
 
diff --git a/Lib/test/test_doctest2.py b/Lib/test/test_doctest2.py
index 3593d41..5b7f36f 100644
--- a/Lib/test/test_doctest2.py
+++ b/Lib/test/test_doctest2.py
@@ -1,17 +1,31 @@
-"""A module to test whether doctest recognizes some 2.2 features,
+# -*- coding: utf-8 -*-
+u"""A module to test whether doctest recognizes some 2.2 features,
 like static and class methods.
 
 >>> print 'yup'  # 1
 yup
+
+We include some (random) encoded (utf-8) text in the text surrounding
+the example.  It should be ignored:
+
+ЉЊЈЁЂ
+
 """
 
 from test import test_support
 
 class C(object):
-    """Class C.
+    u"""Class C.
 
     >>> print C()  # 2
     42
+
+
+    We include some (random) encoded (utf-8) text in the text surrounding
+    the example.  It should be ignored:
+
+        ЉЊЈЁЂ
+
     """
 
     def __init__(self):
diff --git a/Lib/test/test_doctest2.txt b/Lib/test/test_doctest2.txt
index 0d7d1d5..2e14856 100644
--- a/Lib/test/test_doctest2.txt
+++ b/Lib/test/test_doctest2.txt
@@ -5,3 +5,10 @@
   >>> import test.test_doctest
   >>> test.test_doctest.sillySetup
   True
+
+This test also has some (random) encoded (utf-8) unicode text:
+
+  ï»¿ÐÐÐÐÐ
+
+This doesn't cause a problem in the tect surrounding the examples, but
+we include it here (in this test text file) to make sure. :)
