"""
-TestSCmd.py: a testing framework for commands and scripts.
+TestSCons.py: a testing framework for the SCons software construction
+tool.
-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.
+A TestSCons environment object is created via the usual invocation:
-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.
+ test = TestSCons()
-A TestCmd environment object is created via the usual invocation:
-
- test = TestCmd()
-
-The TestCmd module provides pass_test(), fail_test(), and no_result()
-unbound methods 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).
+TestScons is a subclass of TestCmd, and hence has available all of its
+methods and attributes, as well as any overridden or additional methods
+or attributes defined in this subclass.
"""
# Copyright 2001 Steven Knight
import os
import TestCmd
+class TestFailed(Exception):
+ def __init__(self, args=None):
+ self.args = args
+
+class TestNoResult(Exception):
+ def __init__(self, args=None):
+ self.args = args
+
class TestSCons(TestCmd.TestCmd):
- """Class for testing SCons
+ """Class for testing SCons.
+
+ This provides a common place for initializing SCons tests,
+ eliminating the need to begin every test with the same repeated
+ initializations.
"""
def __init__(self, **kw):
+ """Initialize an SCons testing object.
+
+ If they're not overridden by keyword arguments, this
+ initializes the object with the following default values:
+
+ program = 'scons.py'
+ interpreter = 'python'
+ workdir = ''
+
+ The workdir value means that, by default, a temporary workspace
+ directory is created for a TestSCons environment. In addition,
+ this method changes directory (chdir) to the workspace directory,
+ so an explicit "chdir = '.'" on all of the run() method calls
+ is not necessary.
+ """
if not kw.has_key('program'):
kw['program'] = 'scons.py'
if not kw.has_key('interpreter'):
apply(TestCmd.TestCmd.__init__, [self], kw)
os.chdir(self.workdir)
-# def __del__(self):
-# self.cleanup()
-#
-# def __repr__(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
-#
-# def description_set(self, description):
-# """Set the description of the functionality being tested.
-# """
-# self.description = description
-#
-## def diff(self):
-## """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)
-#
-# def interpreter_set(self, 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)
-#
-# def match_exact(self, 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)
-#
-# 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)
-#
-# 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)
-#
-# 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
-#
-# 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'):
-# """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 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()
-#
-# 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 = 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 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()
-# self._status = childerr.close()
-# except:
-# raise
-# else:
-# if stdin:
-# if type(stdin) is 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)
-#
-# 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
-# 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
-# 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 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
-#
-# def verbose_set(self, verbose):
-# """Set the verbose level.
-# """
-# self.verbose = verbose
-#
-# 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()
-# os.chdir(cwd)
-# 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))
-#
-# 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
-# os.path.walk(top, _walk_chmod, f)
-#
-# 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 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)
+ def run(self, stdout = None, stderr = '', **kw):
+ """Runs SCons.
+
+ This is the same as the base TestCmd.run() method, with
+ the addition of
+
+ stdout The expected standard output from
+ the command. A value of None means
+ don't test standard output.
+
+ stderr The expected error output from
+ the command. A value of None means
+ don't test error output.
+
+ By default, this does not test standard output (stdout = None),
+ and expects that error output is empty (stderr = "").
+ """
+ try:
+ apply(TestCmd.TestCmd.run, [self], kw)
+ except:
+ print "STDOUT ============"
+ print self.stdout()
+ print "STDERR ============"
+ print self.stderr()
+ raise
+ if stdout and not self.match(self.stdout(), stdout):
+ print "Expected STDOUT =========="
+ print stdout
+ print "Actual STDOUT ============"
+ print self.stdout()
+ raise TestFailed
+ if stderr and not self.match(self.stderr(), stderr):
+ print "Expected STDERR =========="
+ print stderr
+ print "Actual STDERR ============"
+ print self.stderr()
+ raise TestFailed
Help("Help text\ngoes here.\n")
""")
-test.run(arguments = '-h')
+expect = "Help text\ngoes here.\n\nUse scons -H for help about command-line options.\n"
-test.fail_test(test.stdout() != "Help text\ngoes here.\n\nUse scons -H for help about command-line options.\n")
-test.fail_test(test.stderr() != "")
+test.run(arguments = '-h', stdout = expect)
test.pass_test()
test.run(arguments = '-j 3 f1 f2 f3 f4')
-test.run(program = test.workpath('f1'))
-test.fail_test(test.stdout() != "f1.c\n")
+test.run(program = test.workpath('f1'), stdout = "f1.c\n")
-test.run(program = test.workpath('f2'))
-test.fail_test(test.stdout() != "f2.c\n")
+test.run(program = test.workpath('f2'), stdout = "f2.c\n")
-test.run(program = test.workpath('f3'))
-test.fail_test(test.stdout() != "f3.c\n")
-
-test.run(program = test.workpath('f4'))
-test.fail_test(test.stdout() != "f4.c\n")
+test.run(program = test.workpath('f3'), stdout = "f3.c\n")
+test.run(program = test.workpath('f4'), stdout = "f4.c\n")
test.pass_test()
test.run(arguments = 'foo')
-test.run(program = test.workpath('foo'))
-
-test.fail_test(test.stdout() != "foo.c\n")
+test.run(program = test.workpath('foo'), stdout = "foo.c\n")
test.pass_test()
wpath = test.workpath()
-test.run(chdir = '.')
-test.fail_test(test.stdout() != ("SConstruct %s\nSConscript %s\n" % (wpath, wpath)))
+test.run(stdout = "SConstruct %s\nSConscript %s\n" % (wpath, wpath))
test.pass_test()
print "sconstruct", os.getcwd()
""")
-test.run(chdir = '.')
-
-test.fail_test(test.stdout() != ("sconstruct %s\n" % wpath))
+test.run(stdout = "sconstruct %s\n" % wpath)
test.write('Sconstruct', """
import os
print "Sconstruct", os.getcwd()
""")
-test.run(chdir = '.')
-
-test.fail_test(test.stdout() != ("Sconstruct %s\n" % wpath))
+test.run(stdout = "Sconstruct %s\n" % wpath)
test.write('SConstruct', """
import os
print "SConstruct", os.getcwd()
""")
-test.run(chdir = '.')
-
-test.fail_test(test.stdout() != ("SConstruct %s\n" % wpath))
+test.run(stdout = "SConstruct %s\n" % wpath)
test.pass_test()
test = TestSCons.TestSCons()
test.write('SConstruct1', """
-a ! int(2.0)
+a ! x
""")
-test.run(arguments='-f SConstruct1')
-test.fail_test(test.stderr() != """ File "SConstruct1", line 2
- a ! int(2.0)
+test.run(arguments='-f SConstruct1', stderr = """ File "SConstruct1", line 2
- ^
+ a ! x
+
+ \^
SyntaxError: invalid syntax
test.write('SConstruct2', """
raise UserError, 'Depends() require both sources and targets.'
""")
-test.run(arguments='-f SConstruct2')
-test.fail_test(test.stderr() != """
-SCons error: Depends() require both sources and targets.
-File "SConstruct2", line 2, in ?
+test.run(arguments='-f SConstruct2', stderr = """
+SCons error: Depends\(\) require both sources and targets.
+File "SConstruct2", line 2, in \?
""")
-
test.write('SConstruct3', """
raise InternalError, 'error inside'
""")
-test.run(arguments='-f SConstruct3')
-expect = r"""Traceback \((most recent call|innermost) last\):
+test.run(arguments='-f SConstruct3', stderr = r"""Traceback \((most recent call|innermost) last\):
File ".*scons\.py", line \d+, in \?
main\(\)
File ".*scons\.py", line \d+, in main
File "SConstruct3", line \d+, in \?
raise InternalError, 'error inside'
InternalError: error inside
-"""
-test.fail_test(not test.match_re(test.stderr(), expect))
+""")
test.pass_test()
__revision__ = "test/exitfns.py __REVISION__ __DATE__ __DEVELOPER__"
+import TestCmd
import TestSCons
-test = TestSCons.TestSCons()
+test = TestSCons.TestSCons(match = TestCmd.match_exact)
sconstruct = """
from scons.exitfuncs import *
test.write('SConstruct', sconstruct)
-test.run(arguments='-f SConstruct')
-
-test.fail_test(test.stdout() != expected_output)
+test.run(arguments='-f SConstruct', stdout = expected_output)
test.write('SConstruct', """import sys
def f():
sys.exitfunc = f
""" + sconstruct)
-test.run(arguments='-f SConstruct')
-
-test.fail_test(test.stdout() != expected_output)
+test.run(arguments='-f SConstruct', stdout = expected_output)
test.pass_test()
expect = "python build.py -f1.out\npython build.py -f2.out\n"
-test.run(arguments = '-- -f1.out -f2.out')
-
-test.fail_test(test.stdout() != expect)
-test.fail_test(test.stderr() != "")
+test.run(arguments = '-- -f1.out -f2.out', stdout = expect)
test.fail_test(not os.path.exists(test.workpath('-f1.out')))
test.fail_test(not os.path.exists(test.workpath('-f2.out')))
print "sub/dir/SConstruct", os.getcwd()
""")
-test.run(arguments = '-C sub')
+test.run(arguments = '-C sub',
+ stdout = "sub/SConstruct %s\n" % wpath_sub)
-test.fail_test(test.stdout() != "sub/SConstruct %s\n" % wpath_sub)
-test.fail_test(test.stderr() != "")
+test.run(arguments = '-C sub -C dir',
+ stdout = "sub/dir/SConstruct %s\n" % wpath_sub_dir)
-test.run(arguments = '-C sub -C dir')
+test.run(stdout = "SConstruct %s\n" % wpath)
-test.fail_test(test.stdout() != "sub/dir/SConstruct %s\n" % wpath_sub_dir)
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--directory=sub/dir',
+ stdout = "sub/dir/SConstruct %s\n" % wpath_sub_dir)
-test.run(chdir = '.')
-
-test.fail_test(test.stdout() != "SConstruct %s\n" % wpath)
-test.fail_test(test.stderr() != "")
-
-test.run(arguments = '--directory=sub/dir')
-
-test.fail_test(test.stdout() != "sub/dir/SConstruct %s\n" % wpath_sub_dir)
-test.fail_test(test.stderr() != "")
-
-test.run(arguments = '-C %s -C %s' % (wpath_sub_dir, wpath_sub))
-
-test.fail_test(test.stdout() != "sub/SConstruct %s\n" % wpath_sub)
-test.fail_test(test.stderr() != "")
+test.run(arguments = '-C %s -C %s' % (wpath_sub_dir, wpath_sub),
+ stdout = "sub/SConstruct %s\n" % wpath_sub)
test.pass_test()
print bar.variable
""")
-test.run(arguments = '-I sub1 -I sub2')
+test.run(arguments = '-I sub1 -I sub2', stdout = "sub1/foo\nsub2/bar\n")
-test.fail_test(test.stdout() != "sub1/foo\nsub2/bar\n")
-test.fail_test(test.stderr() != "")
-
-test.run(arguments = '--include-dir=sub2 --include-dir=sub1')
-
-test.fail_test(test.stdout() != "sub2/foo\nsub2/bar\n")
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--include-dir=sub2 --include-dir=sub1',
+ stdout = "sub2/foo\nsub2/bar\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-R')
+test.run(arguments = '-R',
+ stderr = "Warning: the -R option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the -R option is not yet implemented\n")
-
-test.run(arguments = '--no-builtin-variables')
-
-test.fail_test(test.stderr() !=
- "Warning: the --no-builtin-variables option is not yet implemented\n")
+test.run(arguments = '--no-builtin-variables',
+ stderr = "Warning: the --no-builtin-variables option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-S')
+test.run(arguments = '-S', stderr = "Warning: ignoring -S option\n")
-test.fail_test(test.stderr() !=
- "Warning: ignoring -S option\n")
+test.run(arguments = '--no-keep-going',
+ stderr = "Warning: ignoring --no-keep-going option\n")
-test.run(arguments = '--no-keep-going')
-
-test.fail_test(test.stderr() !=
- "Warning: ignoring --no-keep-going option\n")
-
-test.run(arguments = '--stop')
-
-test.fail_test(test.stderr() !=
- "Warning: ignoring --stop option\n")
+test.run(arguments = '--stop', stderr = "Warning: ignoring --stop option\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-W foo')
+test.run(arguments = '-W foo',
+ stderr = "Warning: the -W option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the -W option is not yet implemented\n")
+test.run(arguments = '--what-if=foo',
+ stderr = "Warning: the --what-if option is not yet implemented\n")
-test.run(arguments = '--what-if=foo')
+test.run(arguments = '--new-file=foo',
+ stderr = "Warning: the --new-file option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the --what-if option is not yet implemented\n")
-
-test.run(arguments = '--new-file=foo')
-
-test.fail_test(test.stderr() !=
- "Warning: the --new-file option is not yet implemented\n")
-
-test.run(arguments = '--assume-new=foo')
-
-test.fail_test(test.stderr() !=
- "Warning: the --assume-new option is not yet implemented\n")
+test.run(arguments = '--assume-new=foo',
+ stderr = "Warning: the --assume-new option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-Y foo')
+test.run(arguments = '-Y foo',
+ stderr = "Warning: the -Y option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the -Y option is not yet implemented\n")
-
-test.run(arguments = '--repository=foo')
-
-test.fail_test(test.stderr() !=
- "Warning: the --repository option is not yet implemented\n")
+test.run(arguments = '--repository=foo',
+ stderr = "Warning: the --repository option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '--cache-disable')
+test.run(arguments = '--cache-disable',
+ stderr = "Warning: the --cache-disable option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the --cache-disable option is not yet implemented\n")
-
-test.run(arguments = '--no-cache')
-
-test.fail_test(test.stderr() !=
- "Warning: the --no-cache option is not yet implemented\n")
+test.run(arguments = '--no-cache',
+ stderr = "Warning: the --no-cache option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '--cache-force')
+test.run(arguments = '--cache-force',
+ stderr = "Warning: the --cache-force option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the --cache-force option is not yet implemented\n")
-
-test.run(arguments = '--cache-populate')
-
-test.fail_test(test.stderr() !=
- "Warning: the --cache-populate option is not yet implemented\n")
+test.run(arguments = '--cache-populate',
+ stderr = "Warning: the --cache-populate option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '--cache-show')
-
-test.fail_test(test.stderr() !=
- "Warning: the --cache-show option is not yet implemented\n")
+test.run(arguments = '--cache-show',
+ stderr = "Warning: the --cache-show option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '--list-actions')
-
-test.fail_test(test.stderr() !=
- "Warning: the --list-actions option is not yet implemented\n")
+test.run(arguments = '--list-actions',
+ stderr = "Warning: the --list-actions option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '--list-derived')
-
-test.fail_test(test.stderr() !=
- "Warning: the --list-derived option is not yet implemented\n")
+test.run(arguments = '--list-derived',
+ stderr = "Warning: the --list-derived option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '--list-where')
-
-test.fail_test(test.stderr() !=
- "Warning: the --list-where option is not yet implemented\n")
+test.run(arguments = '--list-where',
+ stderr = "Warning: the --list-where option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '--no-print-directory')
-
-test.fail_test(test.stderr() !=
- "Warning: the --no-print-directory option is not yet implemented\n")
+test.run(arguments = '--no-print-directory',
+ stderr = "Warning: the --no-print-directory option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '--override=foo')
-
-test.fail_test(test.stderr() !=
- "Warning: the --override option is not yet implemented\n")
+test.run(arguments = '--override=foo',
+ stderr = "Warning: the --override option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '--random')
-
-test.fail_test(test.stderr() !=
- "Warning: the --random option is not yet implemented\n")
+test.run(arguments = '--random',
+ stderr = "Warning: the --random option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '--write-filenames=FILE')
-
-test.fail_test(test.stderr() !=
- "Warning: the --write-filenames option is not yet implemented\n")
+test.run(arguments = '--write-filenames=FILE',
+ stderr = "Warning: the --write-filenames option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '--warn-undefined-variables')
-
-test.fail_test(test.stderr() !=
- "Warning: the --warn-undefined-variables option is not yet implemented\n")
+test.run(arguments = '--warn-undefined-variables',
+ stderr = "Warning: the --warn-undefined-variables option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-b')
-
-test.fail_test(test.stderr() !=
- "Warning: ignoring -b option\n")
+test.run(arguments = '-b',
+ stderr = "Warning: ignoring -b option\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-c')
+test.run(arguments = '-c',
+ stderr = "Warning: the -c option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the -c option is not yet implemented\n")
+test.run(arguments = '--clean',
+ stderr = "Warning: the --clean option is not yet implemented\n")
-test.run(arguments = '--clean')
-
-test.fail_test(test.stderr() !=
- "Warning: the --clean option is not yet implemented\n")
-
-test.run(arguments = '--remove')
-
-test.fail_test(test.stderr() !=
- "Warning: the --remove option is not yet implemented\n")
+test.run(arguments = '--remove',
+ stderr = "Warning: the --remove option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-d')
-
-test.fail_test(test.stderr() !=
- "Warning: the -d option is not yet implemented\n")
+test.run(arguments = '-d',
+ stderr = "Warning: the -d option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-e')
+test.run(arguments = '-e',
+ stderr = "Warning: the -e option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the -e option is not yet implemented\n")
-
-test.run(arguments = '--environment-overrides')
-
-test.fail_test(test.stderr() !=
- "Warning: the --environment-overrides option is not yet implemented\n")
+test.run(arguments = '--environment-overrides',
+ stderr = "Warning: the --environment-overrides option is not yet implemented\n")
test.pass_test()
wpath = test.workpath()
-test.run(arguments = '-f SConscript')
-test.fail_test(test.stdout() != ("SConscript %s\n" % wpath))
-test.fail_test(test.stderr() != "")
+test.run(arguments = '-f SConscript',
+ stdout = "SConscript %s\n" % wpath)
-test.run(arguments = '-f ' + subdir_BuildThis)
-test.fail_test(test.stdout() != ("subdir/BuildThis %s\n" % wpath))
-test.fail_test(test.stderr() != "")
+test.run(arguments = '-f ' + subdir_BuildThis,
+ stdout = "subdir/BuildThis %s\n" % wpath)
-test.run(arguments = '--file=SConscript')
-test.fail_test(test.stdout() != ("SConscript %s\n" % wpath))
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--file=SConscript',
+ stdout = "SConscript %s\n" % wpath)
-test.run(arguments = '--file=' + subdir_BuildThis)
-test.fail_test(test.stdout() != ("subdir/BuildThis %s\n" % wpath))
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--file=' + subdir_BuildThis,
+ stdout = "subdir/BuildThis %s\n" % wpath)
-test.run(arguments = '--makefile=SConscript')
-test.fail_test(test.stdout() != ("SConscript %s\n" % wpath))
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--makefile=SConscript',
+ stdout = "SConscript %s\n" % wpath)
-test.run(arguments = '--makefile=' + subdir_BuildThis)
-test.fail_test(test.stdout() != ("subdir/BuildThis %s\n" % wpath))
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--makefile=' + subdir_BuildThis,
+ stdout = "subdir/BuildThis %s\n" % wpath)
-test.run(arguments = '--sconstruct=SConscript')
-test.fail_test(test.stdout() != ("SConscript %s\n" % wpath))
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--sconstruct=SConscript',
+ stdout = "SConscript %s\n" % wpath)
-test.run(arguments = '--sconstruct=' + subdir_BuildThis)
-test.fail_test(test.stdout() != ("subdir/BuildThis %s\n" % wpath))
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--sconstruct=' + subdir_BuildThis,
+ stdout = "subdir/BuildThis %s\n" % wpath)
test.run(arguments = '-f -', stdin = """
import os
print "STDIN " + os.getcwd()
-""")
-test.fail_test(test.stdout() != ("STDIN %s\n" % wpath))
-test.fail_test(test.stderr() != "")
+""",
+ stdout = "STDIN %s\n" % wpath)
-test.run(arguments = '-f no_such_file')
-test.fail_test(test.stdout() != "")
-test.fail_test(test.stderr() != "Ignoring missing script 'no_such_file'\n")
+test.run(arguments = '-f no_such_file',
+ stdout = "",
+ stderr = "Ignoring missing script 'no_such_file'\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-i')
+test.run(arguments = '-i',
+ stderr = "Warning: the -i option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the -i option is not yet implemented\n")
-
-test.run(arguments = '--ignore-errors')
-
-test.fail_test(test.stderr() !=
- "Warning: the --ignore-errors option is not yet implemented\n")
+test.run(arguments = '--ignore-errors',
+ stderr = "Warning: the --ignore-errors option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-k')
+test.run(arguments = '-k',
+ stderr = "Warning: the -k option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the -k option is not yet implemented\n")
-
-test.run(arguments = '--keep-going')
-
-test.fail_test(test.stderr() !=
- "Warning: the --keep-going option is not yet implemented\n")
+test.run(arguments = '--keep-going',
+ stderr = "Warning: the --keep-going option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-l 1')
+test.run(arguments = '-l 1',
+ stderr = "Warning: the -l option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the -l option is not yet implemented\n")
+test.run(arguments = '--load-average=1',
+ stderr = "Warning: the --load-average option is not yet implemented\n")
-test.run(arguments = '--load-average=1')
-
-test.fail_test(test.stderr() !=
- "Warning: the --load-average option is not yet implemented\n")
-
-test.run(arguments = '--max-load=1')
-
-test.fail_test(test.stderr() !=
- "Warning: the --max-load option is not yet implemented\n")
+test.run(arguments = '--max-load=1',
+ stderr = "Warning: the --max-load option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-m')
-
-test.fail_test(test.stderr() !=
- "Warning: ignoring -m option\n")
+test.run(arguments = '-m',
+ stderr = "Warning: ignoring -m option\n")
test.pass_test()
args = 'f1.out f2.out'
expect = "python build.py f1.out\npython build.py f2.out\n"
-test.run(arguments = args)
-
-test.fail_test(test.stdout() != expect)
-test.fail_test(test.stderr() != "")
+test.run(arguments = args, stdout = expect)
test.fail_test(not os.path.exists(test.workpath('f1.out')))
test.fail_test(not os.path.exists(test.workpath('f2.out')))
os.unlink(test.workpath('f1.out'))
os.unlink(test.workpath('f2.out'))
-test.run(arguments = '-n ' + args)
-
-test.fail_test(test.stdout() != expect)
-test.fail_test(test.stderr() != "")
+test.run(arguments = '-n ' + args, stdout = expect)
test.fail_test(os.path.exists(test.workpath('f1.out')))
test.fail_test(os.path.exists(test.workpath('f2.out')))
-test.run(arguments = '--no-exec ' + args)
-
-test.fail_test(test.stdout() != expect)
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--no-exec ' + args, stdout = expect)
test.fail_test(os.path.exists(test.workpath('f1.out')))
test.fail_test(os.path.exists(test.workpath('f2.out')))
-test.run(arguments = '--just-print ' + args)
-
-test.fail_test(test.stdout() != expect)
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--just-print ' + args, stdout = expect)
test.fail_test(os.path.exists(test.workpath('f1.out')))
test.fail_test(os.path.exists(test.workpath('f2.out')))
-test.run(arguments = '--dry-run ' + args)
-
-test.fail_test(test.stdout() != expect)
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--dry-run ' + args, stdout = expect)
test.fail_test(os.path.exists(test.workpath('f1.out')))
test.fail_test(os.path.exists(test.workpath('f2.out')))
-test.run(arguments = '--recon ' + args)
-
-test.fail_test(test.stdout() != expect)
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--recon ' + args, stdout = expect)
test.fail_test(os.path.exists(test.workpath('f1.out')))
test.fail_test(os.path.exists(test.workpath('f2.out')))
test.write('SConstruct', "")
-test.run(arguments = '-o foo')
+test.run(arguments = '-o foo',
+ stderr = "Warning: the -o option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the -o option is not yet implemented\n")
+test.run(arguments = '--old-file=foo',
+ stderr = "Warning: the --old-file option is not yet implemented\n")
-test.run(arguments = '--old-file=foo')
-
-test.fail_test(test.stderr() !=
- "Warning: the --old-file option is not yet implemented\n")
-
-test.run(arguments = '--assume-old=foo')
-
-test.fail_test(test.stderr() !=
- "Warning: the --assume-old option is not yet implemented\n")
+test.run(arguments = '--assume-old=foo',
+ stderr = "Warning: the --assume-old option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-p')
-
-test.fail_test(test.stderr() !=
- "Warning: the -p option is not yet implemented\n")
+test.run(arguments = '-p',
+ stderr = "Warning: the -p option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-q')
+test.run(arguments = '-q',
+ stderr = "Warning: the -q option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the -q option is not yet implemented\n")
-
-test.run(arguments = '--question')
-
-test.fail_test(test.stderr() !=
- "Warning: the --question option is not yet implemented\n")
+test.run(arguments = '--question',
+ stderr = "Warning: the --question option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-r')
+test.run(arguments = '-r',
+ stderr = "Warning: the -r option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the -r option is not yet implemented\n")
-
-test.run(arguments = '--no-builtin-rules')
-
-test.fail_test(test.stderr() !=
- "Warning: the --no-builtin-rules option is not yet implemented\n")
+test.run(arguments = '--no-builtin-rules',
+ stderr = "Warning: the --no-builtin-rules option is not yet implemented\n")
test.pass_test()
env.MyBuild(target = 'f2.out', source = 'f2.in')
""")
-test.run(arguments = '-s f1.out f2.out')
-
-test.fail_test(test.stdout() != "")
-test.fail_test(test.stderr() != "")
+test.run(arguments = '-s f1.out f2.out', stdout = "")
test.fail_test(not os.path.exists(test.workpath('f1.out')))
test.fail_test(not os.path.exists(test.workpath('f2.out')))
os.unlink(test.workpath('f1.out'))
os.unlink(test.workpath('f2.out'))
-test.run(arguments = '--silent f1.out f2.out')
-
-test.fail_test(test.stdout() != "")
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--silent f1.out f2.out', stdout = "")
test.fail_test(not os.path.exists(test.workpath('f1.out')))
test.fail_test(not os.path.exists(test.workpath('f2.out')))
os.unlink(test.workpath('f1.out'))
os.unlink(test.workpath('f2.out'))
-test.run(arguments = '--quiet f1.out f2.out')
-
-test.fail_test(test.stdout() != "")
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--quiet f1.out f2.out', stdout = "")
test.fail_test(not os.path.exists(test.workpath('f1.out')))
test.fail_test(not os.path.exists(test.workpath('f2.out')))
test.write('SConstruct', "")
-test.run(arguments = '-t')
+test.run(arguments = '-t',
+ stderr = "Warning: ignoring -t option\n")
-test.fail_test(test.stderr() !=
- "Warning: ignoring -t option\n")
-
-test.run(arguments = '--touch')
-
-test.fail_test(test.stderr() !=
- "Warning: ignoring --touch option\n")
+test.run(arguments = '--touch',
+ stderr = "Warning: ignoring --touch option\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-u')
-
-test.fail_test(test.stderr() !=
- "Warning: the -u option is not yet implemented\n")
+test.run(arguments = '-u',
+ stderr = "Warning: the -u option is not yet implemented\n")
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-v')
-
expect = r"""SCons version \S+, by Steven Knight et al.
Copyright 2001 Steven Knight
"""
-test.fail_test(not test.match_re(test.stdout(), expect))
-test.fail_test(test.stderr() != "")
-
-test.run(arguments = '--version')
+test.run(arguments = '-v', stdout = expect)
-test.fail_test(not test.match_re(test.stdout(), expect))
-test.fail_test(test.stderr() != "")
+test.run(arguments = '--version', stdout = expect)
test.pass_test()
test.write('SConstruct', "")
-test.run(arguments = '-w')
+test.run(arguments = '-w',
+ stderr = "Warning: the -w option is not yet implemented\n")
-test.fail_test(test.stderr() !=
- "Warning: the -w option is not yet implemented\n")
-
-test.run(arguments = '--print-directory')
-
-test.fail_test(test.stderr() !=
- "Warning: the --print-directory option is not yet implemented\n")
+test.run(arguments = '--print-directory',
+ stderr = "Warning: the --print-directory option is not yet implemented\n")
test.pass_test()
projects / scons.git / commitdiff