summaryrefslogtreecommitdiff
path: root/QMTest/TestSCons.py
diff options
context:
space:
mode:
Diffstat (limited to 'QMTest/TestSCons.py')
-rw-r--r--QMTest/TestSCons.py1617
1 files changed, 0 insertions, 1617 deletions
diff --git a/QMTest/TestSCons.py b/QMTest/TestSCons.py
deleted file mode 100644
index c0b4ebc..0000000
--- a/QMTest/TestSCons.py
+++ /dev/null
@@ -1,1617 +0,0 @@
-"""
-TestSCons.py: a testing framework for the SCons software construction
-tool.
-
-A TestSCons environment object is created via the usual invocation:
-
- test = TestSCons()
-
-TestScons is a subclass of TestCommon, which in turn is a subclass
-of TestCmd), and hence has available all of the methods and attributes
-from those classes, as well as any overridden or additional methods or
-attributes defined in this subclass.
-"""
-
-# Copyright (c) 2001 - 2017 The SCons Foundation
-from __future__ import division, print_function
-
-__revision__ = "QMTest/TestSCons.py rel_3.0.0:4395:8972f6a2f699 2017/09/18 12:59:24 bdbaddog"
-
-import os
-import re
-import shutil
-import sys
-import time
-import subprocess
-
-from TestCommon import *
-from TestCommon import __all__
-
-from TestCmd import Popen
-from TestCmd import PIPE
-
-# Some tests which verify that SCons has been packaged properly need to
-# look for specific version file names. Replicating the version number
-# here provides some independent verification that what we packaged
-# conforms to what we expect.
-
-default_version = '3.0.0'
-
-python_version_unsupported = (2, 6, 0)
-python_version_deprecated = (2, 7, 0)
-
-# In the checked-in source, the value of SConsVersion in the following
-# line must remain "__ VERSION __" (without the spaces) so the built
-# version in build/QMTest/TestSCons.py contains the actual version
-# string of the packages that have been built.
-SConsVersion = '3.0.0'
-if SConsVersion == '__' + 'VERSION' + '__':
- SConsVersion = default_version
-
-__all__.extend([
- 'TestSCons',
- 'machine',
- 'python',
- '_exe',
- '_obj',
- '_shobj',
- 'shobj_',
- 'lib_',
- '_lib',
- 'dll_',
- '_dll'
- ])
-
-machine_map = {
- 'i686' : 'i386',
- 'i586' : 'i386',
- 'i486' : 'i386',
-}
-
-try:
- uname = os.uname
-except AttributeError:
- # Windows doesn't have a uname() function. We could use something like
- # sys.platform as a fallback, but that's not really a "machine," so
- # just leave it as None.
- machine = None
-else:
- machine = uname()[4]
- machine = machine_map.get(machine, machine)
-
-_exe = exe_suffix
-_obj = obj_suffix
-_shobj = shobj_suffix
-shobj_ = shobj_prefix
-_lib = lib_suffix
-lib_ = lib_prefix
-_dll = dll_suffix
-dll_ = dll_prefix
-
-
-if sys.platform == 'cygwin':
- # On Cygwin, os.path.normcase() lies, so just report back the
- # fact that the underlying Win32 OS is case-insensitive.
- def case_sensitive_suffixes(s1, s2):
- return 0
-else:
- def case_sensitive_suffixes(s1, s2):
- return (os.path.normcase(s1) != os.path.normcase(s2))
-
-
-file_expr = r"""File "[^"]*", line \d+, in [^\n]+
-"""
-
-# re.escape escapes too much.
-def re_escape(str):
- for c in '\\.[]()*+?': # Not an exhaustive list.
- str = str.replace(c, '\\' + c)
- return str
-
-#
-# Helper functions that we use as a replacement to the default re.match
-# when searching for special strings in stdout/stderr.
-#
-def search_re(out, l):
- """ Search the regular expression 'l' in the output 'out'
- and return the start index when successful.
- """
- m = re.search(l, out)
- if m:
- return m.start()
-
- return None
-
-def search_re_in_list(out, l):
- """ Search the regular expression 'l' in each line of
- the given string list 'out' and return the line's index
- when successful.
- """
- for idx, o in enumerate(out):
- m = re.search(l, o)
- if m:
- return idx
-
- return None
-
-#
-# Helpers for handling Python version numbers
-#
-def python_version_string():
- return sys.version.split()[0]
-
-def python_minor_version_string():
- return sys.version[:3]
-
-def unsupported_python_version(version=sys.version_info):
- return version < python_version_unsupported
-
-def deprecated_python_version(version=sys.version_info):
- return version < python_version_deprecated
-
-if deprecated_python_version():
- msg = r"""
-scons: warning: Support for pre-2.7.0 Python version (%s) is deprecated.
- If this will cause hardship, contact scons-dev@scons.org
-"""
-
- deprecated_python_expr = re_escape(msg % python_version_string()) + file_expr
- del msg
-else:
- deprecated_python_expr = ""
-
-
-def initialize_sconsflags(ignore_python_version):
- """
- Add the --warn=no-python-version option to SCONSFLAGS for every
- command so test scripts don't have to filter out Python version
- deprecation warnings.
- Same for --warn=no-visual-c-missing.
- """
- save_sconsflags = os.environ.get('SCONSFLAGS')
- if save_sconsflags:
- sconsflags = [save_sconsflags]
- else:
- sconsflags = []
- if ignore_python_version and deprecated_python_version():
- sconsflags.append('--warn=no-python-version')
- # Provide a way to suppress or provide alternate flags for
- # TestSCons purposes by setting TESTSCONS_SCONSFLAGS.
- # (The intended use case is to set it to null when running
- # timing tests of earlier versions of SCons which don't
- # support the --warn=no-visual-c-missing warning.)
- visual_c = os.environ.get('TESTSCONS_SCONSFLAGS',
- '--warn=no-visual-c-missing')
- if visual_c:
- sconsflags.append(visual_c)
- os.environ['SCONSFLAGS'] = ' '.join(sconsflags)
- return save_sconsflags
-
-def restore_sconsflags(sconsflags):
- if sconsflags is None:
- del os.environ['SCONSFLAGS']
- else:
- os.environ['SCONSFLAGS'] = sconsflags
-
-
-class TestSCons(TestCommon):
- """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.
- """
-
- scons_version = SConsVersion
- javac_is_gcj = False
-
- 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' if it exists,
- else 'scons.py'
- interpreter = 'python'
- match = match_exact
- 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.
- """
- self.orig_cwd = os.getcwd()
- self.external = os.environ.get('SCONS_EXTERNAL_TEST', 0)
-
- if not self.external:
- try:
- script_dir = os.environ['SCONS_SCRIPT_DIR']
- except KeyError:
- pass
- else:
- os.chdir(script_dir)
- if 'program' not in kw:
- kw['program'] = os.environ.get('SCONS')
- if not kw['program']:
- if not self.external:
- if os.path.exists('scons'):
- kw['program'] = 'scons'
- else:
- kw['program'] = 'scons.py'
- else:
- kw['program'] = 'scons'
- kw['interpreter'] = ''
- elif not self.external and not os.path.isabs(kw['program']):
- kw['program'] = os.path.join(self.orig_cwd, kw['program'])
- if 'interpreter' not in kw and not os.environ.get('SCONS_EXEC'):
- kw['interpreter'] = [python, '-tt']
- if 'match' not in kw:
- kw['match'] = match_exact
- if 'workdir' not in kw:
- kw['workdir'] = ''
-
- # Term causing test failures due to bogus readline init
- # control character output on FC8
- # TERM can cause test failures due to control chars in prompts etc.
- os.environ['TERM'] = 'dumb'
-
- self.ignore_python_version = kw.get('ignore_python_version', 1)
- if kw.get('ignore_python_version', -1) != -1:
- del kw['ignore_python_version']
-
- TestCommon.__init__(self, **kw)
-
- if not self.external:
- import SCons.Node.FS
- if SCons.Node.FS.default_fs is None:
- SCons.Node.FS.default_fs = SCons.Node.FS.FS()
-
- try:
- self.fixture_dirs = (os.environ['FIXTURE_DIRS']).split(os.pathsep)
- except KeyError:
- pass
-
- def Environment(self, ENV=None, *args, **kw):
- """
- Return a construction Environment that optionally overrides
- the default external environment with the specified ENV.
- """
- if not self.external:
- import SCons.Environment
- import SCons.Errors
- if not ENV is None:
- kw['ENV'] = ENV
- try:
- return SCons.Environment.Environment(*args, **kw)
- except (SCons.Errors.UserError, SCons.Errors.InternalError):
- return None
-
- return None
-
- def detect(self, var, prog=None, ENV=None, norm=None):
- """
- Detect a program named 'prog' by first checking the construction
- variable named 'var' and finally searching the path used by
- SCons. If either method fails to detect the program, then false
- is returned, otherwise the full path to prog is returned. If
- prog is None, then the value of the environment variable will be
- used as prog.
- """
- env = self.Environment(ENV)
- if env:
- v = env.subst('$'+var)
- if not v:
- return None
- if prog is None:
- prog = v
- if v != prog:
- return None
- result = env.WhereIs(prog)
- if norm and os.sep != '/':
- result = result.replace(os.sep, '/')
- return result
-
- return self.where_is(prog)
-
- def detect_tool(self, tool, prog=None, ENV=None):
- """
- Given a tool (i.e., tool specification that would be passed
- to the "tools=" parameter of Environment()) and a program that
- corresponds to that tool, return true if and only if we can find
- that tool using Environment.Detect().
-
- By default, prog is set to the value passed into the tools parameter.
- """
-
- if not prog:
- prog = tool
- env = self.Environment(ENV, tools=[tool])
- if env is None:
- return None
- return env.Detect([prog])
-
- def where_is(self, prog, path=None):
- """
- Given a program, search for it in the specified external PATH,
- or in the actual external PATH if none is specified.
- """
- if path is None:
- path = os.environ['PATH']
- if self.external:
- if isinstance(prog, str):
- prog = [prog]
- import stat
- paths = path.split(os.pathsep)
- for p in prog:
- for d in paths:
- f = os.path.join(d, p)
- if os.path.isfile(f):
- try:
- st = os.stat(f)
- except OSError:
- # os.stat() raises OSError, not IOError if the file
- # doesn't exist, so in this case we let IOError get
- # raised so as to not mask possibly serious disk or
- # network issues.
- continue
- if stat.S_IMODE(st[stat.ST_MODE]) & 0o111:
- return os.path.normpath(f)
- else:
- import SCons.Environment
- env = SCons.Environment.Environment()
- return env.WhereIs(prog, path)
-
- return None
-
- def wrap_stdout(self, build_str = "", read_str = "", error = 0, cleaning = 0):
- """Wraps standard output string(s) in the normal
- "Reading ... done" and "Building ... done" strings
- """
- cap,lc = [ ('Build','build'),
- ('Clean','clean') ][cleaning]
- if error:
- term = "scons: %sing terminated because of errors.\n" % lc
- else:
- term = "scons: done %sing targets.\n" % lc
- return "scons: Reading SConscript files ...\n" + \
- read_str + \
- "scons: done reading SConscript files.\n" + \
- "scons: %sing targets ...\n" % cap + \
- build_str + \
- term
-
- def run(self, *args, **kw):
- """
- Set up SCONSFLAGS for every command so test scripts don't need
- to worry about unexpected warnings in their output.
- """
- sconsflags = initialize_sconsflags(self.ignore_python_version)
- try:
- TestCommon.run(self, *args, **kw)
- finally:
- restore_sconsflags(sconsflags)
-
-# Modifying the options should work and ought to be simpler, but this
-# class is used for more than just running 'scons' itself. If there's
-# an automated way of determining whether it's running 'scons' or
-# something else, this code should be resurected.
-# options = kw.get('options')
-# if options:
-# options = [options]
-# else:
-# options = []
-# if self.ignore_python_version and deprecated_python_version():
-# options.append('--warn=no-python-version')
-# # Provide a way to suppress or provide alternate flags for
-# # TestSCons purposes by setting TESTSCONS_SCONSFLAGS.
-# # (The intended use case is to set it to null when running
-# # timing tests of earlier versions of SCons which don't
-# # support the --warn=no-visual-c-missing warning.)
-# visual_c = os.environ.get('TESTSCONS_SCONSFLAGS',
-# '--warn=no-visual-c-missing')
-# if visual_c:
-# options.append(visual_c)
-# kw['options'] = ' '.join(options)
-# TestCommon.run(self, *args, **kw)
-
- def up_to_date(self, arguments = '.', read_str = "", **kw):
- s = ""
- for arg in arguments.split():
- s = s + "scons: `%s' is up to date.\n" % arg
- kw['arguments'] = arguments
- stdout = self.wrap_stdout(read_str = read_str, build_str = s)
- # Append '.*' so that timing output that comes after the
- # up-to-date output is okay.
- kw['stdout'] = re.escape(stdout) + '.*'
- kw['match'] = self.match_re_dotall
- self.run(**kw)
-
- def not_up_to_date(self, arguments = '.', **kw):
- """Asserts that none of the targets listed in arguments is
- up to date, but does not make any assumptions on other targets.
- This function is most useful in conjunction with the -n option.
- """
- s = ""
- for arg in arguments.split():
- s = s + "(?!scons: `%s' is up to date.)" % re.escape(arg)
- s = '('+s+'[^\n]*\n)*'
- kw['arguments'] = arguments
- stdout = re.escape(self.wrap_stdout(build_str='ARGUMENTSGOHERE'))
- kw['stdout'] = stdout.replace('ARGUMENTSGOHERE', s)
- kw['match'] = self.match_re_dotall
- self.run(**kw)
-
- def option_not_yet_implemented(self, option, arguments=None, **kw):
- """
- Verifies expected behavior for options that are not yet implemented:
- a warning message, and exit status 1.
- """
- msg = "Warning: the %s option is not yet implemented\n" % option
- kw['stderr'] = msg
- if arguments:
- # If it's a long option and the argument string begins with '=',
- # it's of the form --foo=bar and needs no separating space.
- if option[:2] == '--' and arguments[0] == '=':
- kw['arguments'] = option + arguments
- else:
- kw['arguments'] = option + ' ' + arguments
- return self.run(**kw)
-
- def deprecated_wrap(self, msg):
- """
- Calculate the pattern that matches a deprecation warning.
- """
- return '\nscons: warning: ' + re_escape(msg) + '\n' + file_expr
-
- def deprecated_fatal(self, warn, msg):
- """
- Determines if the warning has turned into a fatal error. If so,
- passes the test, as any remaining runs are now moot.
-
- This method expects a SConscript to be present that will causes
- the warning. The method writes a SConstruct that calls the
- SConsscript and looks to see what type of result occurs.
-
- The pattern that matches the warning is returned.
-
- TODO: Actually detect that it's now an error. We don't have any
- cases yet, so there's no way to test it.
- """
- self.write('SConstruct', """if True:
- WARN = ARGUMENTS.get('WARN')
- if WARN: SetOption('warn', WARN)
- SConscript('SConscript')
- """)
-
- def err_out():
- # TODO calculate stderr for fatal error
- return re_escape('put something here')
-
- # no option, should get one of nothing, warning, or error
- warning = self.deprecated_wrap(msg)
- self.run(arguments = '.', stderr = None)
- stderr = self.stderr()
- if stderr:
- # most common case done first
- if match_re_dotall(stderr, warning):
- # expected output
- pass
- elif match_re_dotall(stderr, err_out()):
- # now a fatal error; skip the rest of the tests
- self.pass_test()
- else:
- # test failed; have to do this by hand...
- print(self.banner('STDOUT '))
- print(self.stdout())
- print(self.diff(warning, stderr, 'STDERR '))
- self.fail_test()
-
- return warning
-
- def deprecated_warning(self, warn, msg):
- """
- Verifies the expected behavior occurs for deprecation warnings.
- This method expects a SConscript to be present that will causes
- the warning. The method writes a SConstruct and exercises various
- combinations of command-line options and SetOption parameters to
- validate that it performs correctly.
-
- The pattern that matches the warning is returned.
- """
- warning = self.deprecated_fatal(warn, msg)
-
- def RunPair(option, expected):
- # run the same test with the option on the command line and
- # then with the option passed via SetOption().
- self.run(options = '--warn=' + option,
- arguments = '.',
- stderr = expected,
- match = match_re_dotall)
- self.run(options = 'WARN=' + option,
- arguments = '.',
- stderr = expected,
- match = match_re_dotall)
-
- # all warnings off, should get no output
- RunPair('no-deprecated', '')
-
- # warning enabled, should get expected output
- RunPair(warn, warning)
-
- # warning disabled, should get either nothing or mandatory message
- expect = """()|(Can not disable mandataory warning: 'no-%s'\n\n%s)""" % (warn, warning)
- RunPair('no-' + warn, expect)
-
- return warning
-
- def diff_substr(self, expect, actual, prelen=20, postlen=40):
- i = 0
- for x, y in zip(expect, actual):
- if x != y:
- return "Actual did not match expect at char %d:\n" \
- " Expect: %s\n" \
- " Actual: %s\n" \
- % (i, repr(expect[i-prelen:i+postlen]),
- repr(actual[i-prelen:i+postlen]))
- i = i + 1
- return "Actual matched the expected output???"
-
- def python_file_line(self, file, line):
- """
- Returns a Python error line for output comparisons.
-
- The exec of the traceback line gives us the correct format for
- this version of Python.
-
- File "<string>", line 1, <module>
-
- We stick the requested file name and line number in the right
- places, abstracting out the version difference.
- """
- # This routine used to use traceback to get the proper format
- # that doesn't work well with py3. And the format of the
- # traceback seems to be stable, so let's just format
- # an appropriate string
- #
- #exec('import traceback; x = traceback.format_stack()[-1]')
- # import traceback
- # x = traceback.format_stack()
- # x = # XXX: .lstrip()
- # x = x.replace('<string>', file)
- # x = x.replace('line 1,', 'line %s,' % line)
- # x="\n".join(x)
- x='File "%s", line %s, in <module>\n'%(file,line)
- return x
-
- def normalize_ps(self, s):
- s = re.sub(r'(Creation|Mod)Date: .*',
- r'\1Date XXXX', s)
- s = re.sub(r'%DVIPSSource:\s+TeX output\s.*',
- r'%DVIPSSource: TeX output XXXX', s)
- s = re.sub(r'/(BaseFont|FontName) /[A-Z0-9]{6}',
- r'/\1 /XXXXXX', s)
- s = re.sub(r'BeginFont: [A-Z0-9]{6}',
- r'BeginFont: XXXXXX', s)
-
- return s
-
- @staticmethod
- def to_bytes_re_sub(pattern, repl, str, count=0, flags=0):
- """
- Wrapper around re.sub to change pattern and repl to bytes to work with
- both python 2 & 3
- """
- pattern = to_bytes(pattern)
- repl = to_bytes(repl)
- return re.sub(pattern, repl, str, count, flags)
-
- def normalize_pdf(self, s):
- s = self.to_bytes_re_sub(r'/(Creation|Mod)Date \(D:[^)]*\)',
- r'/\1Date (D:XXXX)', s)
- s = self.to_bytes_re_sub(r'/ID \[<[0-9a-fA-F]*> <[0-9a-fA-F]*>\]',
- r'/ID [<XXXX> <XXXX>]', s)
- s = self.to_bytes_re_sub(r'/(BaseFont|FontName) /[A-Z]{6}',
- r'/\1 /XXXXXX', s)
- s = self.to_bytes_re_sub(r'/Length \d+ *\n/Filter /FlateDecode\n',
- r'/Length XXXX\n/Filter /FlateDecode\n', s)
-
- try:
- import zlib
- except ImportError:
- pass
- else:
- begin_marker = to_bytes('/FlateDecode\n>>\nstream\n')
- end_marker = to_bytes('endstream\nendobj')
-
- encoded = []
- b = s.find(begin_marker, 0)
- while b != -1:
- b = b + len(begin_marker)
- e = s.find(end_marker, b)
- encoded.append((b, e))
- b = s.find(begin_marker, e + len(end_marker))
-
- x = 0
- r = []
- for b, e in encoded:
- r.append(s[x:b])
- d = zlib.decompress(s[b:e])
- d = self.to_bytes_re_sub(r'%%CreationDate: [^\n]*\n',
- r'%%CreationDate: 1970 Jan 01 00:00:00\n', d)
- d = self.to_bytes_re_sub(r'%DVIPSSource: TeX output \d\d\d\d\.\d\d\.\d\d:\d\d\d\d',
- r'%DVIPSSource: TeX output 1970.01.01:0000', d)
- d = self.to_bytes_re_sub(r'/(BaseFont|FontName) /[A-Z]{6}',
- r'/\1 /XXXXXX', d)
- r.append(d)
- x = e
- r.append(s[x:])
- s = to_bytes('').join(r)
-
- return s
-
- def paths(self,patterns):
- import glob
- result = []
- for p in patterns:
- result.extend(sorted(glob.glob(p)))
- return result
-
- def unlink_sconsignfile(self,name='.sconsign.dblite'):
- """
- Delete sconsign file.
- Note on python it seems to append .p3 to the file name so we take care of that
- Parameters
- ----------
- name - expected name of sconsign file
-
- Returns
- -------
- None
- """
- if sys.version_info[0] == 3:
- name += '.p3'
- self.unlink(name)
-
- def java_ENV(self, version=None):
- """
- Initialize with a default external environment that uses a local
- Java SDK in preference to whatever's found in the default PATH.
- """
- if not self.external:
- try:
- return self._java_env[version]['ENV']
- except AttributeError:
- self._java_env = {}
- except KeyError:
- pass
-
- import SCons.Environment
- env = SCons.Environment.Environment()
- self._java_env[version] = env
-
-
- if version:
- patterns = [
- '/usr/java/jdk%s*/bin' % version,
- '/usr/lib/jvm/*-%s*/bin' % version,
- '/usr/local/j2sdk%s*/bin' % version,
- ]
- java_path = self.paths(patterns) + [env['ENV']['PATH']]
- else:
- patterns = [
- '/usr/java/latest/bin',
- '/usr/lib/jvm/*/bin',
- '/usr/local/j2sdk*/bin',
- ]
- java_path = self.paths(patterns) + [env['ENV']['PATH']]
-
- env['ENV']['PATH'] = os.pathsep.join(java_path)
- return env['ENV']
-
- return None
-
- def java_where_includes(self,version=None):
- """
- Return java include paths compiling java jni code
- """
- import sys
-
- result = []
- if sys.platform[:6] == 'darwin':
- java_home = self.java_where_java_home(version)
- jni_path = os.path.join(java_home,'include','jni.h')
- if os.path.exists(jni_path):
- result.append(os.path.dirname(jni_path))
-
- if not version:
- version=''
- jni_dirs = ['/System/Library/Frameworks/JavaVM.framework/Headers/jni.h',
- '/usr/lib/jvm/default-java/include/jni.h',
- '/usr/lib/jvm/java-*-oracle/include/jni.h']
- else:
- jni_dirs = ['/System/Library/Frameworks/JavaVM.framework/Versions/%s*/Headers/jni.h'%version]
- jni_dirs.extend(['/usr/lib/jvm/java-*-sun-%s*/include/jni.h'%version,
- '/usr/lib/jvm/java-%s*-openjdk*/include/jni.h'%version,
- '/usr/java/jdk%s*/include/jni.h'%version])
- dirs = self.paths(jni_dirs)
- if not dirs:
- return None
- d=os.path.dirname(self.paths(jni_dirs)[0])
- result.append(d)
-
- if sys.platform == 'win32':
- result.append(os.path.join(d,'win32'))
- elif sys.platform.startswith('linux'):
- result.append(os.path.join(d,'linux'))
- return result
-
- def java_where_java_home(self, version=None):
- if sys.platform[:6] == 'darwin':
- # osx 10.11, 10.12
- home_tool = '/usr/libexec/java_home'
- java_home = False
- if os.path.exists(home_tool):
- java_home = subprocess.check_output(home_tool).strip()
- java_home = java_home.decode()
-
- if version is None:
- if java_home:
- return java_home
- else:
- homes = ['/System/Library/Frameworks/JavaVM.framework/Home',
- # osx 10.10
- '/System/Library/Frameworks/JavaVM.framework/Versions/Current/Home']
- for home in homes:
- if os.path.exists(home):
- return home
-
- else:
- if java_home.find('jdk%s'%version) != -1:
- return java_home
- else:
- home = '/System/Library/Frameworks/JavaVM.framework/Versions/%s/Home' % version
- if not os.path.exists(home):
- # This works on OSX 10.10
- home = '/System/Library/Frameworks/JavaVM.framework/Versions/Current/'
- else:
- jar = self.java_where_jar(version)
- home = os.path.normpath('%s/..'%jar)
- if os.path.isdir(home):
- return home
- print("Could not determine JAVA_HOME: %s is not a directory" % home)
- self.fail_test()
-
- def java_where_jar(self, version=None):
- ENV = self.java_ENV(version)
- if self.detect_tool('jar', ENV=ENV):
- where_jar = self.detect('JAR', 'jar', ENV=ENV)
- else:
- where_jar = self.where_is('jar', ENV['PATH'])
- if not where_jar:
- self.skip_test("Could not find Java jar, skipping test(s).\n")
- return where_jar
-
- def java_where_java(self, version=None):
- """
- Return a path to the java executable.
- """
- ENV = self.java_ENV(version)
- where_java = self.where_is('java', ENV['PATH'])
- if not where_java:
- self.skip_test("Could not find Java java, skipping test(s).\n")
- return where_java
-
- def java_where_javac(self, version=None):
- """
- Return a path to the javac compiler.
- """
- ENV = self.java_ENV(version)
- if self.detect_tool('javac'):
- where_javac = self.detect('JAVAC', 'javac', ENV=ENV)
- else:
- where_javac = self.where_is('javac', ENV['PATH'])
- if not where_javac:
- self.skip_test("Could not find Java javac, skipping test(s).\n")
- self.run(program = where_javac,
- arguments = '-version',
- stderr=None,
- status=None)
- if version:
- if self.stderr().find('javac %s' % version) == -1:
- fmt = "Could not find javac for Java version %s, skipping test(s).\n"
- self.skip_test(fmt % version)
- else:
- m = re.search(r'javac (\d\.\d)', self.stderr())
- if m:
- version = m.group(1)
- self.javac_is_gcj = False
- elif self.stderr().find('gcj'):
- version='1.2'
- self.javac_is_gcj = True
- else:
- version = None
- self.javac_is_gcj = False
- return where_javac, version
-
- def java_where_javah(self, version=None):
- ENV = self.java_ENV(version)
- if self.detect_tool('javah'):
- where_javah = self.detect('JAVAH', 'javah', ENV=ENV)
- else:
- where_javah = self.where_is('javah', ENV['PATH'])
- if not where_javah:
- self.skip_test("Could not find Java javah, skipping test(s).\n")
- return where_javah
-
- def java_where_rmic(self, version=None):
- ENV = self.java_ENV(version)
- if self.detect_tool('rmic'):
- where_rmic = self.detect('RMIC', 'rmic', ENV=ENV)
- else:
- where_rmic = self.where_is('rmic', ENV['PATH'])
- if not where_rmic:
- self.skip_test("Could not find Java rmic, skipping non-simulated test(s).\n")
- return where_rmic
-
-
- def java_get_class_files(self, dir):
- result = []
- for dirpath, dirnames, filenames in os.walk(dir):
- for fname in filenames:
- if fname.endswith('.class'):
- result.append(os.path.join(dirpath, fname))
- return sorted(result)
-
-
- def Qt_dummy_installation(self, dir='qt'):
- # create a dummy qt installation
-
- self.subdir( dir, [dir, 'bin'], [dir, 'include'], [dir, 'lib'] )
-
- self.write([dir, 'bin', 'mymoc.py'], """\
-import getopt
-import sys
-import re
-# -w and -z are fake options used in test/QT/QTFLAGS.py
-cmd_opts, args = getopt.getopt(sys.argv[1:], 'io:wz', [])
-output = None
-impl = 0
-opt_string = ''
-for opt, arg in cmd_opts:
- if opt == '-o': output = open(arg, 'w')
- elif opt == '-i': impl = 1
- else: opt_string = opt_string + ' ' + opt
-output.write("/* mymoc.py%s */\\n" % opt_string)
-for a in args:
- contents = open(a, 'r').read()
- a = a.replace('\\\\', '\\\\\\\\')
- subst = r'{ my_qt_symbol( "' + a + '\\\\n" ); }'
- if impl:
- contents = re.sub( r'#include.*', '', contents )
- output.write(contents.replace('Q_OBJECT', subst))
-output.close()
-sys.exit(0)
-""")
-
- self.write([dir, 'bin', 'myuic.py'], """\
-import os.path
-import re
-import sys
-output_arg = 0
-impl_arg = 0
-impl = None
-source = None
-opt_string = ''
-for arg in sys.argv[1:]:
- if output_arg:
- output = open(arg, 'w')
- output_arg = 0
- elif impl_arg:
- impl = arg
- impl_arg = 0
- elif arg == "-o":
- output_arg = 1
- elif arg == "-impl":
- impl_arg = 1
- elif arg[0:1] == "-":
- opt_string = opt_string + ' ' + arg
- else:
- if source:
- sys.exit(1)
- source = open(arg, 'r')
- sourceFile = arg
-output.write("/* myuic.py%s */\\n" % opt_string)
-if impl:
- output.write( '#include "' + impl + '"\\n' )
- includes = re.findall('<include.*?>(.*?)</include>', source.read())
- for incFile in includes:
- # this is valid for ui.h files, at least
- if os.path.exists(incFile):
- output.write('#include "' + incFile + '"\\n')
-else:
- output.write( '#include "my_qobject.h"\\n' + source.read() + " Q_OBJECT \\n" )
-output.close()
-sys.exit(0)
-""" )
-
- self.write([dir, 'include', 'my_qobject.h'], r"""
-#define Q_OBJECT ;
-void my_qt_symbol(const char *arg);
-""")
-
- self.write([dir, 'lib', 'my_qobject.cpp'], r"""
-#include "../include/my_qobject.h"
-#include <stdio.h>
-void my_qt_symbol(const char *arg) {
- fputs( arg, stdout );
-}
-""")
-
- self.write([dir, 'lib', 'SConstruct'], r"""
-env = Environment()
-import sys
-if sys.platform == 'win32':
- env.StaticLibrary( 'myqt', 'my_qobject.cpp' )
-else:
- env.SharedLibrary( 'myqt', 'my_qobject.cpp' )
-""")
-
- self.run(chdir = self.workpath(dir, 'lib'),
- arguments = '.',
- stderr = noisy_ar,
- match = self.match_re_dotall)
-
- self.QT = self.workpath(dir)
- self.QT_LIB = 'myqt'
- self.QT_MOC = '%s %s' % (_python_, self.workpath(dir, 'bin', 'mymoc.py'))
- self.QT_UIC = '%s %s' % (_python_, self.workpath(dir, 'bin', 'myuic.py'))
- self.QT_LIB_DIR = self.workpath(dir, 'lib')
-
- def Qt_create_SConstruct(self, place):
- if isinstance(place, list):
- place = test.workpath(*place)
- self.write(place, """\
-if ARGUMENTS.get('noqtdir', 0): QTDIR=None
-else: QTDIR=r'%s'
-env = Environment(QTDIR = QTDIR,
- QT_LIB = r'%s',
- QT_MOC = r'%s',
- QT_UIC = r'%s',
- tools=['default','qt'])
-dup = 1
-if ARGUMENTS.get('variant_dir', 0):
- if ARGUMENTS.get('chdir', 0):
- SConscriptChdir(1)
- else:
- SConscriptChdir(0)
- dup=int(ARGUMENTS.get('dup', 1))
- if dup == 0:
- builddir = 'build_dup0'
- env['QT_DEBUG'] = 1
- else:
- builddir = 'build'
- VariantDir(builddir, '.', duplicate=dup)
- print(builddir, dup)
- sconscript = Dir(builddir).File('SConscript')
-else:
- sconscript = File('SConscript')
-Export("env dup")
-SConscript( sconscript )
-""" % (self.QT, self.QT_LIB, self.QT_MOC, self.QT_UIC))
-
-
- NCR = 0 # non-cached rebuild
- CR = 1 # cached rebuild (up to date)
- NCF = 2 # non-cached build failure
- CF = 3 # cached build failure
-
- if sys.platform == 'win32':
- Configure_lib = 'msvcrt'
- else:
- Configure_lib = 'm'
-
- # to use cygwin compilers on cmd.exe -> uncomment following line
- #Configure_lib = 'm'
-
- def skip_if_not_msvc(self, check_platform=True):
- """ Check whether we are on a Windows platform and skip the
- test if not. This check can be omitted by setting
- check_platform to False.
- Then, for a win32 platform, additionally check
- whether we have a MSVC toolchain installed
- in the system, and skip the test if none can be
- found (=MinGW is the only compiler available).
- """
- if check_platform:
- if sys.platform != 'win32':
- msg = "Skipping Visual C/C++ test on non-Windows platform '%s'\n" % sys.platform
- self.skip_test(msg)
- return
-
- try:
- import SCons.Tool.MSCommon as msc
- if not msc.msvc_exists():
- msg = "No MSVC toolchain found...skipping test\n"
- self.skip_test(msg)
- except:
- pass
-
- def checkLogAndStdout(self, checks, results, cached,
- logfile, sconf_dir, sconstruct,
- doCheckLog=True, doCheckStdout=True):
- """
- Used to verify the expected output from using Configure()
- via the contents of one or both of stdout or config.log file.
- The checks, results, cached parameters all are zipped together
- for use in comparing results.
-
- TODO: Perhaps a better API makes sense?
-
- Parameters
- ----------
- checks : The Configure checks being run
-
- results : The expected results for each check
-
- cached : If the corresponding check is expected to be cached
-
- logfile : Name of the config log
-
- sconf_dir : Name of the sconf dir
-
- sconstruct : SConstruct file name
-
- doCheckLog : check specified log file, defaults to true
-
- doCheckStdout : Check stdout, defaults to true
-
- Returns
- -------
-
- """
-
- class NoMatch(Exception):
- def __init__(self, p):
- self.pos = p
-
- def matchPart(log, logfile, lastEnd, NoMatch=NoMatch):
- """
- Match part of the logfile
- """
- m = re.match(log, logfile[lastEnd:])
- if not m:
- raise NoMatch(lastEnd)
- return m.end() + lastEnd
-
- try:
-
- # Build regexp for a character which is not
- # a linesep, and in the case of CR/LF
- # build it with both CR and CR/LF
- # TODO: Not sure why this is a good idea. A static string
- # could do the same since we only have two variations
- # to do with?
- # ls = os.linesep
- # nols = "("
- # for i in range(len(ls)):
- # nols = nols + "("
- # for j in range(i):
- # nols = nols + ls[j]
- # nols = nols + "[^" + ls[i] + "])"
- # if i < len(ls)-1:
- # nols = nols + "|"
- # nols = nols + ")"
- #
- # Replaced above logic with \n as we're reading the file
- # using non-binary read. Python will translate \r\n -> \n
- # For us.
- ls = '\n'
- nols = '([^\n])'
- lastEnd = 0
-
- # Read the whole logfile
- logfile = self.read(self.workpath(logfile), mode='r')
-
- # Some debug code to keep around..
- # sys.stderr.write("LOGFILE[%s]:%s"%(type(logfile),logfile))
-
- if (doCheckLog and
- logfile.find("scons: warning: The stored build information has an unexpected class.") >= 0):
- self.fail_test()
-
- sconf_dir = sconf_dir
- sconstruct = sconstruct
-
- log = r'file\ \S*%s\,line \d+:' % re.escape(sconstruct) + ls
- if doCheckLog:
- lastEnd = matchPart(log, logfile, lastEnd)
-
- log = "\t" + re.escape("Configure(confdir = %s)" % sconf_dir) + ls
- if doCheckLog:
- lastEnd = matchPart(log, logfile, lastEnd)
-
- rdstr = ""
- cnt = 0
- for check,result,cache_desc in zip(checks, results, cached):
- log = re.escape("scons: Configure: " + check) + ls
-
- if doCheckLog:
- lastEnd = matchPart(log, logfile, lastEnd)
-
- log = ""
- result_cached = 1
- for bld_desc in cache_desc: # each TryXXX
- for ext, flag in bld_desc: # each file in TryBuild
- file = os.path.join(sconf_dir,"conftest_%d%s" % (cnt, ext))
- if flag == self.NCR:
- # NCR = Non Cached Rebuild
- # rebuild will pass
- if ext in ['.c', '.cpp']:
- log=log + re.escape(file + " <-") + ls
- log=log + r"( \|" + nols + "*" + ls + ")+?"
- else:
- log=log + "(" + nols + "*" + ls +")*?"
- result_cached = 0
- if flag == self.CR:
- # CR = cached rebuild (up to date)s
- # up to date
- log=log + \
- re.escape("scons: Configure: \"%s\" is up to date."
- % file) + ls
- log=log+re.escape("scons: Configure: The original builder "
- "output was:") + ls
- log=log+r"( \|.*"+ls+")+"
- if flag == self.NCF:
- # non-cached rebuild failure
- log=log + "(" + nols + "*" + ls + ")*?"
- result_cached = 0
- if flag == self.CF:
- # cached rebuild failure
- log=log + \
- re.escape("scons: Configure: Building \"%s\" failed "
- "in a previous run and all its sources are"
- " up to date." % file) + ls
- log=log+re.escape("scons: Configure: The original builder "
- "output was:") + ls
- log=log+r"( \|.*"+ls+")+"
- cnt = cnt + 1
- if result_cached:
- result = "(cached) " + result
- rdstr = rdstr + re.escape(check) + re.escape(result) + "\n"
- log=log + re.escape("scons: Configure: " + result) + ls + ls
-
- if doCheckLog:
- lastEnd = matchPart(log, logfile, lastEnd)
-
- log = ""
- if doCheckLog: lastEnd = matchPart(ls, logfile, lastEnd)
- if doCheckLog and lastEnd != len(logfile):
- raise NoMatch(lastEnd)
-
- except NoMatch as m:
- print("Cannot match log file against log regexp.")
- print("log file: ")
- print("------------------------------------------------------")
- print(logfile[m.pos:])
- print("------------------------------------------------------")
- print("log regexp: ")
- print("------------------------------------------------------")
- print(log)
- print("------------------------------------------------------")
- self.fail_test()
-
- if doCheckStdout:
- exp_stdout = self.wrap_stdout(".*", rdstr)
- if not self.match_re_dotall(self.stdout(), exp_stdout):
- print("Unexpected stdout: ")
- print("-----------------------------------------------------")
- print(repr(self.stdout()))
- print("-----------------------------------------------------")
- print(repr(exp_stdout))
- print("-----------------------------------------------------")
- self.fail_test()
-
- def get_python_version(self):
- """
- Returns the Python version (just so everyone doesn't have to
- hand-code slicing the right number of characters).
- """
- # see also sys.prefix documentation
- return python_minor_version_string()
-
- def get_platform_python_info(self):
- """
- Returns a path to a Python executable suitable for testing on
- this platform and its associated include path, library path,
- and library name.
- """
- python = self.where_is('python')
- if not python:
- self.skip_test('Can not find installed "python", skipping test.\n')
-
- self.run(program = python, stdin = """\
-import os, sys
-try:
- if sys.platform == 'win32':
- py_ver = 'python%d%d' % sys.version_info[:2]
- else:
- py_ver = 'python%d.%d' % sys.version_info[:2]
-except AttributeError:
- py_ver = 'python' + sys.version[:3]
-# print include and lib path
-try:
- import distutils.sysconfig
- exec_prefix = distutils.sysconfig.EXEC_PREFIX
- print(distutils.sysconfig.get_python_inc())
- lib_path = os.path.join(exec_prefix, 'libs')
- if not os.path.exists(lib_path):
- lib_path = os.path.join(exec_prefix, 'lib')
- print(lib_path)
-except:
- print(os.path.join(sys.prefix, 'include', py_ver))
- print(os.path.join(sys.prefix, 'lib', py_ver, 'config'))
-print(py_ver)
-""")
-
- return [python] + self.stdout().strip().split('\n')
-
- def start(self, *args, **kw):
- """
- Starts SCons in the test environment.
-
- This method exists to tell Test{Cmd,Common} that we're going to
- use standard input without forcing every .start() call in the
- individual tests to do so explicitly.
- """
- if 'stdin' not in kw:
- kw['stdin'] = True
- sconsflags = initialize_sconsflags(self.ignore_python_version)
- try:
- p = TestCommon.start(self, *args, **kw)
- finally:
- restore_sconsflags(sconsflags)
- return p
-
- def wait_for(self, fname, timeout=20.0, popen=None):
- """
- Waits for the specified file name to exist.
- """
- waited = 0.0
- while not os.path.exists(fname):
- if timeout and waited >= timeout:
- sys.stderr.write('timed out waiting for %s to exist\n' % fname)
- if popen:
- popen.stdin.close()
- popen.stdin = None
- self.status = 1
- self.finish(popen)
- stdout = self.stdout()
- if stdout:
- sys.stdout.write(self.banner('STDOUT ') + '\n')
- sys.stdout.write(stdout)
- stderr = self.stderr()
- if stderr:
- sys.stderr.write(self.banner('STDERR ') + '\n')
- sys.stderr.write(stderr)
- self.fail_test()
- time.sleep(1.0)
- waited = waited + 1.0
-
- def get_alt_cpp_suffix(self):
- """
- Many CXX tests have this same logic.
- They all needed to determine if the current os supports
- files with .C and .c as different files or not
- in which case they are instructed to use .cpp instead of .C
- """
- if not case_sensitive_suffixes('.c','.C'):
- alt_cpp_suffix = '.cpp'
- else:
- alt_cpp_suffix = '.C'
- return alt_cpp_suffix
-
- def platform_has_symlink(self):
- if not hasattr(os, 'symlink') or sys.platform == 'win32':
- return False
- else:
- return True
-
-
-class Stat:
- def __init__(self, name, units, expression, convert=None):
- if convert is None:
- convert = lambda x: x
- self.name = name
- self.units = units
- self.expression = re.compile(expression)
- self.convert = convert
-
-StatList = [
- Stat('memory-initial', 'kbytes',
- r'Memory before reading SConscript files:\s+(\d+)',
- convert=lambda s: int(s) // 1024),
- Stat('memory-prebuild', 'kbytes',
- r'Memory before building targets:\s+(\d+)',
- convert=lambda s: int(s) // 1024),
- Stat('memory-final', 'kbytes',
- r'Memory after building targets:\s+(\d+)',
- convert=lambda s: int(s) // 1024),
-
- Stat('time-sconscript', 'seconds',
- r'Total SConscript file execution time:\s+([\d.]+) seconds'),
- Stat('time-scons', 'seconds',
- r'Total SCons execution time:\s+([\d.]+) seconds'),
- Stat('time-commands', 'seconds',
- r'Total command execution time:\s+([\d.]+) seconds'),
- Stat('time-total', 'seconds',
- r'Total build time:\s+([\d.]+) seconds'),
-]
-
-
-class TimeSCons(TestSCons):
- """Class for timing SCons."""
- def __init__(self, *args, **kw):
- """
- In addition to normal TestSCons.TestSCons intialization,
- this enables verbose mode (which causes the command lines to
- be displayed in the output) and copies the contents of the
- directory containing the executing script to the temporary
- working directory.
- """
- self.variables = kw.get('variables')
- default_calibrate_variables = []
- if self.variables is not None:
- for variable, value in self.variables.items():
- value = os.environ.get(variable, value)
- try:
- value = int(value)
- except ValueError:
- try:
- value = float(value)
- except ValueError:
- pass
- else:
- default_calibrate_variables.append(variable)
- else:
- default_calibrate_variables.append(variable)
- self.variables[variable] = value
- del kw['variables']
- calibrate_keyword_arg = kw.get('calibrate')
- if calibrate_keyword_arg is None:
- self.calibrate_variables = default_calibrate_variables
- else:
- self.calibrate_variables = calibrate_keyword_arg
- del kw['calibrate']
-
- self.calibrate = os.environ.get('TIMESCONS_CALIBRATE', '0') != '0'
-
- if 'verbose' not in kw and not self.calibrate:
- kw['verbose'] = True
-
- TestSCons.__init__(self, *args, **kw)
-
- # TODO(sgk): better way to get the script dir than sys.argv[0]
- self.test_dir = os.path.dirname(sys.argv[0])
- test_name = os.path.basename(self.test_dir)
-
- if not os.path.isabs(self.test_dir):
- self.test_dir = os.path.join(self.orig_cwd, self.test_dir)
- self.copy_timing_configuration(self.test_dir, self.workpath())
-
- def main(self, *args, **kw):
- """
- The main entry point for standard execution of timings.
-
- This method run SCons three times:
-
- Once with the --help option, to have it exit after just reading
- the configuration.
-
- Once as a full build of all targets.
-
- Once again as a (presumably) null or up-to-date build of
- all targets.
-
- The elapsed time to execute each build is printed after
- it has finished.
- """
- if 'options' not in kw and self.variables:
- options = []
- for variable, value in self.variables.items():
- options.append('%s=%s' % (variable, value))
- kw['options'] = ' '.join(options)
- if self.calibrate:
- self.calibration(*args, **kw)
- else:
- self.uptime()
- self.startup(*args, **kw)
- self.full(*args, **kw)
- self.null(*args, **kw)
-
- def trace(self, graph, name, value, units, sort=None):
- fmt = "TRACE: graph=%s name=%s value=%s units=%s"
- line = fmt % (graph, name, value, units)
- if sort is not None:
- line = line + (' sort=%s' % sort)
- line = line + '\n'
- sys.stdout.write(line)
- sys.stdout.flush()
-
- def report_traces(self, trace, stats):
- self.trace('TimeSCons-elapsed',
- trace,
- self.elapsed_time(),
- "seconds",
- sort=0)
- for name, args in stats.items():
- self.trace(name, trace, **args)
-
- def uptime(self):
- try:
- fp = open('/proc/loadavg')
- except EnvironmentError:
- pass
- else:
- avg1, avg5, avg15 = fp.readline().split(" ")[:3]
- fp.close()
- self.trace('load-average', 'average1', avg1, 'processes')
- self.trace('load-average', 'average5', avg5, 'processes')
- self.trace('load-average', 'average15', avg15, 'processes')
-
- def collect_stats(self, input):
- result = {}
- for stat in StatList:
- m = stat.expression.search(input)
- if m:
- value = stat.convert(m.group(1))
- # The dict keys match the keyword= arguments
- # of the trace() method above so they can be
- # applied directly to that call.
- result[stat.name] = {'value':value, 'units':stat.units}
- return result
-
- def add_timing_options(self, kw, additional=None):
- """
- Add the necessary timings options to the kw['options'] value.
- """
- options = kw.get('options', '')
- if additional is not None:
- options += additional
- kw['options'] = options + ' --debug=memory,time'
-
- def startup(self, *args, **kw):
- """
- Runs scons with the --help option.
-
- This serves as a way to isolate just the amount of startup time
- spent reading up the configuration, since --help exits before any
- "real work" is done.
- """
- self.add_timing_options(kw, ' --help')
- # Ignore the exit status. If the --help run dies, we just
- # won't report any statistics for it, but we can still execute
- # the full and null builds.
- kw['status'] = None
- self.run(*args, **kw)
- sys.stdout.write(self.stdout())
- stats = self.collect_stats(self.stdout())
- # Delete the time-commands, since no commands are ever
- # executed on the help run and it is (or should be) always 0.0.
- del stats['time-commands']
- self.report_traces('startup', stats)
-
- def full(self, *args, **kw):
- """
- Runs a full build of SCons.
- """
- self.add_timing_options(kw)
- self.run(*args, **kw)
- sys.stdout.write(self.stdout())
- stats = self.collect_stats(self.stdout())
- self.report_traces('full', stats)
- self.trace('full-memory', 'initial', **stats['memory-initial'])
- self.trace('full-memory', 'prebuild', **stats['memory-prebuild'])
- self.trace('full-memory', 'final', **stats['memory-final'])
-
- def calibration(self, *args, **kw):
- """
- Runs a full build of SCons, but only reports calibration
- information (the variable(s) that were set for this configuration,
- and the elapsed time to run.
- """
- self.add_timing_options(kw)
- self.run(*args, **kw)
- for variable in self.calibrate_variables:
- value = self.variables[variable]
- sys.stdout.write('VARIABLE: %s=%s\n' % (variable, value))
- sys.stdout.write('ELAPSED: %s\n' % self.elapsed_time())
-
- def null(self, *args, **kw):
- """
- Runs an up-to-date null build of SCons.
- """
- # TODO(sgk): allow the caller to specify the target (argument)
- # that must be up-to-date.
- self.add_timing_options(kw)
- self.up_to_date(arguments='.', **kw)
- sys.stdout.write(self.stdout())
- stats = self.collect_stats(self.stdout())
- # time-commands should always be 0.0 on a null build, because
- # no commands should be executed. Remove it from the stats
- # so we don't trace it, but only if it *is* 0 so that we'll
- # get some indication if a supposedly-null build actually does
- # build something.
- if float(stats['time-commands']['value']) == 0.0:
- del stats['time-commands']
- self.report_traces('null', stats)
- self.trace('null-memory', 'initial', **stats['memory-initial'])
- self.trace('null-memory', 'prebuild', **stats['memory-prebuild'])
- self.trace('null-memory', 'final', **stats['memory-final'])
-
- def elapsed_time(self):
- """
- Returns the elapsed time of the most recent command execution.
- """
- return self.endTime - self.startTime
-
- def run(self, *args, **kw):
- """
- Runs a single build command, capturing output in the specified file.
-
- Because this class is about timing SCons, we record the start
- and end times of the elapsed execution, and also add the
- --debug=memory and --debug=time options to have SCons report
- its own memory and timing statistics.
- """
- self.startTime = time.time()
- try:
- result = TestSCons.run(self, *args, **kw)
- finally:
- self.endTime = time.time()
- return result
-
- def copy_timing_configuration(self, source_dir, dest_dir):
- """
- Copies the timing configuration from the specified source_dir (the
- directory in which the controlling script lives) to the specified
- dest_dir (a temporary working directory).
-
- This ignores all files and directories that begin with the string
- 'TimeSCons-', and all '.svn' subdirectories.
- """
- for root, dirs, files in os.walk(source_dir):
- if '.svn' in dirs:
- dirs.remove('.svn')
- dirs = [ d for d in dirs if not d.startswith('TimeSCons-') ]
- files = [ f for f in files if not f.startswith('TimeSCons-') ]
- for dirname in dirs:
- source = os.path.join(root, dirname)
- destination = source.replace(source_dir, dest_dir)
- os.mkdir(destination)
- if sys.platform != 'win32':
- shutil.copystat(source, destination)
- for filename in files:
- source = os.path.join(root, filename)
- destination = source.replace(source_dir, dest_dir)
- shutil.copy2(source, destination)
-
-
-# In some environments, $AR will generate a warning message to stderr
-# if the library doesn't previously exist and is being created. One
-# way to fix this is to tell AR to be quiet (sometimes the 'c' flag),
-# but this is difficult to do in a platform-/implementation-specific
-# method. Instead, we will use the following as a stderr match for
-# tests that use AR so that we will view zero or more "ar: creating
-# <file>" messages to be successful executions of the test (see
-# test/AR.py for sample usage).
-
-noisy_ar=r'(ar: creating( archive)? \S+\n?)*'
-
-# Local Variables:
-# tab-width:4
-# indent-tabs-mode:nil
-# End:
-# vim: set expandtab tabstop=4 shiftwidth=4: