Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60568-60598,60600-60616 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r60568 | christian.heimes | 2008-02-04 19:48:38 +0100 (Mon, 04 Feb 2008) | 1 line

  Increase debugging to investige failing tests on some build bots
........
  r60570 | christian.heimes | 2008-02-04 20:30:05 +0100 (Mon, 04 Feb 2008) | 1 line

  Small adjustments for test compact freelist test. It's no passing on Windows as well.
........
  r60573 | amaury.forgeotdarc | 2008-02-04 21:53:14 +0100 (Mon, 04 Feb 2008) | 2 lines

  Correct quotes in NEWS file
........
  r60575 | amaury.forgeotdarc | 2008-02-04 22:45:05 +0100 (Mon, 04 Feb 2008) | 13 lines

  #1750076: Debugger did not step on every iteration of a while statement.

  The mapping between bytecode offsets and source lines (lnotab) did not contain
  an entry for the beginning of the loop.

  Now it does, and the lnotab can be a bit larger:
  in particular, several statements on the same line generate several entries.
  However, this does not bother the settrace function, which will trigger only
  one 'line' event.

  The lnotab seems to be exactly the same as with python2.4.
........
  r60584 | amaury.forgeotdarc | 2008-02-05 01:26:21 +0100 (Tue, 05 Feb 2008) | 3 lines

  Change r60575 broke test_compile:
  there is no need to emit co_lnotab item when both offsets are zeros.
........
  r60587 | skip.montanaro | 2008-02-05 03:32:16 +0100 (Tue, 05 Feb 2008) | 1 line

  sync with most recent version from python-mode sf project
........
  r60588 | lars.gustaebel | 2008-02-05 12:51:40 +0100 (Tue, 05 Feb 2008) | 5 lines

  Issue #2004: Use mode 0700 for temporary directories and default
  permissions for missing directories.

  (will backport to 2.5)
........
  r60590 | georg.brandl | 2008-02-05 13:01:24 +0100 (Tue, 05 Feb 2008) | 2 lines

  Convert external links to internal links. Fixes #2010.
........
  r60592 | marc-andre.lemburg | 2008-02-05 15:50:40 +0100 (Tue, 05 Feb 2008) | 3 lines

  Keep distutils Python 2.1 compatible (or even Python 2.4 in this case).
........
  r60593 | andrew.kuchling | 2008-02-05 17:06:57 +0100 (Tue, 05 Feb 2008) | 5 lines

  Update PEP URL.
  (This code is duplicated between pydoc and DocXMLRPCServer; maybe it
  should be refactored as a GHOP project.)

  2.5.2 backport candidate.
........
  r60596 | guido.van.rossum | 2008-02-05 18:32:15 +0100 (Tue, 05 Feb 2008) | 2 lines

  In the experimental 'Scanner' feature, the group count was set wrong.
........
  r60602 | facundo.batista | 2008-02-05 20:03:32 +0100 (Tue, 05 Feb 2008) | 3 lines


  Issue 1951. Converts wave test cases to unittest.
........
  r60603 | georg.brandl | 2008-02-05 20:07:10 +0100 (Tue, 05 Feb 2008) | 2 lines

  Actually run the test.
........
  r60604 | skip.montanaro | 2008-02-05 20:24:30 +0100 (Tue, 05 Feb 2008) | 2 lines

  correct object name
........
  r60605 | georg.brandl | 2008-02-05 20:58:17 +0100 (Tue, 05 Feb 2008) | 7 lines

  * 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.
........
  r60613 | raymond.hettinger | 2008-02-06 02:49:00 +0100 (Wed, 06 Feb 2008) | 1 line

  Sync-up with Py3k work.
........
  r60614 | christian.heimes | 2008-02-06 13:44:34 +0100 (Wed, 06 Feb 2008) | 1 line

  Limit free list of method and builtin function objects to 256 entries each.
........
  r60616 | christian.heimes | 2008-02-06 14:33:44 +0100 (Wed, 06 Feb 2008) | 7 lines

  Unified naming convention for free lists and their limits. All free lists
  in Object/ are named ``free_list``, the counter ``numfree`` and the upper
  limit is a macro ``PyName_MAXFREELIST`` inside an #ifndef block.

  The chances should make it easier to adjust Python for platforms with
  less memory, e.g. mobile phones.
........

7 files changed, 389 insertions, 244 deletions

diff --git a/Lib/test/output/test_profile b/Lib/test/output/test_profile
deleted file mode 100644
index 0582611..0000000
--- a/Lib/test/output/test_profile
+++ /dev/null
@@ -1,97 +0,0 @@
-test_profile
-         125 function calls (105 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)
-        1    0.000    0.000    1.000    1.000 :0(exec)
-       12    0.000    0.000    0.012    0.001 :0(hasattr)
-        1    0.000    0.000    0.000    0.000 :0(setprofile)
-        1    0.000    0.000    1.000    1.000 <string>:1(<module>)
-        2    0.000    0.000    0.000    0.000 io.py:1213(flush)
-        1    0.000    0.000    0.000    0.000 io.py:269(flush)
-        1    0.000    0.000    0.000    0.000 io.py:656(closed)
-        1    0.000    0.000    0.000    0.000 io.py:874(flush)
-        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(exec)                              -> <string>:1(<module>)(1)    1.000
-                                         io.py:1213(flush)(2)    0.000
-:0(hasattr)                           -> test_profile.py:115(__getattr__)(12)    0.028
-:0(setprofile)                        -> 
-<string>:1(<module>)                  -> test_profile.py:30(testfunc)(1)    1.000
-io.py:1213(flush)                     -> io.py:269(flush)(1)    0.000
-                                         io.py:874(flush)(1)    0.000
-io.py:269(flush)                      -> 
-io.py:656(closed)                     -> 
-io.py:874(flush)                      -> io.py:656(closed)(1)    0.000
-profile:0(profiler)                   -> profile:0(testfunc())(1)    1.000
-profile:0(testfunc())                 -> :0(exec)(1)    1.000
-                                         :0(setprofile)(1)    0.000
-test_profile.py:103(subhelper)        -> 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(exec)                              <- profile:0(testfunc())(1)    1.000
-:0(hasattr)                           <- test_profile.py:78(helper1)(4)    0.120
-                                         test_profile.py:93(helper2)(8)    0.400
-:0(setprofile)                        <- profile:0(testfunc())(1)    1.000
-<string>:1(<module>)                  <- :0(exec)(1)    1.000
-io.py:1213(flush)                     <- :0(exec)(2)    1.000
-io.py:269(flush)                      <- io.py:1213(flush)(1)    0.000
-io.py:656(closed)                     <- io.py:874(flush)(1)    0.000
-io.py:874(flush)                      <- io.py:1213(flush)(1)    0.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
-
-
diff --git a/Lib/test/profilee.py b/Lib/test/profilee.py
new file mode 100644
index 0000000..6ad2c83
--- /dev/null
+++ b/Lib/test/profilee.py
@@ -0,0 +1,115 @@
+"""
+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
diff --git a/Lib/test/test_docxmlrpc.py b/Lib/test/test_docxmlrpc.py
index 1a056f8..c9984b3 100644
--- a/Lib/test/test_docxmlrpc.py
+++ b/Lib/test/test_docxmlrpc.py
@@ -117,11 +117,11 @@ b"""<dl><dt><a name="-&lt;lambda&gt;"><strong>&lt;lambda&gt;</strong></a>(x, y)<
         The documentation for the "add" method contains the test material.
         """
         self.client.request("GET", "/")
-        response = self.client.getresponse()
+        response = self.client.getresponse().read()
 
         self.assert_( # This is ugly ... how can it be made better?
-b"""<dl><dt><a name="-add"><strong>add</strong></a>(x, y)</dt><dd><tt>Add&nbsp;two&nbsp;instances&nbsp;together.&nbsp;This&nbsp;follows&nbsp;<a href="http://www.python.org/peps/pep-0008.html">PEP008</a>,&nbsp;but&nbsp;has&nbsp;nothing<br>\nto&nbsp;do&nbsp;with&nbsp;<a href="http://www.rfc-editor.org/rfc/rfc1952.txt">RFC1952</a>.&nbsp;Case&nbsp;should&nbsp;matter:&nbsp;pEp008&nbsp;and&nbsp;rFC1952.&nbsp;&nbsp;Things<br>\nthat&nbsp;start&nbsp;with&nbsp;http&nbsp;and&nbsp;ftp&nbsp;should&nbsp;be&nbsp;auto-linked,&nbsp;too:<br>\n<a href="http://google.com">http://google.com</a>.</tt></dd></dl>"""
-          in response.read())
+b"""<dl><dt><a name="-add"><strong>add</strong></a>(x, y)</dt><dd><tt>Add&nbsp;two&nbsp;instances&nbsp;together.&nbsp;This&nbsp;follows&nbsp;<a href="http://www.python.org/dev/peps/pep-0008/">PEP008</a>,&nbsp;but&nbsp;has&nbsp;nothing<br>\nto&nbsp;do&nbsp;with&nbsp;<a href="http://www.rfc-editor.org/rfc/rfc1952.txt">RFC1952</a>.&nbsp;Case&nbsp;should&nbsp;matter:&nbsp;pEp008&nbsp;and&nbsp;rFC1952.&nbsp;&nbsp;Things<br>\nthat&nbsp;start&nbsp;with&nbsp;http&nbsp;and&nbsp;ftp&nbsp;should&nbsp;be&nbsp;auto-linked,&nbsp;too:<br>\n<a href="http://google.com">http://google.com</a>.</tt></dd></dl>"""
+          in response, response)
 
     def test_system_methods(self):
         """Test the precense of three consecutive system.* methods.
diff --git a/Lib/test/test_profile.py b/Lib/test/test_profile.py
index 95ad8d2..632911d 100644..100755
--- a/Lib/test/test_profile.py
+++ b/Lib/test/test_profile.py
@@ -1,123 +1,179 @@
 """Test suite for the profile module."""
 
-import profile, pstats, sys
+import os
+import sys
+import pstats
+import unittest
+from difflib import unified_diff
+from io import StringIO
+from test.test_support import run_unittest
 
-# 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 = 0
+import profile
+from test.profilee import testfunc, timer
+
+
+class ProfileTest(unittest.TestCase):
+
+    profilerclass = profile.Profile
+    methodnames = ['print_stats', 'print_callers', 'print_callees']
+    expected_output = {}
+
+    @classmethod
+    def do_profiling(cls):
+        results = []
+        prof = cls.profilerclass(timer, 0.001)
+        prof.runctx("testfunc()", globals(), locals())
+        results.append(timer())
+        for methodname in cls.methodnames:
+            s = StringIO()
+            stats = pstats.Stats(prof, stream=s)
+            stats.strip_dirs().sort_stats("stdname")
+            getattr(stats, methodname)()
+            results.append(s.getvalue())
+        return results
+
+    def test_cprofile(self):
+        results = self.do_profiling()
+        self.assertEqual(results[0], 43000)
+        for i, method in enumerate(self.methodnames):
+            if results[i+1] != self.expected_output[method]:
+                print("Stats.%s output for %s doesn't fit expectation!" %
+                      (method, self.profilerclass.__name__))
+                print('\n'.join(unified_diff(
+                                  results[i+1].split('\n'),
+                                  self.expected_output[method].split('\n'))))
+
+
+def regenerate_expected_output(filename, cls):
+    filename = filename.rstrip('co')
+    print('Regenerating %s...' % filename)
+    results = cls.do_profiling()
+
+    newfile = []
+    with open(filename, 'r') as f:
+        for line in f:
+            newfile.append(line)
+            if line[:6] == '#--cut':
+                break
+
+    with open(filename, 'w') as f:
+        f.writelines(newfile)
+        for i, method in enumerate(cls.methodnames):
+            f.write('%s.expected_output[%r] = """\\\n%s"""\n' % (
+                cls.__name__, method, results[i+1]))
+        f.write('\nif __name__ == "__main__":\n    main()\n')
 
-# IMPORTANT: this is an output test.  *ALL* NUMBERS in the expected
-# output are relevant.  If you change the formatting of pstats,
-# please don't just regenerate output/test_profile without checking
-# very carefully that not a single number has changed.
 
 def test_main():
-    global ticks
-    ticks = 42000
-    prof = profile.Profile(timer)
-    prof.runctx("testfunc()", globals(), locals())
-    assert ticks == 43000, ticks
-    st = pstats.Stats(prof)
-    st.strip_dirs().sort_stats('stdname').print_stats()
-    st.print_callees()
-    st.print_callers()
-
-def timer():
-    return ticks*0.001
-
-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))
+    run_unittest(ProfileTest)
+
+def main():
+    if '-r' not in sys.argv:
+        test_main()
     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
+        regenerate_expected_output(__file__, ProfileTest)
+
+
+# Don't remove this comment. Everything below it is auto-generated.
+#--cut--------------------------------------------------------------------------
+ProfileTest.expected_output['print_stats'] = """\
+         126 function calls (106 primitive calls) in 999.751 CPU seconds
+
+   Ordered by: standard name
+
+   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
+        4   -0.004   -0.001   -0.004   -0.001 :0(append)
+        4   -0.004   -0.001   -0.004   -0.001 :0(exc_info)
+        1   -0.004   -0.004  999.753  999.753 :0(exec)
+       12   -0.024   -0.002   11.964    0.997 :0(hasattr)
+        1    0.000    0.000    0.000    0.000 :0(setprofile)
+        1   -0.002   -0.002  999.767  999.767 <string>:1(<module>)
+        2   -0.004   -0.002   -0.010   -0.005 io.py:1213(flush)
+        2   -0.002   -0.001   -0.002   -0.001 io.py:656(closed)
+        2   -0.004   -0.002   -0.006   -0.003 io.py:874(flush)
+        0    0.000             0.000          profile:0(profiler)
+        1   -0.002   -0.002  999.751  999.751 profile:0(testfunc())
+       28   27.972    0.999   27.972    0.999 profilee.py:110(__getattr__)
+        1  269.996  269.996  999.769  999.769 profilee.py:25(testfunc)
+     23/3  149.937    6.519  169.917   56.639 profilee.py:35(factorial)
+       20   19.980    0.999   19.980    0.999 profilee.py:48(mul)
+        2   39.986   19.993  599.830  299.915 profilee.py:55(helper)
+        4  115.984   28.996  119.964   29.991 profilee.py:73(helper1)
+        2   -0.006   -0.003  139.946   69.973 profilee.py:84(helper2_indirect)
+        8  311.976   38.997  399.912   49.989 profilee.py:88(helper2)
+        8   63.976    7.997   79.960    9.995 profilee.py:98(subhelper)
+
+
+"""
+ProfileTest.expected_output['print_callers'] = """\
+   Ordered by: standard name
+
+Function                          was called by...
+:0(append)                        <- profilee.py:73(helper1)(4)  119.964
+:0(exc_info)                      <- profilee.py:73(helper1)(4)  119.964
+:0(exec)                          <- profile:0(testfunc())(1)  999.751
+:0(hasattr)                       <- profilee.py:73(helper1)(4)  119.964
+                                     profilee.py:88(helper2)(8)  399.912
+:0(setprofile)                    <- profile:0(testfunc())(1)  999.751
+<string>:1(<module>)              <- :0(exec)(1)  999.753
+io.py:1213(flush)                 <- :0(exec)(2)  999.753
+io.py:656(closed)                 <- io.py:874(flush)(2)   -0.006
+io.py:874(flush)                  <- io.py:1213(flush)(2)   -0.010
+profile:0(profiler)               <-
+profile:0(testfunc())             <- profile:0(profiler)(1)    0.000
+profilee.py:110(__getattr__)      <- :0(hasattr)(12)   11.964
+                                     profilee.py:98(subhelper)(16)   79.960
+profilee.py:25(testfunc)          <- <string>:1(<module>)(1)  999.767
+profilee.py:35(factorial)         <- profilee.py:25(testfunc)(1)  999.769
+                                     profilee.py:35(factorial)(20)  169.917
+                                     profilee.py:84(helper2_indirect)(2)  139.946
+profilee.py:48(mul)               <- profilee.py:35(factorial)(20)  169.917
+profilee.py:55(helper)            <- profilee.py:25(testfunc)(2)  999.769
+profilee.py:73(helper1)           <- profilee.py:55(helper)(4)  599.830
+profilee.py:84(helper2_indirect)  <- profilee.py:55(helper)(2)  599.830
+profilee.py:88(helper2)           <- profilee.py:55(helper)(6)  599.830
+                                     profilee.py:84(helper2_indirect)(2)  139.946
+profilee.py:98(subhelper)         <- profilee.py:88(helper2)(8)  399.912
+
+
+"""
+ProfileTest.expected_output['print_callees'] = """\
+   Ordered by: standard name
+
+Function                          called...
+:0(append)                        ->
+:0(exc_info)                      ->
+:0(exec)                          -> <string>:1(<module>)(1)  999.767
+                                     io.py:1213(flush)(2)   -0.010
+:0(hasattr)                       -> profilee.py:110(__getattr__)(12)   27.972
+:0(setprofile)                    ->
+<string>:1(<module>)              -> profilee.py:25(testfunc)(1)  999.769
+io.py:1213(flush)                 -> io.py:874(flush)(2)   -0.006
+io.py:656(closed)                 ->
+io.py:874(flush)                  -> io.py:656(closed)(2)   -0.002
+profile:0(profiler)               -> profile:0(testfunc())(1)  999.751
+profile:0(testfunc())             -> :0(exec)(1)  999.753
+                                     :0(setprofile)(1)    0.000
+profilee.py:110(__getattr__)      ->
+profilee.py:25(testfunc)          -> profilee.py:35(factorial)(1)  169.917
+                                     profilee.py:55(helper)(2)  599.830
+profilee.py:35(factorial)         -> profilee.py:35(factorial)(20)  169.917
+                                     profilee.py:48(mul)(20)   19.980
+profilee.py:48(mul)               ->
+profilee.py:55(helper)            -> profilee.py:73(helper1)(4)  119.964
+                                     profilee.py:84(helper2_indirect)(2)  139.946
+                                     profilee.py:88(helper2)(6)  399.912
+profilee.py:73(helper1)           -> :0(append)(4)   -0.004
+                                     :0(exc_info)(4)   -0.004
+                                     :0(hasattr)(4)   11.964
+profilee.py:84(helper2_indirect)  -> profilee.py:35(factorial)(2)  169.917
+                                     profilee.py:88(helper2)(2)  399.912
+profilee.py:88(helper2)           -> :0(hasattr)(8)   11.964
+                                     profilee.py:98(subhelper)(8)   79.960
+profilee.py:98(subhelper)         -> profilee.py:110(__getattr__)(16)   27.972
+
+
+"""
 
 if __name__ == "__main__":
-    test_main()
+    main()
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index 11251b7..d8d74d0 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -339,11 +339,14 @@ class SysModuleTest(unittest.TestCase):
         # freed blocks shouldn't change
         self.assertEqual(r[0][2], 0)
         # fill freelists
-        floats = [float(i) for i in range(12000)]
+        ints = list(range(10000))
+        floats = [float(i) for i in ints]
+        del ints
         del floats
-        # should free more than 200 blocks
+        # should free more than 100 blocks
         r = sys._compact_freelists()
-        self.assert_(r[0][2] > 200, r[0][2])
+        self.assert_(r[0][1] > 100, r[0][1])
+        self.assert_(r[0][2] > 100, r[0][2])
 
 def test_main():
     test.test_support.run_unittest(SysModuleTest)
diff --git a/Lib/test/test_trace.py b/Lib/test/test_trace.py
index a0f76c6..635e1bc 100644
--- a/Lib/test/test_trace.py
+++ b/Lib/test/test_trace.py
@@ -252,14 +252,16 @@ class TraceTestCase(unittest.TestCase):
                 "\n".join(difflib.ndiff([str(x) for x in expected_events],
                                         [str(x) for x in events])))
 
-
-    def run_test(self, func):
+    def run_and_compare(self, func, events):
         tracer = Tracer()
         sys.settrace(tracer.trace)
         func()
         sys.settrace(None)
         self.compare_events(func.__code__.co_firstlineno,
-                            tracer.events, func.events)
+                            tracer.events, events)
+
+    def run_test(self, func):
+        self.run_and_compare(func, func.events)
 
     def run_test2(self, func):
         tracer = Tracer()
@@ -321,6 +323,59 @@ class TraceTestCase(unittest.TestCase):
         self.compare_events(generator_example.__code__.co_firstlineno,
                             tracer.events, generator_example.events)
 
+    def test_14_onliner_if(self):
+        def onliners():
+            if True: False
+            else: True
+            return 0
+        self.run_and_compare(
+            onliners,
+            [(0, 'call'),
+             (1, 'line'),
+             (3, 'line'),
+             (3, 'return')])
+
+    def test_15_loops(self):
+        # issue1750076: "while" expression is skipped by debugger
+        def for_example():
+            for x in range(2):
+                pass
+        self.run_and_compare(
+            for_example,
+            [(0, 'call'),
+             (1, 'line'),
+             (2, 'line'),
+             (1, 'line'),
+             (2, 'line'),
+             (1, 'line'),
+             (1, 'return')])
+
+        def while_example():
+            # While expression should be traced on every loop
+            x = 2
+            while x > 0:
+                x -= 1
+        self.run_and_compare(
+            while_example,
+            [(0, 'call'),
+             (2, 'line'),
+             (3, 'line'),
+             (4, 'line'),
+             (3, 'line'),
+             (4, 'line'),
+             (3, 'line'),
+             (3, 'return')])
+
+    def test_16_blank_lines(self):
+        namespace = {}
+        exec("def f():\n" + "\n" * 256 + "    pass", namespace)
+        self.run_and_compare(
+            namespace["f"],
+            [(0, 'call'),
+             (257, 'line'),
+             (257, 'return')])
+
+
 class RaisingTraceFuncTestCase(unittest.TestCase):
     def trace(self, frame, event, arg):
         """A trace function that raises an exception in response to a
diff --git a/Lib/test/test_wave.py b/Lib/test/test_wave.py
index 271f0a8..c37323a 100644
--- a/Lib/test/test_wave.py
+++ b/Lib/test/test_wave.py
@@ -1,32 +1,45 @@
-from test.test_support import TestFailed, TESTFN
+from test.test_support import TESTFN, run_unittest
 import os
 import wave
-
-def check(t, msg=None):
-    if not t:
-        raise TestFailed(msg)
+import unittest
 
 nchannels = 2
 sampwidth = 2
 framerate = 8000
 nframes = 100
 
-f = wave.open(TESTFN, 'wb')
-f.setnchannels(nchannels)
-f.setsampwidth(sampwidth)
-f.setframerate(framerate)
-f.setnframes(nframes)
-output = b'\0' * nframes * nchannels * sampwidth
-f.writeframes(output)
-f.close()
-
-f = wave.open(TESTFN, 'rb')
-check(nchannels == f.getnchannels(), "nchannels")
-check(sampwidth == f.getsampwidth(), "sampwidth")
-check(framerate == f.getframerate(), "framerate")
-check(nframes == f.getnframes(), "nframes")
-input = f.readframes(nframes)
-check(input == output, "data")
-f.close()
-
-os.remove(TESTFN)
+class TestWave(unittest.TestCase):
+
+    def setUp(self):
+        self.f = None
+
+    def tearDown(self):
+        if self.f is not None:
+            self.f.close()
+        try:
+            os.remove(TESTFN)
+        except OSError:
+            pass
+
+    def test_it(self):
+        self.f = wave.open(TESTFN, 'wb')
+        self.f.setnchannels(nchannels)
+        self.f.setsampwidth(sampwidth)
+        self.f.setframerate(framerate)
+        self.f.setnframes(nframes)
+        output = b'\0' * nframes * nchannels * sampwidth
+        self.f.writeframes(output)
+        self.f.close()
+
+        self.f = wave.open(TESTFN, 'rb')
+        self.assertEqual(nchannels, self.f.getnchannels())
+        self.assertEqual(sampwidth, self.f.getsampwidth())
+        self.assertEqual(framerate, self.f.getframerate())
+        self.assertEqual(nframes, self.f.getnframes())
+        self.assertEqual(self.f.readframes(nframes), output)
+
+def test_main():
+    run_unittest(TestWave)
+
+if __name__ == '__main__':
+    test_main()