Record and print an internal stack trace when Taskmaster detects errors for easier debugging. (Gary Oberbrunner) Better debugging of Python exceptions (like TypeErrors) in SConscript files.

1 files changed, 563 insertions, 401 deletions

diff --git a/etc/TestCmd.py b/etc/TestCmd.py
index 6d6db73..1b78739 100644
--- a/etc/TestCmd.py
+++ b/etc/TestCmd.py
@@ -5,27 +5,158 @@ 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 those workspace
-directories from in-line data, here-documents), allowing tests to be
-completely self-contained.
+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
+those workspace directories from in-line data, here-documents), allowing
+tests to be completely self-contained.
 
 A TestCmd environment object is created via the usual invocation:
 
-    test = TestCmd()
+    import TestCmd
+    test = TestCmd.TestCmd()
+
+There are a bunch of keyword arguments that you can use at instantiation
+time:
+
+    test = TestCmd.TestCmd(description = 'string',
+                           program = 'program_or_script_to_test',
+                           interpreter = 'script_interpreter',
+                           workdir = 'prefix',
+                           subdir = 'subdir',
+                           verbose = Boolean,
+                           match = default_match_function,
+                           combine = Boolean)
+
+There are a bunch of methods that let you do a bunch of different
+things.  Here is an overview of them:
+
+    test.verbose_set(1)
+
+    test.description_set('string')
+
+    test.program_set('program_or_script_to_test')
+
+    test.interpreter_set('script_interpreter')
+
+    test.workdir_set('prefix')
+    test.workdir_set('')
+
+    test.workpath('file')
+    test.workpath('subdir', 'file')
+
+    test.subdir('subdir', ...)
+
+    test.write('file', "contents\n")
+    test.write(['subdir', 'file'], "contents\n")
+
+    test.read('file')
+    test.read(['subdir', 'file'])
+    test.read('file', mode)
+    test.read(['subdir', 'file'], mode)
+
+    test.writable('dir', 1)
+    test.writable('dir', None)
+
+    test.preserve(condition, ...)
+
+    test.cleanup(condition)
+
+    test.run(program = 'program_or_script_to_run',
+             interpreter = 'script_interpreter',
+             arguments = 'arguments to pass to program',
+             chdir = 'directory_to_chdir_to',
+             stdin = 'input to feed to the program\n')
+
+    test.pass_test()
+    test.pass_test(condition)
+    test.pass_test(condition, function)
+
+    test.fail_test()
+    test.fail_test(condition)
+    test.fail_test(condition, function)
+    test.fail_test(condition, function, skip)
+
+    test.no_result()
+    test.no_result(condition)
+    test.no_result(condition, function)
+    test.no_result(condition, function, skip)
+
+    test.stdout()
+    test.stdout(run)
+
+    test.stderr()
+    test.stderr(run)
+
+    test.match(actual, expected)
+
+    test.match_exact("actual 1\nactual 2\n", "expected 1\nexpected 2\n")
+    test.match_exact(["actual 1\n", "actual 2\n"],
+                     ["expected 1\n", "expected 2\n"])
+
+    test.match_re("actual 1\nactual 2\n", regex_string)
+    test.match_re(["actual 1\n", "actual 2\n"], list_of_regexes)
+
+    test.match_re_dotall("actual 1\nactual 2\n", regex_string)
+    test.match_re_dotall(["actual 1\n", "actual 2\n"], list_of_regexes)
+
+    test.sleep()
+    test.sleep(seconds)
+
+    test.where_is('foo')
+    test.where_is('foo', 'PATH1:PATH2')
+    test.where_is('foo', 'PATH1;PATH2', '.suffix3;.suffix4')
+
+    test.unlink('file')
+    test.unlink('subdir', 'file')
 
 The TestCmd module provides pass_test(), fail_test(), and no_result()
-unbound methods that report test results for use with the Aegis change
+unbound functions that report test results for use with the Aegis change
 management system.  These methods terminate the test immediately,
 reporting PASSED, FAILED, or NO RESULT respectively, and exiting with
 status 0 (success), 1 or 2 respectively.  This allows for a distinction
 between an actual failed test and a test that could not be properly
 evaluated because of an external condition (such as a full file system
 or incorrect permissions).
+
+    import TestCmd
+
+    TestCmd.pass_test()
+    TestCmd.pass_test(condition)
+    TestCmd.pass_test(condition, function)
+
+    TestCmd.fail_test()
+    TestCmd.fail_test(condition)
+    TestCmd.fail_test(condition, function)
+    TestCmd.fail_test(condition, function, skip)
+
+    TestCmd.no_result()
+    TestCmd.no_result(condition)
+    TestCmd.no_result(condition, function)
+    TestCmd.no_result(condition, function, skip)
+
+The TestCmd module also provides unbound functions that handle matching
+in the same way as the match_*() methods described above.
+
+    import TestCmd
+
+    test = TestCmd.TestCmd(match = TestCmd.match_exact)
+
+    test = TestCmd.TestCmd(match = TestCmd.match_re)
+
+    test = TestCmd.TestCmd(match = TestCmd.match_re_dotall)
+
+Lastly, the where_is() method also exists in an unbound function
+version.
+
+    import TestCmd
+
+    TestCmd.where_is('foo')
+    TestCmd.where_is('foo', 'PATH1:PATH2')
+    TestCmd.where_is('foo', 'PATH1;PATH2', '.suffix3;.suffix4')
 """
 
-# Copyright 2000 Steven Knight
+# Copyright 2000, 2001, 2002, 2003 Steven Knight
 # This module is free software, and you may redistribute it and/or modify
 # it under the same terms as Python itself, so long as this copyright message
 # and disclaimer are retained in their original form.
@@ -41,9 +172,9 @@ or incorrect permissions).
 # AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
 # SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 
-__author__ = "Steven Knight <knight@baldmt.com>"
-__revision__ = "TestCmd.py 0.D002 2001/08/31 14:56:12 software"
-__version__ = "0.02"
+__author__ = "Steven Knight <knight at baldmt dot com>"
+__revision__ = "TestCmd.py 0.04.D009 2003/07/18 17:37:29 knight"
+__version__ = "0.04"
 
 import os
 import os.path
@@ -54,8 +185,14 @@ import stat
 import string
 import sys
 import tempfile
+import time
 import traceback
 import types
+import UserList
+
+def is_List(e):
+    return type(e) is types.ListType \
+        or isinstance(e, UserList.UserList)
 
 try:
     from UserString import UserString
@@ -102,7 +239,7 @@ def _clean():
     _Cleanup = []
     list.reverse()
     for test in list:
-	test.cleanup()
+        test.cleanup()
 
 sys.exitfunc = _clean
 
@@ -110,17 +247,17 @@ 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
+        if file[-10:] == "TestCmd.py":
+                break
+        arr = [(file, line, name, text)] + arr
     atfrom = "at"
     for file, line, name, text in arr[skip:]:
-	if name == "?":
-	    name = ""
-	else:
-	    name = " (" + name + ")"
-	string = string + ("%s line %d of %s%s\n" % (atfrom, line, file, name))
-	atfrom = "\tfrom"
+        if name == "?":
+            name = ""
+        else:
+            name = " (" + name + ")"
+        string = string + ("%s line %d of %s%s\n" % (atfrom, line, file, name))
+        atfrom = "\tfrom"
     return string
 
 def fail_test(self = None, condition = 1, function = None, skip = 0):
@@ -131,19 +268,19 @@ def fail_test(self = None, condition = 1, function = None, skip = 0):
     the test fails only if the condition is true.
     """
     if not condition:
-	return
+        return
     if not function is None:
-	function()
+        function()
     of = ""
     desc = ""
     sep = " "
     if not self is None:
-	if self.program:
-	    of = " of " + self.program
-	    sep = "\n\t"
-	if self.description:
-	    desc = " [" + self.description + "]"
-	    sep = "\n\t"
+        if self.program:
+            of = " of " + self.program
+            sep = "\n\t"
+        if self.description:
+            desc = " [" + self.description + "]"
+            sep = "\n\t"
 
     at = _caller(traceback.extract_stack(), skip)
     sys.stderr.write("FAILED test" + of + desc + sep + at)
@@ -158,19 +295,19 @@ def no_result(self = None, condition = 1, function = None, skip = 0):
     the test fails only if the condition is true.
     """
     if not condition:
-	return
+        return
     if not function is None:
-	function()
+        function()
     of = ""
     desc = ""
     sep = " "
     if not self is None:
-	if self.program:
-	    of = " of " + self.program
-	    sep = "\n\t"
-	if self.description:
-	    desc = " [" + self.description + "]"
-	    sep = "\n\t"
+        if self.program:
+            of = " of " + self.program
+            sep = "\n\t"
+        if self.description:
+            desc = " [" + self.description + "]"
+            sep = "\n\t"
 
     at = _caller(traceback.extract_stack(), skip)
     sys.stderr.write("NO RESULT for test" + of + desc + sep + at)
@@ -185,38 +322,38 @@ def pass_test(self = None, condition = 1, function = None):
     the test passes only if the condition is true.
     """
     if not condition:
-	return
+        return
     if not function is None:
-	function()
+        function()
     sys.stderr.write("PASSED\n")
     sys.exit(0)
 
 def match_exact(lines = None, matches = None):
     """
     """
-    if not type(lines) is types.ListType:
-	lines = string.split(lines, "\n")
-    if not type(matches) is types.ListType:
-	matches = string.split(matches, "\n")
+    if not is_List(lines):
+        lines = string.split(lines, "\n")
+    if not is_List(matches):
+        matches = string.split(matches, "\n")
     if len(lines) != len(matches):
-	return
+        return
     for i in range(len(lines)):
-	if lines[i] != matches[i]:
-	    return
+        if lines[i] != matches[i]:
+            return
     return 1
 
 def match_re(lines = None, res = None):
     """
     """
-    if not type(lines) is types.ListType:
-	lines = string.split(lines, "\n")
-    if not type(res) is types.ListType:
-	res = string.split(res, "\n")
+    if not is_List(lines):
+        lines = string.split(lines, "\n")
+    if not is_List(res):
+        res = string.split(res, "\n")
     if len(lines) != len(res):
-	return
+        return
     for i in range(len(lines)):
-	if not re.compile("^" + res[i] + "$").search(lines[i]):
-	    return
+        if not re.compile("^" + res[i] + "$").search(lines[i]):
+            return
     return 1
 
 def match_re_dotall(lines = None, res = None):
@@ -239,6 +376,8 @@ else:
 
 if sys.platform == 'win32':
 
+    default_sleep_seconds = 2
+
     def where_is(file, path=None, pathext=None):
         if path is None:
             path = os.environ['PATH']
@@ -278,424 +417,447 @@ else:
                     return f
         return None
 
+    default_sleep_seconds = 1
+
 class TestCmd:
     """Class TestCmd
     """
 
     def __init__(self, description = None,
-			program = None,
-			interpreter = None,
-			workdir = None,
-			subdir = None,
-			verbose = 0,
-			match = None):
-	self._cwd = os.getcwd()
-	self.description_set(description)
-	self.program_set(program)
-	self.interpreter_set(interpreter)
-	self.verbose_set(verbose)
-	if not match is None:
-	    self.match_func = match
-	else:
-	    self.match_func = match_re
-	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 '':
-	    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']
-	    except KeyError:
-		pass
-	    try:
-		self._preserve['no_result'] = os.environ['PRESERVE_NO_RESULT']
-	    except KeyError:
-		pass
-	self._stdout = []
-	self._stderr = []
-	self.status = None
-	self.condition = 'no_result'
-	self.workdir_set(workdir)
-	self.subdir(subdir)
+                       program = None,
+                       interpreter = None,
+                       workdir = None,
+                       subdir = None,
+                       verbose = 0,
+                       match = None,
+                       combine = 0):
+        self._cwd = os.getcwd()
+        self.description_set(description)
+        self.program_set(program)
+        self.interpreter_set(interpreter)
+        self.verbose_set(verbose)
+        self.combine = combine
+        if not match is None:
+            self.match_func = match
+        else:
+            self.match_func = match_re
+        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 '':
+            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']
+            except KeyError:
+                pass
+            try:
+                self._preserve['no_result'] = os.environ['PRESERVE_NO_RESULT']
+            except KeyError:
+                pass
+        self._stdout = []
+        self._stderr = []
+        self.status = None
+        self.condition = 'no_result'
+        self.workdir_set(workdir)
+        self.subdir(subdir)
 
     def __del__(self):
-	self.cleanup()
+        self.cleanup()
 
     def __repr__(self):
-	return "%x" % id(self)
+        return "%x" % id(self)
 
     def cleanup(self, condition = None):
-	"""Removes any temporary working directories for the specified
-	TestCmd environment.  If the environment variable PRESERVE was
-	set when the TestCmd environment was created, temporary working
-	directories are not removed.  If any of the environment variables
-	PRESERVE_PASS, PRESERVE_FAIL, or PRESERVE_NO_RESULT were set
-	when the TestCmd environment was created, then temporary working
-	directories are not removed if the test passed, failed, or had
-	no result, respectively.  Temporary working directories are also
-	preserved for conditions specified via the preserve method.
-
-	Typically, this method is not called directly, but is used when
-	the script exits to clean up temporary working directories as
-	appropriate for the exit status.
-	"""
-	if not self._dirlist:
-	    return
-	if condition is None:
-	    condition = self.condition
-	#print "cleanup(" + condition + "):  ", self._preserve
-	if self._preserve[condition]:
-	    return
-	os.chdir(self._cwd)
-	self.workdir = None
-	list = self._dirlist[:]
-	self._dirlist = []
-	list.reverse()
-	for dir in list:
-	    self.writable(dir, 1)
-	    shutil.rmtree(dir, ignore_errors = 1)
-	try:
-	    global _Cleanup
-	    _Cleanup.remove(self)
-	except (AttributeError, ValueError):
-	    pass
+        """Removes any temporary working directories for the specified
+        TestCmd environment.  If the environment variable PRESERVE was
+        set when the TestCmd environment was created, temporary working
+        directories are not removed.  If any of the environment variables
+        PRESERVE_PASS, PRESERVE_FAIL, or PRESERVE_NO_RESULT were set
+        when the TestCmd environment was created, then temporary working
+        directories are not removed if the test passed, failed, or had
+        no result, respectively.  Temporary working directories are also
+        preserved for conditions specified via the preserve method.
+
+        Typically, this method is not called directly, but is used when
+        the script exits to clean up temporary working directories as
+        appropriate for the exit status.
+        """
+        if not self._dirlist:
+            return
+        if condition is None:
+            condition = self.condition
+        if self._preserve[condition]:
+            for dir in self._dirlist:
+                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 = []
+                
+        self.workdir = None
+        os.chdir(self._cwd)            
+        try:
+            global _Cleanup
+            _Cleanup.remove(self)
+        except (AttributeError, ValueError):
+            pass
 
     def description_set(self, description):
-	"""Set the description of the functionality being tested.
-	"""
-	self.description = description
+        """Set the description of the functionality being tested.
+        """
+        self.description = description
 
 #    def diff(self):
-#	"""Diff two arrays.
-#	"""
+#        """Diff two arrays.
+#        """
 
     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,
-		  skip = skip)
+        """Cause the test to fail.
+        """
+        if not condition:
+            return
+        self.condition = 'fail_test'
+        fail_test(self = self,
+                  condition = condition,
+                  function = function,
+                  skip = skip)
 
     def interpreter_set(self, interpreter):
-	"""Set the program to be used to interpret the program
-	under test as a script.
-	"""
-	self.interpreter = interpreter
+        """Set the program to be used to interpret the program
+        under test as a script.
+        """
+        self.interpreter = interpreter
 
     def match(self, lines, matches):
-	"""Compare actual and expected file contents.
-	"""
-	return self.match_func(lines, matches)
+        """Compare actual and expected file contents.
+        """
+        return self.match_func(lines, matches)
 
     def match_exact(self, lines, matches):
-	"""Compare actual and expected file contents.
-	"""
-	return match_exact(lines, matches)
+        """Compare actual and expected file contents.
+        """
+        return match_exact(lines, matches)
 
     def match_re(self, lines, res):
-	"""Compare actual and expected file contents.
-	"""
-	return match_re(lines, res)
+        """Compare actual and expected file contents.
+        """
+        return match_re(lines, res)
+
+    def match_re_dotall(self, lines, res):
+        """Compare actual and expected file contents.
+        """
+        return match_re_dotall(lines, res)
 
     def no_result(self, condition = 1, function = None, skip = 0):
-	"""Report that the test could not be run.
-	"""
-	if not condition:
-	    return
-	self.condition = 'no_result'
-	no_result(self = self,
-		  condition = condition,
-		  function = function,
-		  skip = skip)
+        """Report that the test could not be run.
+        """
+        if not condition:
+            return
+        self.condition = 'no_result'
+        no_result(self = self,
+                  condition = condition,
+                  function = function,
+                  skip = skip)
 
     def pass_test(self, condition = 1, function = None):
-	"""Cause the test to pass.
-	"""
-	if not condition:
-	    return
-	self.condition = 'pass_test'
-	pass_test(self = self, condition = condition, function = function)
+        """Cause the test to pass.
+        """
+        if not condition:
+            return
+        self.condition = 'pass_test'
+        pass_test(self = self, condition = condition, function = function)
 
     def preserve(self, *conditions):
-	"""Arrange for the temporary working directories for the
-	specified TestCmd environment to be preserved for one or more
-	conditions.  If no conditions are specified, arranges for
-	the temporary working directories to be preserved for all
-	conditions.
-	"""
-	if conditions is ():
-	    conditions = ('pass_test', 'fail_test', 'no_result')
-	for cond in conditions:
-	    self._preserve[cond] = 1
+        """Arrange for the temporary working directories for the
+        specified TestCmd environment to be preserved for one or more
+        conditions.  If no conditions are specified, arranges for
+        the temporary working directories to be preserved for all
+        conditions.
+        """
+        if conditions is ():
+            conditions = ('pass_test', 'fail_test', 'no_result')
+        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
+        """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'):
-	"""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).
-	"""
-	if type(file) is types.ListType:
-	    file = apply(os.path.join, tuple(file))
-	if not os.path.isabs(file):
-	    file = os.path.join(self.workdir, file)
-	if mode[0] != 'r':
-	    raise ValueError, "mode must begin with 'r'"
-	return open(file, mode).read()
+        """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).
+        """
+        if is_List(file):
+            file = apply(os.path.join, tuple(file))
+        if not os.path.isabs(file):
+            file = os.path.join(self.workdir, file)
+        if mode[0] != 'r':
+            raise ValueError, "mode must begin with 'r'"
+        return open(file, mode).read()
 
     def run(self, program = None,
-		  interpreter = None,
-		  arguments = None,
-		  chdir = None,
-		  stdin = None):
-	"""Runs a test of the program or script for the test
-	environment.  Standard output and error output are saved for
-	future retrieval via the stdout() and stderr() methods.
-	"""
-	if chdir:
-	    oldcwd = os.getcwd()
-	    if not os.path.isabs(chdir):
-		chdir = os.path.join(self.workpath(chdir))
-	    if self.verbose:
-		sys.stderr.write("chdir(" + chdir + ")\n")
-	    os.chdir(chdir)
-	cmd = None
-	if program:
-	    if not os.path.isabs(program):
-		program = os.path.join(self._cwd, program)
-	    cmd = escape_cmd(program)
-	    if interpreter:
-		cmd = interpreter + " " + cmd
-	else:
-	    cmd = self.program
-	    if self.interpreter:
-		cmd =  self.interpreter + " " + cmd
-	if arguments:
-	    cmd = cmd + " " + arguments
-	if self.verbose:
-	    sys.stderr.write(cmd + "\n")
-	try:
+                  interpreter = None,
+                  arguments = None,
+                  chdir = None,
+                  stdin = None):
+        """Runs a test of the program or script for the test
+        environment.  Standard output and error output are saved for
+        future retrieval via the stdout() and stderr() methods.
+        """
+        if chdir:
+            oldcwd = os.getcwd()
+            if not os.path.isabs(chdir):
+                chdir = os.path.join(self.workpath(chdir))
+            if self.verbose:
+                sys.stderr.write("chdir(" + chdir + ")\n")
+            os.chdir(chdir)
+        cmd = None
+        if program:
+            if not os.path.isabs(program):
+                program = os.path.join(self._cwd, program)
+            cmd = escape_cmd(program)
+            if interpreter:
+                cmd = interpreter + " " + cmd
+        else:
+            cmd = self.program
+            if self.interpreter:
+                cmd =  self.interpreter + " " + cmd
+        if arguments:
+            cmd = cmd + " " + arguments
+        if self.verbose:
+            sys.stderr.write(cmd + "\n")
+        try:
             p = popen2.Popen3(cmd, 1)
-	except AttributeError:
-	    (tochild, fromchild, childerr) = os.popen3(cmd)
-	    if stdin:
-		if type(stdin) is types.ListType:
-		    for line in stdin:
-			tochild.write(line)
-		else:
-		    tochild.write(stdin)
-	    tochild.close()
-	    self._stdout.append(fromchild.read())
-	    self._stderr.append(childerr.read())
-	    fromchild.close()
+        except AttributeError:
+            (tochild, fromchild, childerr) = os.popen3(cmd)
+            if stdin:
+                if is_List(stdin):
+                    for line in stdin:
+                        tochild.write(line)
+                else:
+                    tochild.write(stdin)
+            tochild.close()
+            out = fromchild.read()
+            err = childerr.read()
+            if self.combine:
+                self._stdout.append(out + err)
+            else:
+                self._stdout.append(out)
+                self._stderr.append(err)
+            fromchild.close()
             self.status = childerr.close()
             if not self.status:
                 self.status = 0
-	except:
-	    raise
-	else:
-	    if stdin:
-		if type(stdin) is types.ListType:
-		    for line in stdin:
-			p.tochild.write(line)
-		else:
-		    p.tochild.write(stdin)
-	    p.tochild.close()
-	    self._stdout.append(p.fromchild.read())
-	    self._stderr.append(p.childerr.read())
-	    self.status = p.wait()
-	if chdir:
-	    os.chdir(oldcwd)
+        except:
+            raise
+        else:
+            if stdin:
+                if is_List(stdin):
+                    for line in stdin:
+                        p.tochild.write(line)
+                else:
+                    p.tochild.write(stdin)
+            p.tochild.close()
+            out = p.fromchild.read()
+            err = p.childerr.read()
+            if self.combine:
+                self._stdout.append(out + err)
+            else:
+                self._stdout.append(out)
+                self._stderr.append(err)
+            self.status = p.wait()
+        if chdir:
+            os.chdir(oldcwd)
+
+    def sleep(self, seconds = default_sleep_seconds):
+        """Sleeps at least the specified number of seconds.  If no
+        number is specified, sleeps at least the minimum number of
+        seconds necessary to advance file time stamps on the current
+        system.  Sleeping more seconds is all right.
+        """
+        time.sleep(seconds)
 
     def stderr(self, run = None):
-	"""Returns the error output from the specified run number.
-	If there is no specified run number, then returns the error
-	output of the last run.  If the run number is less than zero,
-	then returns the error output from that many runs back from the
-	current run.
-	"""
-	if not run:
-	    run = len(self._stderr)
-	elif run < 0:
-	    run = len(self._stderr) + run
-	run = run - 1
-	if run >= len(self._stderr) or run < 0:
-	    return ''
-	else:
-	    return self._stderr[run]
+        """Returns the error output from the specified run number.
+        If there is no specified run number, then returns the error
+        output of the last run.  If the run number is less than zero,
+        then returns the error output from that many runs back from the
+        current run.
+        """
+        if not run:
+            run = len(self._stderr)
+        elif run < 0:
+            run = len(self._stderr) + run
+        run = run - 1
+        return self._stderr[run]
 
     def stdout(self, run = None):
-	"""Returns the standard output from the specified run number.
-	If there is no specified run number, then returns the standard
-	output of the last run.  If the run number is less than zero,
-	then returns the standard output from that many runs back from
-	the current run.
-	"""
-	if not run:
-	    run = len(self._stdout)
-	elif run < 0:
-	    run = len(self._stdout) + run
-	run = run - 1
-	if run >= len(self._stdout) or run < 0:
-	    return ''
-	else:
-	    return self._stdout[run]
+        """Returns the standard output from the specified run number.
+        If there is no specified run number, then returns the standard
+        output of the last run.  If the run number is less than zero,
+        then returns the standard output from that many runs back from
+        the current run.
+        """
+        if not run:
+            run = len(self._stdout)
+        elif run < 0:
+            run = len(self._stdout) + run
+        run = run - 1
+        return self._stdout[run]
 
     def subdir(self, *subdirs):
-	"""Create new subdirectories under the temporary working
-	directory, one for each argument.  An argument may be a list,
-	in which case the list elements are concatenated using the
-	os.path.join() method.  Subdirectories multiple levels deep
-	must be created using a separate argument for each level:
-
-		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 type(sub) is types.ListType:
-		sub = apply(os.path.join, tuple(sub))
-	    new = os.path.join(self.workdir, sub)
-	    try:
-		os.mkdir(new)
-	    except:
-		pass
-	    else:
-		count = count + 1
-	return count
+        """Create new subdirectories under the temporary working
+        directory, one for each argument.  An argument may be a list,
+        in which case the list elements are concatenated using the
+        os.path.join() method.  Subdirectories multiple levels deep
+        must be created using a separate argument for each level:
+
+                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))
+            new = os.path.join(self.workdir, sub)
+            try:
+                os.mkdir(new)
+            except:
+                pass
+            else:
+                count = count + 1
+        return count
 
     def unlink (self, file):
         """Unlinks 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.
-	"""
-	if type(file) is types.ListType:
-	    file = apply(os.path.join, tuple(file))
-	if not os.path.isabs(file):
-	    file = os.path.join(self.workdir, file)
+        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.
+        """
+        if is_List(file):
+            file = apply(os.path.join, tuple(file))
+        if not os.path.isabs(file):
+            file = os.path.join(self.workdir, file)
         os.unlink(file)
-        
 
     def verbose_set(self, verbose):
-	"""Set the verbose level.
-	"""
-	self.verbose = verbose
+        """Set the verbose level.
+        """
+        self.verbose = verbose
 
     def where_is(self, file, path=None, pathext=None):
         """Find an executable file.
         """
-	if type(file) is types.ListType:
+	if is_List(file):
 	    file = apply(os.path.join, tuple(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 = tempfile.mktemp()
-	    if path != None:
-		os.mkdir(path)
-	    self._dirlist.append(path)
-	    global _Cleanup
-	    try:
-		_Cleanup.index(self)
-	    except ValueError:
-		_Cleanup.append(self)
-	    # We'd like to set self.workdir like this:
-	    #	self.workdir = path
-	    # But symlinks in the path will report things
-	    # differently from os.getcwd(), so chdir there
-	    # and back to fetch the canonical path.
-	    cwd = os.getcwd()
-	    os.chdir(path)
-	    self.workdir = os.getcwd()
+        """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 = tempfile.mktemp()
+            if path != None:
+                os.mkdir(path)
+            # We'd like to set self.workdir like this:
+            #     self.workdir = path
+            # But symlinks in the path will report things
+            # differently from os.getcwd(), so chdir there
+            # and back to fetch the canonical path.
+            cwd = os.getcwd()
+            os.chdir(path)
+            self.workdir = os.getcwd()
+            os.chdir(cwd)
             # Uppercase the drive letter since the case of drive
             # letters is pretty much random on win32:
             drive,rest = os.path.splitdrive(self.workdir)
             if drive:
                 self.workdir = string.upper(drive) + rest
-	    os.chdir(cwd)
-	else:
-	    self.workdir = None
+            #
+            self._dirlist.append(self.workdir)
+            global _Cleanup
+            try:
+                _Cleanup.index(self)
+            except ValueError:
+                _Cleanup.append(self)
+        else:
+            self.workdir = None
 
     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))
+        """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))
 
     def writable(self, top, write):
-	"""Make the specified directory tree writable (write == 1)
-	or not (write == None).
-	"""
-
-	def _walk_chmod(arg, dirname, names):
-	    st = os.stat(dirname)
-	    os.chmod(dirname, arg(st[stat.ST_MODE]))
-	    for name in names:
-		n = os.path.join(dirname, name)
-		st = os.stat(n)
-		os.chmod(n, arg(st[stat.ST_MODE]))
-
-	def _mode_writable(mode):
-	    return stat.S_IMODE(mode|0200)
-
-	def _mode_non_writable(mode):
-	    return stat.S_IMODE(mode&~0200)
-
-	if write:
-	    f = _mode_writable
-	else:
-	    f = _mode_non_writable
-	try:
-	    os.path.walk(top, _walk_chmod, f)
-	except:
-	    pass # ignore any problems changing modes
-	    
+        """Make the specified directory tree writable (write == 1)
+        or not (write == None).
+        """
+
+        def _walk_chmod(arg, dirname, names):
+            st = os.stat(dirname)
+            os.chmod(dirname, arg(st[stat.ST_MODE]))
+            for name in names:
+                n = os.path.join(dirname, name)
+                st = os.stat(n)
+                os.chmod(n, arg(st[stat.ST_MODE]))
+
+        def _mode_writable(mode):
+            return stat.S_IMODE(mode|0200)
+
+        def _mode_non_writable(mode):
+            return stat.S_IMODE(mode&~0200)
+
+        if write:
+            f = _mode_writable
+        else:
+            f = _mode_non_writable
+        try:
+            os.path.walk(top, _walk_chmod, f)
+        except:
+            pass # ignore any problems changing modes
+
     def write(self, file, content, mode = 'wb'):
-	"""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).
-	"""
-	if type(file) is types.ListType:
-	    file = apply(os.path.join, tuple(file))
-	if not os.path.isabs(file):
-	    file = os.path.join(self.workdir, file)
-	if mode[0] != 'w':
-	    raise ValueError, "mode must begin with 'w'"
-	open(file, mode).write(content)
+        """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).
+        """
+        if is_List(file):
+            file = apply(os.path.join, tuple(file))
+        if not os.path.isabs(file):
+            file = os.path.join(self.workdir, file)
+        if mode[0] != 'w':
+            raise ValueError, "mode must begin with 'w'"
+        open(file, mode).write(content)