* Use the same code to profile for test_profile and test_cprofile.

* Convert both to unittest.
* Use the same unit testing code.
* Include the expected output in both test files.
* Make it possible to regenerate the expected output by running
  the file as a script with an '-r' argument.

Lib/test/output/test_profile

-test_profile
-         127 function calls (107 primitive calls) in 1.000 CPU seconds
-
-   Ordered by: standard name
-
-   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
-        4    0.000    0.000    0.000    0.000 :0(append)
-        4    0.000    0.000    0.000    0.000 :0(exc_info)
-       12    0.000    0.000    0.012    0.001 :0(hasattr)
-        8    0.000    0.000    0.000    0.000 :0(range)
-        1    0.000    0.000    0.000    0.000 :0(setprofile)
-        1    0.000    0.000    1.000    1.000 <string>:1(<module>)
-        0    0.000             0.000          profile:0(profiler)
-        1    0.000    0.000    1.000    1.000 profile:0(testfunc())
-        8    0.064    0.008    0.080    0.010 test_profile.py:103(subhelper)
-       28    0.028    0.001    0.028    0.001 test_profile.py:115(__getattr__)
-        1    0.270    0.270    1.000    1.000 test_profile.py:30(testfunc)
-     23/3    0.150    0.007    0.170    0.057 test_profile.py:40(factorial)
-       20    0.020    0.001    0.020    0.001 test_profile.py:53(mul)
-        2    0.040    0.020    0.600    0.300 test_profile.py:60(helper)
-        4    0.116    0.029    0.120    0.030 test_profile.py:78(helper1)
-        2    0.000    0.000    0.140    0.070 test_profile.py:89(helper2_indirect)
-        8    0.312    0.039    0.400    0.050 test_profile.py:93(helper2)
-
-
-   Ordered by: standard name
-
-Function                              called...
-:0(append)                            ->
-:0(exc_info)                          ->
-:0(hasattr)                           -> test_profile.py:115(__getattr__)(12)    0.028
-:0(range)                             ->
-:0(setprofile)                        ->
-<string>:1(<module>)                  -> test_profile.py:30(testfunc)(1)    1.000
-profile:0(profiler)                   -> profile:0(testfunc())(1)    1.000
-profile:0(testfunc())                 -> :0(setprofile)(1)    0.000
-                                         <string>:1(<module>)(1)    1.000
-test_profile.py:103(subhelper)        -> :0(range)(8)    0.000
-                                         test_profile.py:115(__getattr__)(16)    0.028
-test_profile.py:115(__getattr__)      ->
-test_profile.py:30(testfunc)          -> test_profile.py:40(factorial)(1)    0.170
-                                         test_profile.py:60(helper)(2)    0.600
-test_profile.py:40(factorial)         -> test_profile.py:40(factorial)(20)    0.170
-                                         test_profile.py:53(mul)(20)    0.020
-test_profile.py:53(mul)               ->
-test_profile.py:60(helper)            -> test_profile.py:78(helper1)(4)    0.120
-                                         test_profile.py:89(helper2_indirect)(2)    0.140
-                                         test_profile.py:93(helper2)(6)    0.400
-test_profile.py:78(helper1)           -> :0(append)(4)    0.000
-                                         :0(exc_info)(4)    0.000
-                                         :0(hasattr)(4)    0.012
-test_profile.py:89(helper2_indirect)  -> test_profile.py:40(factorial)(2)    0.170
-                                         test_profile.py:93(helper2)(2)    0.400
-test_profile.py:93(helper2)           -> :0(hasattr)(8)    0.012
-                                         test_profile.py:103(subhelper)(8)    0.080
-
-
-   Ordered by: standard name
-
-Function                              was called by...
-:0(append)                            <- test_profile.py:78(helper1)(4)    0.120
-:0(exc_info)                          <- test_profile.py:78(helper1)(4)    0.120
-:0(hasattr)                           <- test_profile.py:78(helper1)(4)    0.120
-                                         test_profile.py:93(helper2)(8)    0.400
-:0(range)                             <- test_profile.py:103(subhelper)(8)    0.080
-:0(setprofile)                        <- profile:0(testfunc())(1)    1.000
-<string>:1(<module>)                  <- profile:0(testfunc())(1)    1.000
-profile:0(profiler)                   <-
-profile:0(testfunc())                 <- profile:0(profiler)(1)    0.000
-test_profile.py:103(subhelper)        <- test_profile.py:93(helper2)(8)    0.400
-test_profile.py:115(__getattr__)      <- :0(hasattr)(12)    0.012
-                                         test_profile.py:103(subhelper)(16)    0.080
-test_profile.py:30(testfunc)          <- <string>:1(<module>)(1)    1.000
-test_profile.py:40(factorial)         <- test_profile.py:30(testfunc)(1)    1.000
-                                         test_profile.py:40(factorial)(20)    0.170
-                                         test_profile.py:89(helper2_indirect)(2)    0.140
-test_profile.py:53(mul)               <- test_profile.py:40(factorial)(20)    0.170
-test_profile.py:60(helper)            <- test_profile.py:30(testfunc)(2)    1.000
-test_profile.py:78(helper1)           <- test_profile.py:60(helper)(4)    0.600
-test_profile.py:89(helper2_indirect)  <- test_profile.py:60(helper)(2)    0.600
-test_profile.py:93(helper2)           <- test_profile.py:60(helper)(6)    0.600
-                                         test_profile.py:89(helper2_indirect)(2)    0.140
-
-

Lib/test/profilee.py

+"""
+Input for test_profile.py and test_cprofile.py.
+
+IMPORTANT: This stuff is touchy. If you modify anything above the
+test class you'll have to regenerate the stats by running the two
+test files.
+
+*ALL* NUMBERS in the expected output are relevant.  If you change
+the formatting of pstats, please don't just regenerate the expected
+output without checking very carefully that not a single number has
+changed.
+"""
+
+import sys
+
+# In order to have reproducible time, we simulate a timer in the global
+# variable 'TICKS', which represents simulated time in milliseconds.
+# (We can't use a helper function increment the timer since it would be
+# included in the profile and would appear to consume all the time.)
+TICKS = 42000
+
+def timer():
+    return TICKS
+
+def testfunc():
+    # 1 call
+    # 1000 ticks total: 270 ticks local, 730 ticks in subfunctions
+    global TICKS
+    TICKS += 99
+    helper()                            # 300
+    helper()                            # 300
+    TICKS += 171
+    factorial(14)                       # 130
+
+def factorial(n):
+    # 23 calls total
+    # 170 ticks total, 150 ticks local
+    # 3 primitive calls, 130, 20 and 20 ticks total
+    # including 116, 17, 17 ticks local
+    global TICKS
+    if n > 0:
+        TICKS += n
+        return mul(n, factorial(n-1))
+    else:
+        TICKS += 11
+        return 1
+
+def mul(a, b):
+    # 20 calls
+    # 1 tick, local
+    global TICKS
+    TICKS += 1
+    return a * b
+
+def helper():
+    # 2 calls
+    # 300 ticks total: 20 ticks local, 260 ticks in subfunctions
+    global TICKS
+    TICKS += 1
+    helper1()                           # 30
+    TICKS += 2
+    helper1()                           # 30
+    TICKS += 6
+    helper2()                           # 50
+    TICKS += 3
+    helper2()                           # 50
+    TICKS += 2
+    helper2()                           # 50
+    TICKS += 5
+    helper2_indirect()                  # 70
+    TICKS += 1
+
+def helper1():
+    # 4 calls
+    # 30 ticks total: 29 ticks local, 1 tick in subfunctions
+    global TICKS
+    TICKS += 10
+    hasattr(C(), "foo")                 # 1
+    TICKS += 19
+    lst = []
+    lst.append(42)                      # 0
+    sys.exc_info()                      # 0
+
+def helper2_indirect():
+    helper2()                           # 50
+    factorial(3)                        # 20
+
+def helper2():
+    # 8 calls
+    # 50 ticks local: 39 ticks local, 11 ticks in subfunctions
+    global TICKS
+    TICKS += 11
+    hasattr(C(), "bar")                 # 1
+    TICKS += 13
+    subhelper()                         # 10
+    TICKS += 15
+
+def subhelper():
+    # 8 calls
+    # 10 ticks total: 8 ticks local, 2 ticks in subfunctions
+    global TICKS
+    TICKS += 2
+    for i in range(2):                  # 0
+        try:
+            C().foo                     # 1 x 2
+        except AttributeError:
+            TICKS += 3                  # 3 x 2
+
+class C:
+    def __getattr__(self, name):
+        # 28 calls
+        # 1 tick, local
+        global TICKS
+        TICKS += 1
+        raise AttributeError

Lib/test/test_queue.py

@@ -9,6 +9,10 @@ from test import test_support
 
 QUEUE_SIZE = 5
 
+def qfull(q):
+    return q.maxsize > 0 and q.qsize() == q.maxsize
+
+
 # A thread to run a function that unclogs a blocked Queue.
 class _TriggerThread(threading.Thread):
     def __init__(self, fn, args):
@@ -86,7 +90,7 @@ class BaseQueueTest(unittest.TestCase, BlockingTestMixin):
         self.cumlock = threading.Lock()
 
     def simple_queue_test(self, q):
-        if not q.empty():
+        if q.qsize():
             raise RuntimeError, "Call this function with an empty queue"
         # I guess we better check things actually queue correctly a little :)
         q.put(111)
@@ -100,10 +104,10 @@ class BaseQueueTest(unittest.TestCase, BlockingTestMixin):
                           "Didn't seem to queue the correct data!")
         for i in range(QUEUE_SIZE-1):
             q.put(i)
-            self.assert_(not q.empty(), "Queue should not be empty")
-        self.assert_(not q.full(), "Queue should not be full")
+            self.assert_(q.qsize(), "Queue should not be empty")
+        self.assert_(not qfull(q), "Queue should not be full")
         q.put("last")
-        self.assert_(q.full(), "Queue should be full")
+        self.assert_(qfull(q), "Queue should be full")
         try:
             q.put("full", block=0)
             self.fail("Didn't appear to block with a full queue")
@@ -120,7 +124,7 @@ class BaseQueueTest(unittest.TestCase, BlockingTestMixin):
         # Empty it
         for i in range(QUEUE_SIZE):
             q.get()
-        self.assert_(q.empty(), "Queue should be empty")
+        self.assert_(not q.qsize(), "Queue should be empty")
         try:
             q.get(block=0)
             self.fail("Didn't appear to block with an empty queue")
@@ -224,7 +228,7 @@ class FailingQueue(Queue.Queue):
 class FailingQueueTest(unittest.TestCase, BlockingTestMixin):
 
     def failing_queue_test(self, q):
-        if not q.empty():
+        if q.qsize():
             raise RuntimeError, "Call this function with an empty queue"
         for i in range(QUEUE_SIZE-1):
             q.put(i)
@@ -242,7 +246,7 @@ class FailingQueueTest(unittest.TestCase, BlockingTestMixin):
         except FailingQueueException:
             pass
         q.put("last")
-        self.assert_(q.full(), "Queue should be full")
+        self.assert_(qfull(q), "Queue should be full")
         # Test a failing blocking put
         q.fail_next_put = True
         try:
@@ -264,17 +268,17 @@ class FailingQueueTest(unittest.TestCase, BlockingTestMixin):
         # Check the Queue isn't damaged.
         # put failed, but get succeeded - re-add
         q.put("last")
-        self.assert_(q.full(), "Queue should be full")
+        self.assert_(qfull(q), "Queue should be full")
         q.get()
-        self.assert_(not q.full(), "Queue should not be full")
+        self.assert_(not qfull(q), "Queue should not be full")
         q.put("last")
-        self.assert_(q.full(), "Queue should be full")
+        self.assert_(qfull(q), "Queue should be full")
         # Test a blocking put
         self.do_blocking_test(q.put, ("full",), q.get, ())
         # Empty it
         for i in range(QUEUE_SIZE):
             q.get()
-        self.assert_(q.empty(), "Queue should be empty")
+        self.assert_(not q.qsize(), "Queue should be empty")
         q.put("first")
         q.fail_next_get = True
         try:
@@ -282,16 +286,16 @@ class FailingQueueTest(unittest.TestCase, BlockingTestMixin):
             self.fail("The queue didn't fail when it should have")
         except FailingQueueException:
             pass
-        self.assert_(not q.empty(), "Queue should not be empty")
+        self.assert_(q.qsize(), "Queue should not be empty")
         q.fail_next_get = True
         try:
             q.get(timeout=0.1)
             self.fail("The queue didn't fail when it should have")
         except FailingQueueException:
             pass
-        self.assert_(not q.empty(), "Queue should not be empty")
+        self.assert_(q.qsize(), "Queue should not be empty")
         q.get()
-        self.assert_(q.empty(), "Queue should be empty")
+        self.assert_(not q.qsize(), "Queue should be empty")
         q.fail_next_get = True
         try:
             self.do_exceptional_blocking_test(q.get, (), q.put, ('empty',),
@@ -300,9 +304,9 @@ class FailingQueueTest(unittest.TestCase, BlockingTestMixin):
         except FailingQueueException:
             pass
         # put succeeded, but get failed.
-        self.assert_(not q.empty(), "Queue should not be empty")
+        self.assert_(q.qsize(), "Queue should not be empty")
         q.get()
-        self.assert_(q.empty(), "Queue should be empty")
+        self.assert_(not q.qsize(), "Queue should be empty")
 
     def test_failing_queue(self):
         # Test to make sure a queue is functioning correctly.

Misc/NEWS

@@ -1287,6 +1287,8 @@ Extension Modules
 Tests
 -----
 
+- Refactor test_profile and test_cprofile to use the same code to profile.
+
 - Make test_runpy reentrant by fixing _check_module to clear out any module
   being tested.  Was causing an error by __import__ doing a reload on the
   second run and thus suppressing bytecode recreation.