1 files changed, 29 insertions, 15 deletions
diff --git a/Lib/test/test_heapq.py b/Lib/test/test_heapq.py
index 327a64d..f19d56e 100644
--- a/Lib/test/test_heapq.py
+++ b/Lib/test/test_heapq.py
@@ -1,16 +1,31 @@
 """Unittests for heapq."""
 
+import sys
 import random
-import unittest
+
 from test import support
-import sys
+from unittest import TestCase, skipUnless
 
-# We do a bit of trickery here to be able to test both the C implementation
-# and the Python implementation of the module.
-import heapq as c_heapq
 py_heapq = support.import_fresh_module('heapq', blocked=['_heapq'])
+c_heapq = support.import_fresh_module('heapq', fresh=['_heapq'])
+
+# _heapq.nlargest/nsmallest are saved in heapq._nlargest/_smallest when
+# _heapq is imported, so check them there
+func_names = ['heapify', 'heappop', 'heappush', 'heappushpop',
+              'heapreplace', '_nlargest', '_nsmallest']
+
+class TestModules(TestCase):
+    def test_py_functions(self):
+        for fname in func_names:
+            self.assertEqual(getattr(py_heapq, fname).__module__, 'heapq')
+
+    @skipUnless(c_heapq, 'requires _heapq')
+    def test_c_functions(self):
+        for fname in func_names:
+            self.assertEqual(getattr(c_heapq, fname).__module__, '_heapq')
 
-class TestHeap(unittest.TestCase):
+
+class TestHeap(TestCase):
     module = None
 
     def test_push_pop(self):
@@ -176,16 +191,12 @@ class TestHeap(unittest.TestCase):
                 self.assertEqual(list(self.module.nlargest(n, data, key=f)),
                                  sorted(data, key=f, reverse=True)[:n])
 
+
 class TestHeapPython(TestHeap):
     module = py_heapq
 
-    # As an early adopter, we sanity check the
-    # test.support.import_fresh_module utility function
-    def test_pure_python(self):
-        self.assertFalse(sys.modules['heapq'] is self.module)
-        self.assertTrue(hasattr(self.module.heapify, '__code__'))
-
 
+@skipUnless(c_heapq, 'requires _heapq')
 class TestHeapC(TestHeap):
     module = c_heapq
 
@@ -307,7 +318,8 @@ def L(seqn):
     'Test multiple tiers of iterators'
     return chain(map(lambda x:x, R(Ig(G(seqn)))))
 
-class TestErrorHandling(unittest.TestCase):
+
+class TestErrorHandling(TestCase):
     module = None
 
     def test_non_sequence(self):
@@ -358,9 +370,11 @@ class TestErrorHandling(unittest.TestCase):
                 self.assertRaises(TypeError, f, 2, N(s))
                 self.assertRaises(ZeroDivisionError, f, 2, E(s))
 
+
 class TestErrorHandlingPython(TestErrorHandling):
     module = py_heapq
 
+@skipUnless(c_heapq, 'requires _heapq')
 class TestErrorHandlingC(TestErrorHandling):
     module = c_heapq
 
@@ -369,8 +383,8 @@ class TestErrorHandlingC(TestErrorHandling):
 
 
 def test_main(verbose=None):
-    test_classes = [TestHeapPython, TestHeapC, TestErrorHandlingPython,
-                    TestErrorHandlingC]
+    test_classes = [TestModules, TestHeapPython, TestHeapC,
+                    TestErrorHandlingPython, TestErrorHandlingC]
     support.run_unittest(*test_classes)
 
     # verify reference counting