Python 3 compatibility

test/lib/TestCmd.py

 """
 TestCmd.py:  a testing framework for commands and scripts.
 
 The TestCmd module provides a framework for portable automated testing
 of executable commands and scripts (in any language, not just Python),
 especially commands and scripts that require file system interaction.
 
 In addition to running tests and evaluating conditions, the TestCmd
 module manages and cleans up one or more temporary workspace
 directories, and provides methods for creating files and directories in
@@ skipping 196 matching lines @@
 # SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF
 # THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
 # DAMAGE.
 #
 # THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 # PARTICULAR PURPOSE.  THE CODE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS,
 # AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
 # SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 
+from __future__ import print_function
+
 __author__ = "Steven Knight <knight at baldmt dot com>"
 __revision__ = "TestCmd.py 0.37.D001 2010/01/11 16:55:50 knight"
 __version__ = "0.37"
 
 import errno
 import os
 import os.path
 import re
 import shutil
 import stat
-import string
 import sys
 import tempfile
 import time
 import traceback
-import types
-import UserList
+try:
+    from UserList import UserList
+except ImportError:
+    from collections import UserList
 
 __all__ = [
     'diff_re',
     'fail_test',
     'no_result',
     'pass_test',
     'match_exact',
     'match_re',
     'match_re_dotall',
     'python_executable',
     'TestCmd'
 ]
 
 try:
     import difflib
 except ImportError:
     __all__.append('simple_diff')
 
 def is_List(e):
-    return type(e) is types.ListType \
-        or isinstance(e, UserList.UserList)
+    return type(e) is list \
+        or isinstance(e, UserList)
 
 try:
     from UserString import UserString
 except ImportError:
-    class UserString:
-        pass
+    try:
+        from collections import UserString
+    except ImportError:
+        class UserString:
+            pass
 
-if hasattr(types, 'UnicodeType'):
-    def is_String(e):
-        return type(e) is types.StringType \
-            or type(e) is types.UnicodeType \
-            or isinstance(e, UserString)
-else:
-    def is_String(e):
-        return type(e) is types.StringType or isinstance(e, UserString)
+try:
+    basestring = basestring
+except NameError:
+    basestring = str
+
+def is_String(e):
+    return isinstance(e, basestring) \
+        or isinstance(e, UserString)
 
 tempfile.template = 'testcmd.'
 if os.name in ('posix', 'nt'):
     tempfile.template = 'testcmd.' + str(os.getpid()) + '.'
 else:
     tempfile.template = 'testcmd.'
 
 re_space = re.compile('\s')
 
 _Cleanup = []
 
 _chain_to_exitfunc = None
 
 def _clean():
     global _Cleanup
-    cleanlist = filter(None, _Cleanup)
+    for test in reversed(_Cleanup):
+        if test:
+            test.cleanup()
     del _Cleanup[:]
-    cleanlist.reverse()
-    for test in cleanlist:
-        test.cleanup()
     if _chain_to_exitfunc:
         _chain_to_exitfunc()
 
 try:
     import atexit
 except ImportError:
     # TODO(1.5): atexit requires python 2.0, so chain sys.exitfunc
     try:
         _chain_to_exitfunc = sys.exitfunc
     except AttributeError:
         pass
     sys.exitfunc = _clean
 else:
     atexit.register(_clean)
 
 try:
     zip
 except NameError:
     def zip(*lists):
         result = []
-        for i in xrange(min(map(len, lists))):
+        for i in range(min(map(len, lists))):
             result.append(tuple(map(lambda l, i=i: l[i], lists)))
         return result
 
-class Collector:
-    def __init__(self, top):
-        self.entries = [top]
-    def __call__(self, arg, dirname, names):
-        pathjoin = lambda n, d=dirname: os.path.join(d, n)
-        self.entries.extend(map(pathjoin, names))
-
 def _caller(tblist, skip):
     string = ""
     arr = []
     for file, line, name, text in tblist:
         if file[-10:] == "TestCmd.py":
                 break
         arr = [(file, line, name, text)] + arr
     atfrom = "at"
     for file, line, name, text in arr[skip:]:
         if name in ("?", "<module>"):
@@ skipping 72 matching lines @@
         return
     if not function is None:
         function()
     sys.stderr.write("PASSED\n")
     sys.exit(0)
 
 def match_exact(lines = None, matches = None):
     """
     """
     if not is_List(lines):
-        lines = string.split(lines, "\n")
+        lines = lines.split("\n")
     if not is_List(matches):
-        matches = string.split(matches, "\n")
+        matches = matches.split("\n")
     if len(lines) != len(matches):
         return
     for i in range(len(lines)):
         if lines[i] != matches[i]:
             return
     return 1
 
 def match_re(lines = None, res = None):
     """
     """
     if not is_List(lines):
-        lines = string.split(lines, "\n")
+        lines = lines.split("\n")
     if not is_List(res):
-        res = string.split(res, "\n")
+        res = res.split("\n")
     if len(lines) != len(res):
         return
     for i in range(len(lines)):
         s = "^" + res[i] + "$"
         try:
             expr = re.compile(s)
-        except re.error, e:
+        except re.error as e:
             msg = "Regular expression error in %s: %s"
-            raise re.error, msg % (repr(s), e[0])
+            raise re.error(msg % (repr(s), e[0]))
         if not expr.search(lines[i]):
             return
     return 1
 
 def match_re_dotall(lines = None, res = None):
     """
     """
     if not type(lines) is type(""):
-        lines = string.join(lines, "\n")
+        lines = "\n".join(lines)
     if not type(res) is type(""):
-        res = string.join(res, "\n")
+        res = "\n".join(res)
     s = "^" + res + "$"
     try:
         expr = re.compile(s, re.DOTALL)
-    except re.error, e:
+    except re.error as e:
         msg = "Regular expression error in %s: %s"
-        raise re.error, msg % (repr(s), e[0])
+        raise re.error(msg % (repr(s), e[0]))
     if expr.match(lines):
         return 1
 
 try:
     import difflib
 except ImportError:
     pass
 else:
     def simple_diff(a, b, fromfile='', tofile='',
                     fromfiledate='', tofiledate='', n=3, lineterm='\n'):
@@ skipping 33 matching lines @@
     diff = len(a) - len(b)
     if diff < 0:
         a = a + ['']*(-diff)
     elif diff > 0:
         b = b + ['']*diff
     i = 0
     for aline, bline in zip(a, b):
         s = "^" + aline + "$"
         try:
             expr = re.compile(s)
-        except re.error, e:
+        except re.error as e:
             msg = "Regular expression error in %s: %s"
-            raise re.error, msg % (repr(s), e[0])
+            raise re.error(msg % (repr(s), e[0]))
         if not expr.search(bline):
             result.append("%sc%s" % (i+1, i+1))
             result.append('< ' + repr(a[i]))
             result.append('---')
             result.append('> ' + repr(b[i]))
         i = i+1
     return result
 
 if os.name == 'java':
 
     python_executable = os.path.join(sys.prefix, 'jython')
 
 else:
 
     python_executable = sys.executable
 
 if sys.platform == 'win32':
 
     default_sleep_seconds = 2
 
     def where_is(file, path=None, pathext=None):
         if path is None:
             path = os.environ['PATH']
         if is_String(path):
-            path = string.split(path, os.pathsep)
+            path = path.split(os.pathsep)
         if pathext is None:
             pathext = os.environ['PATHEXT']
         if is_String(pathext):
-            pathext = string.split(pathext, os.pathsep)
+            pathext = pathext.split(os.pathsep)
         for ext in pathext:
-            if string.lower(ext) == string.lower(file[-len(ext):]):
+            if ext.lower() == file[-len(ext):].lower():
                 pathext = ['']
                 break
         for dir in path:
             f = os.path.join(dir, file)
             for ext in pathext:
                 fext = f + ext
                 if os.path.isfile(fext):
                     return fext
         return None
 
 else:
 
     def where_is(file, path=None, pathext=None):
         if path is None:
             path = os.environ['PATH']
         if is_String(path):
-            path = string.split(path, os.pathsep)
+            path = path.split(os.pathsep)
         for dir in path:
             f = os.path.join(dir, file)
             if os.path.isfile(f):
                 try:
                     st = os.stat(f)
                 except OSError:
                     continue
-                if stat.S_IMODE(st[stat.ST_MODE]) & 0111:
+                if stat.S_IMODE(st[stat.ST_MODE]) & 0o111:
                     return f
         return None
 
     default_sleep_seconds = 1
 
 
 
 try:
     import subprocess
 except ImportError:
     # The subprocess module doesn't exist in this version of Python,
     # so we're going to cobble up something that looks just enough
     # like its API for our purposes below.
     import new
 
     subprocess = new.module('subprocess')
 
     subprocess.PIPE = 'PIPE'
     subprocess.STDOUT = 'STDOUT'
-    subprocess.mswindows = (sys.platform == 'win32')
 
     try:
         import popen2
         popen2.Popen3
     except AttributeError:
-        class Popen3:
+        class Popen3(object):
             universal_newlines = 1
             def __init__(self, command, **kw):
                 if sys.platform == 'win32' and command[0] == '"':
                     command = '"' + command + '"'
                 (stdin, stdout, stderr) = os.popen3(' ' + command)
                 self.stdin = stdin
                 self.stdout = stdout
                 self.stderr = stderr
             def close_output(self):
                 self.stdout.close()
@@ skipping 41 matching lines @@
                     os.close(c2pwrite)
                     self.fromchild = os.fdopen(c2pread, 'r', bufsize)
                     popen2._active.append(self)
 
             popen2.Popen4 = Popen4
 
         class Popen3(popen2.Popen3, popen2.Popen4):
             universal_newlines = 1
             def __init__(self, command, **kw):
                 if kw.get('stderr') == 'STDOUT':
-                    apply(popen2.Popen4.__init__, (self, command, 1))
+                    popen2.Popen4.__init__(self, command, 1)
                 else:
-                    apply(popen2.Popen3.__init__, (self, command, 1))
+                    popen2.Popen3.__init__(self, command, 1)
                 self.stdin = self.tochild
                 self.stdout = self.fromchild
                 self.stderr = self.childerr
             def wait(self, *args, **kw):
-                resultcode = apply(popen2.Popen3.wait, (self,)+args, kw)
+                resultcode = popen2.Popen3.wait(self, *args, **kw)
                 if os.WIFEXITED(resultcode):
                     return os.WEXITSTATUS(resultcode)
                 elif os.WIFSIGNALED(resultcode):
                     return os.WTERMSIG(resultcode)
                 else:
                     return None
 
     subprocess.Popen = Popen3
 
 
 
 # From Josiah Carlson,
 # ASPN : Python Cookbook : Module to allow Asynchronous subprocess use on Windows and Posix platforms
 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/440554
 
 PIPE = subprocess.PIPE
 
-if subprocess.mswindows:
+if sys.platform == 'win32':
     from win32file import ReadFile, WriteFile
     from win32pipe import PeekNamedPipe
     import msvcrt
 else:
     import select
     import fcntl
 
     try:                    fcntl.F_GETFL
     except AttributeError:  fcntl.F_GETFL = 3
 
@@ skipping 14 matching lines @@
         if maxsize is None:
             maxsize = 1024
         elif maxsize < 1:
             maxsize = 1
         return getattr(self, which), maxsize
 
     def _close(self, which):
         getattr(self, which).close()
         setattr(self, which, None)
 
-    if subprocess.mswindows:
+    if sys.platform == 'win32':
         def send(self, input):
             if not self.stdin:
                 return None
 
             try:
                 x = msvcrt.get_osfhandle(self.stdin.fileno())
                 (errCode, written) = WriteFile(x, input)
             except ValueError:
                 return self._close('stdin')
-            except (subprocess.pywintypes.error, Exception), why:
+            except (subprocess.pywintypes.error, Exception) as why:
                 if why[0] in (109, errno.ESHUTDOWN):
                     return self._close('stdin')
                 raise
 
             return written
 
         def _recv(self, which, maxsize):
             conn, maxsize = self.get_conn_maxsize(which, maxsize)
             if conn is None:
                 return None
 
             try:
                 x = msvcrt.get_osfhandle(conn.fileno())
                 (read, nAvail, nMessage) = PeekNamedPipe(x, 0)
                 if maxsize < nAvail:
                     nAvail = maxsize
                 if nAvail > 0:
                     (errCode, read) = ReadFile(x, nAvail, None)
             except ValueError:
                 return self._close(which)
-            except (subprocess.pywintypes.error, Exception), why:
+            except (subprocess.pywintypes.error, Exception) as why:
                 if why[0] in (109, errno.ESHUTDOWN):
                     return self._close(which)
                 raise
 
             #if self.universal_newlines:
             #    read = self._translate_newlines(read)
             return read
 
     else:
         def send(self, input):
             if not self.stdin:
                 return None
 
             if not select.select([], [self.stdin], [], 0)[1]:
                 return 0
 
             try:
                 written = os.write(self.stdin.fileno(), input)
-            except OSError, why:
+            except OSError as why:
                 if why[0] == errno.EPIPE: #broken pipe
                     return self._close('stdin')
                 raise
 
             return written
 
         def _recv(self, which, maxsize):
             conn, maxsize = self.get_conn_maxsize(which, maxsize)
             if conn is None:
                 return None
@@ skipping 48 matching lines @@
 # TODO(3.0:  rewrite to use memoryview()
 def send_all(p, data):
     while len(data):
         sent = p.send(data)
         if sent is None:
             raise Exception(disconnect_message)
         data = buffer(data, sent)
 
 
 
-try:
-    object
-except NameError:
-    class object:
-        pass
-
-
-
 class TestCmd(object):
     """Class TestCmd
     """
 
     def __init__(self, description = None,
                        program = None,
                        interpreter = None,
                        workdir = None,
                        subdir = None,
                        verbose = None,
@@ skipping 23 matching lines @@
             try:
                 difflib
             except NameError:
                 pass
             else:
                 self.diff_function = simple_diff
                 #self.diff_function = difflib.context_diff
                 #self.diff_function = difflib.unified_diff
         self._dirlist = []
         self._preserve = {'pass_test': 0, 'fail_test': 0, 'no_result': 0}
-        if os.environ.has_key('PRESERVE') and not os.environ['PRESERVE'] is '':
+        if 'PRESERVE' in os.environ and os.environ['PRESERVE'] is not '':
             self._preserve['pass_test'] = os.environ['PRESERVE']
             self._preserve['fail_test'] = os.environ['PRESERVE']
             self._preserve['no_result'] = os.environ['PRESERVE']
         else:
             try:
                 self._preserve['pass_test'] = os.environ['PRESERVE_PASS']
             except KeyError:
                 pass
             try:
                 self._preserve['fail_test'] = os.environ['PRESERVE_FAIL']
@@ skipping 24 matching lines @@
             width = self.banner_width
         return s + self.banner_char * (width - len(s))
 
     if os.name == 'posix':
 
         def escape(self, arg):
             "escape shell special characters"
             slash = '\\'
             special = '"$'
 
-            arg = string.replace(arg, slash, slash+slash)
+            arg = arg.replace(slash, slash+slash)
             for c in special:
-                arg = string.replace(arg, c, slash+c)
+                arg = arg.replace(c, slash+c)
 
             if re_space.search(arg):
                 arg = '"' + arg + '"'
             return arg
 
     else:
 
         # Windows does not allow special characters in file names
         # anyway, so no need for an escape function, we will just quote
         # the arg.
         def escape(self, arg):
             if re_space.search(arg):
                 arg = '"' + arg + '"'
             return arg
 
     def canonicalize(self, path):
         if is_List(path):
-            path = apply(os.path.join, tuple(path))
+            path = os.path.join(*path)
         if not os.path.isabs(path):
             path = os.path.join(self.workdir, path)
         return path
 
     def chmod(self, path, mode):
         """Changes permissions on the specified file or directory
         path name."""
         path = self.canonicalize(path)
         os.chmod(path, mode)
 
@@ skipping 13 matching lines @@
         appropriate for the exit status.
         """
         if not self._dirlist:
             return
         os.chdir(self._cwd)
         self.workdir = None
         if condition is None:
             condition = self.condition
         if self._preserve[condition]:
             for dir in self._dirlist:
-                print "Preserved directory", dir
+                print("Preserved directory", dir)
         else:
             list = self._dirlist[:]
             list.reverse()
             for dir in list:
                 self.writable(dir, 1)
                 shutil.rmtree(dir, ignore_errors = 1)
             self._dirlist = []
 
         try:
             global _Cleanup
@@ skipping 13 matching lines @@
                 interpreter = self.interpreter
         if not type(program) in [type([]), type(())]:
             program = [program]
         cmd = list(program)
         if interpreter:
             if not type(interpreter) in [type([]), type(())]:
                 interpreter = [interpreter]
             cmd = list(interpreter) + cmd
         if arguments:
             if type(arguments) == type(''):
-                arguments = string.split(arguments)
+                arguments = arguments.split()
             cmd.extend(arguments)
         return cmd
 
     def description_set(self, description):
         """Set the description of the functionality being tested.
         """
         self.description = description
 
     try:
         difflib
     except NameError:
         def diff(self, a, b, name, *args, **kw):
-            print self.banner('Expected %s' % name)
-            print a
-            print self.banner('Actual %s' % name)
-            print b
+            print(self.banner('Expected %s' % name))
+            print(a)
+            print(self.banner('Actual %s' % name))
+            print(b)
     else:
         def diff(self, a, b, name, *args, **kw):
-            print self.banner(name)
+            print(self.banner(name))
             args = (a.splitlines(), b.splitlines()) + args
-            lines = apply(self.diff_function, args, kw)
+            lines = self.diff_function(*args, **kw)
             for l in lines:
-                print l
+                print(l)
 
     def fail_test(self, condition = 1, function = None, skip = 0):
         """Cause the test to fail.
         """
         if not condition:
             return
         self.condition = 'fail_test'
         fail_test(self = self,
                   condition = condition,
                   function = function,
@@ skipping 56 matching lines @@
         for cond in conditions:
             self._preserve[cond] = 1
 
     def program_set(self, program):
         """Set the executable program or script to be tested.
         """
         if program and not os.path.isabs(program):
             program = os.path.join(self._cwd, program)
         self.program = program
 
-    def read(self, file, mode = 'rb'):
+    def read(self, file, mode = 'r'):
         """Reads and returns the contents of the specified file name.
         The file name may be a list, in which case the elements are
         concatenated with the os.path.join() method.  The file is
         assumed to be under the temporary working directory unless it
         is an absolute path name.  The I/O mode for the file may
         be specified; it must begin with an 'r'.  The default is
-        'rb' (binary read).
+        'r' (string read).
         """
         file = self.canonicalize(file)
         if mode[0] != 'r':
-            raise ValueError, "mode must begin with 'r'"
+            raise ValueError("mode must begin with 'r'")
         with open(file, mode) as f:
             result = f.read()
         return result
 
     def rmdir(self, dir):
         """Removes the specified dir name.
         The dir name may be a list, in which case the elements are
         concatenated with the os.path.join() method.  The dir is
         assumed to be under the temporary working directory unless it
         is an absolute path name.
         The dir must be empty.
         """
         dir = self.canonicalize(dir)
         os.rmdir(dir)
 
     def start(self, program = None,
                     interpreter = None,
                     arguments = None,
                     universal_newlines = None,
                     **kw):
         """
         Starts a program or script for the test environment.
 
         The specified program will have the original directory
         prepended unless it is enclosed in a [list].
         """
         cmd = self.command_args(program, interpreter, arguments)
-        cmd_string = string.join(map(self.escape, cmd), ' ')
+        cmd_string = ' '.join(map(self.escape, cmd))
         if self.verbose:
             sys.stderr.write(cmd_string + "\n")
         if universal_newlines is None:
             universal_newlines = self.universal_newlines
 
         # On Windows, if we make stdin a pipe when we plan to send 
         # no input, and the test program exits before
         # Popen calls msvcrt.open_osfhandle, that call will fail.
         # So don't use a pipe for stdin if we don't need one.
         stdin = kw.get('stdin', None)
@@ skipping 144 matching lines @@
 
                 test.subdir('sub', ['sub', 'dir'], ['sub', 'dir', 'ectory'])
 
         Returns the number of subdirectories actually created.
         """
         count = 0
         for sub in subdirs:
             if sub is None:
                 continue
             if is_List(sub):
-                sub = apply(os.path.join, tuple(sub))
+                sub = os.path.join(*sub)
             new = os.path.join(self.workdir, sub)
             try:
                 os.mkdir(new)
             except OSError:
                 pass
             else:
                 count = count + 1
         return count
 
     def symlink(self, target, link):
@@ skipping 27 matching lines @@
         try:
             os.chdir(path)
             path = os.getcwd()
         finally:
             os.chdir(cwd)
 
         # Uppercase the drive letter since the case of drive
         # letters is pretty much random on win32:
         drive,rest = os.path.splitdrive(path)
         if drive:
-            path = string.upper(drive) + rest
+            path = drive.upper() + rest
 
         #
         self._dirlist.append(path)
         global _Cleanup
         try:
             _Cleanup.index(self)
         except ValueError:
             _Cleanup.append(self)
 
         return path
@@ skipping 21 matching lines @@
 
     def verbose_set(self, verbose):
         """Set the verbose level.
         """
         self.verbose = verbose
 
     def where_is(self, file, path=None, pathext=None):
         """Find an executable file.
         """
         if is_List(file):
-            file = apply(os.path.join, tuple(file))
+            file = os.path.join(*file)
         if not os.path.isabs(file):
             file = where_is(file, path, pathext)
         return file
 
     def workdir_set(self, path):
         """Creates a temporary working directory with the specified
         path name.  If the path is a null string (''), a unique
         directory name is created.
         """
         if (path != None):
             if path == '':
                 path = None
             path = self.tempdir(path)
         self.workdir = path
 
     def workpath(self, *args):
         """Returns the absolute path name to a subdirectory or file
         within the current temporary working directory.  Concatenates
         the temporary working directory name with the specified
         arguments using the os.path.join() method.
         """
-        return apply(os.path.join, (self.workdir,) + tuple(args))
+        return os.path.join(self.workdir, *args)
 
     def readable(self, top, read=1):
         """Make the specified directory tree readable (read == 1)
         or not (read == None).
 
         This method has no effect on Windows systems, which use a
         completely different mechanism to control file readability.
         """
 
         if sys.platform == 'win32':
@@ skipping 10 matching lines @@
                 except OSError: pass
                 else: os.chmod(fname, stat.S_IMODE(st[stat.ST_MODE]&~stat.S_IREAD))
 
         if os.path.isfile(top):
             # If it's a file, that's easy, just chmod it.
             do_chmod(top)
         elif read:
             # It's a directory and we're trying to turn on read
             # permission, so it's also pretty easy, just chmod the
             # directory and then chmod every entry on our walk down the
-            # tree.  Because os.path.walk() is top-down, we'll enable
+            # tree.  Because os.walk() is top-down, we'll enable
             # read permission on any directories that have it disabled
-            # before os.path.walk() tries to list their contents.
+            # before os.walk() tries to list their contents.
             do_chmod(top)
 
-            def chmod_entries(arg, dirname, names, do_chmod=do_chmod):
-                for n in names:
+            for dirname, dirnames, filenames in os.walk(top):
+                for n in dirnames:
                     do_chmod(os.path.join(dirname, n))
-
-            os.path.walk(top, chmod_entries, None)
+                for n in filenames:
+                    do_chmod(os.path.join(dirname, n))
         else:
             # It's a directory and we're trying to turn off read
             # permission, which means we have to chmod the directoreis
             # in the tree bottom-up, lest disabling read permission from
             # the top down get in the way of being able to get at lower
-            # parts of the tree.  But os.path.walk() visits things top
-            # down, so we just use an object to collect a list of all
-            # of the entries in the tree, reverse the list, and then
-            # chmod the reversed (bottom-up) list.
-            col = Collector(top)
-            os.path.walk(top, col, None)
-            col.entries.reverse()
-            for d in col.entries: do_chmod(d)
+            # parts of the tree.
+            for dirname, dirnames, filenames in os.walk(top, topdown=False):
+                for n in dirnames:
+                    do_chmod(os.path.join(dirname, n))
+                for n in filenames:
+                    do_chmod(os.path.join(dirname, n))
+
+            do_chmod(top)
 
     def writable(self, top, write=1):
         """Make the specified directory tree writable (write == 1)
         or not (write == None).
         """
 
         if sys.platform == 'win32':
 
             if write:
                 def do_chmod(fname):
                     try: os.chmod(fname, stat.S_IWRITE)
                     except OSError: pass
             else:
                 def do_chmod(fname):
                     try: os.chmod(fname, stat.S_IREAD)
                     except OSError: pass
 
         else:
 
             if write:
                 def do_chmod(fname):
                     try: st = os.stat(fname)
                     except OSError: pass
-                    else: os.chmod(fname, stat.S_IMODE(st[stat.ST_MODE]|0200))
+                    else: os.chmod(fname, stat.S_IMODE(st[stat.ST_MODE]|0o200))
             else:
                 def do_chmod(fname):
                     try: st = os.stat(fname)
                     except OSError: pass
-                    else: os.chmod(fname, stat.S_IMODE(st[stat.ST_MODE]&~0200))
+                    else: os.chmod(fname, stat.S_IMODE(st[stat.ST_MODE]&~0o200))
 
         if os.path.isfile(top):
             do_chmod(top)
         else:
-            col = Collector(top)
-            os.path.walk(top, col, None)
-            for d in col.entries: do_chmod(d)
+            do_chmod(top)
+            for dirname, dirnames, filenames in os.walk(top):
+                for n in dirnames:
+                    do_chmod(os.path.join(dirname, n))
+                for n in filenames:
+                    do_chmod(os.path.join(dirname, n))
 
     def executable(self, top, execute=1):
         """Make the specified directory tree executable (execute == 1)
         or not (execute == None).
 
         This method has no effect on Windows systems, which use a
         completely different mechanism to control file executability.
         """
 
         if sys.platform == 'win32':
@@ skipping 10 matching lines @@
                 except OSError: pass
                 else: os.chmod(fname, stat.S_IMODE(st[stat.ST_MODE]&~stat.S_IEXEC))
 
         if os.path.isfile(top):
             # If it's a file, that's easy, just chmod it.
             do_chmod(top)
         elif execute:
             # It's a directory and we're trying to turn on execute
             # permission, so it's also pretty easy, just chmod the
             # directory and then chmod every entry on our walk down the
-            # tree.  Because os.path.walk() is top-down, we'll enable
+            # tree.  Because os.walk() is top-down, we'll enable
             # execute permission on any directories that have it disabled
-            # before os.path.walk() tries to list their contents.
+            # before os.walk() tries to list their contents.
             do_chmod(top)
 
-            def chmod_entries(arg, dirname, names, do_chmod=do_chmod):
-                for n in names:
+            for dirname, dirnames, filenames in os.walk(top):
+                for n in dirnames:
                     do_chmod(os.path.join(dirname, n))
-
-            os.path.walk(top, chmod_entries, None)
+                for n in filenames:
+                    do_chmod(os.path.join(dirname, n))
         else:
             # It's a directory and we're trying to turn off execute
             # permission, which means we have to chmod the directories
             # in the tree bottom-up, lest disabling execute permission from
             # the top down get in the way of being able to get at lower
-            # parts of the tree.  But os.path.walk() visits things top
-            # down, so we just use an object to collect a list of all
-            # of the entries in the tree, reverse the list, and then
-            # chmod the reversed (bottom-up) list.
-            col = Collector(top)
-            os.path.walk(top, col, None)
-            col.entries.reverse()
-            for d in col.entries: do_chmod(d)
+            # parts of the tree.
+            for dirname, dirnames, filenames in os.walk(top, topdown=False):
+                for n in dirnames:
+                    do_chmod(os.path.join(dirname, n))
+                for n in filenames:
+                    do_chmod(os.path.join(dirname, n))
 
-    def write(self, file, content, mode = 'wb'):
+            do_chmod(top)
+
+    def write(self, file, content, mode = 'w'):
         """Writes the specified content text (second argument) to the
         specified file name (first argument).  The file name may be
         a list, in which case the elements are concatenated with the
         os.path.join() method.  The file is created under the temporary
         working directory.  Any subdirectories in the path must already
         exist.  The I/O mode for the file may be specified; it must
-        begin with a 'w'.  The default is 'wb' (binary write).
+        begin with a 'w'.  The default is 'w' (string write).
         """
         file = self.canonicalize(file)
         if mode[0] != 'w':
-            raise ValueError, "mode must begin with 'w'"
+            raise ValueError("mode must begin with 'w'")
         with open(file, mode) as f:
             f.write(content)
 
 # Local Variables:
 # tab-width:4
 # indent-tabs-mode:nil
 # End:
 # vim: set expandtab tabstop=4 shiftwidth=4: