# Copyright 2002-2005 Vladimir Prus. # Copyright 2002-2003 Dave Abrahams. # Copyright 2006 Rene Rivera. # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or copy at # http://www.boost.org/LICENSE_1_0.txt) import TestCmd from tree import build_tree, trees_difference import copy import fnmatch import glob import os import re import shutil import string import types import time import tempfile import sys import traceback import math from StringIO import StringIO annotation_func = None annotations = [] def print_annotation(name, value): """Writes some named bit of information about test run. """ print name + " {{{" print value print "}}}" def flush_annotations(): global annotations for ann in annotations: print_annotation(ann[0], ann[1]) annotations = [] defer_annotations = 0 def set_defer_annotations(n): global defer_annotations defer_annotations = n def annotation(name, value): """Records an annotation about test run.""" annotations.append((name, value)) if not defer_annotations: flush_annotations() def get_toolset(): toolset = None; for arg in sys.argv[1:]: if not arg.startswith('-'): toolset = arg return toolset or 'gcc' windows = 0 if os.environ.get('OS','').lower().startswith('windows') or \ os.__dict__.has_key('uname') and \ os.uname()[0].lower().startswith('cygwin'): windows = 1 suffixes = {} # Prepare the map of suffixes def prepare_suffix_map(toolset): global windows, suffixes suffixes = {'.exe': '', '.dll': '.so', '.lib': '.a', '.obj': '.o'} if windows: suffixes = {} if toolset in ["gcc"]: suffixes['.lib'] = '.a' # static libs have '.a' suffix with mingw... suffixes['.obj'] = '.o' if os.__dict__.has_key('uname') and os.uname()[0] == 'Darwin': suffixes['.dll'] = '.dylib' def re_remove(sequence,regex): me = re.compile(regex) result = filter( lambda x: me.match(x), sequence ) if 0 == len(result): raise ValueError() for r in result: sequence.remove(r) def glob_remove(sequence,pattern): result = fnmatch.filter(sequence,pattern) if 0 == len(result): raise ValueError() for r in result: sequence.remove(r) lib_prefix = 1 dll_prefix = 1 if windows: #~ lib_prefix = 0 dll_prefix = 0 # # FIXME: this is copy-pasted from TestSCons.py # Should be moved to TestCmd.py? # if os.name == 'posix': def _failed(self, status = 0): if self.status is None: return None if os.WIFSIGNALED(status): return None return _status(self) != status def _status(self): if os.WIFEXITED(self.status): return os.WEXITSTATUS(self.status) else: return -1 elif os.name == 'nt': def _failed(self, status = 0): return not self.status is None and self.status != status def _status(self): return self.status class Tester(TestCmd.TestCmd): """Class for testing Boost.Build. Optional argument `executable` indicates the name of the executable to invoke. Set this to "jam" to test Boost.Build v1 behavior. Optional argument `work_dir` indicates an absolute directory, where the test will run be run. """ def __init__(self, arguments="", executable = 'bjam', match = TestCmd.match_exact, boost_build_path = None, translate_suffixes = 1, pass_toolset = 1, workdir = '', **keywords): self.original_workdir = os.getcwd() if workdir != '' and not os.path.isabs(workdir): raise "Parameter workdir <"+workdir+"> must point to a absolute directory: " self.last_build_time = 0 self.translate_suffixes = translate_suffixes self.toolset = get_toolset() self.pass_toolset = pass_toolset prepare_suffix_map(pass_toolset and self.toolset or 'gcc') if not '--default-bjam' in sys.argv: jam_build_dir = "" if os.name == 'nt': jam_build_dir = "bin.ntx86" elif os.name == 'posix' and os.__dict__.has_key('uname'): if os.uname()[0].lower().startswith('cygwin'): jam_build_dir = "bin.cygwinx86" if 'TMP' in os.environ and os.environ['TMP'].find('~') != -1: print 'Setting $TMP to /tmp to get around problem with short path names' os.environ['TMP'] = '/tmp' elif os.uname()[0] == 'Linux': cpu = os.uname()[4] if re.match("i.86", cpu): jam_build_dir = "bin.linuxx86"; else: jam_build_dir = "bin.linux" + os.uname()[4] elif os.uname()[0] == 'SunOS': jam_build_dir = "bin.solaris" elif os.uname()[0] == 'Darwin': jam_build_dir = "bin.macosxppc" elif os.uname()[0] == "AIX": jam_build_dir = "bin.aix" elif os.uname()[0] == "IRIX64": jam_build_dir = "bin.irix" elif os.uname()[0] == "FreeBSD": jam_build_dir = "bin.freebsd" elif os.uname()[0] == "OSF1": jam_build_dir = "bin.osf" else: raise "Don't know directory where jam is build for this system: " + os.name + "/" + os.uname()[0] else: raise "Don't know directory where jam is build for this system: " + os.name # Find there jam_src is located. # try for the debug version if it's lying around dirs = [os.path.join('../../../jam/src', jam_build_dir + '.debug'), os.path.join('../../../jam/src', jam_build_dir), os.path.join('../../jam_src', jam_build_dir + '.debug'), os.path.join('../../jam_src', jam_build_dir), os.path.join('../jam_src', jam_build_dir + '.debug'), os.path.join('../jam_src', jam_build_dir), ] for d in dirs: if os.path.exists(d): jam_build_dir = d break else: print "Cannot find built Boost.Jam" os.exit(1) verbosity = ['-d0', '--quiet'] if '--verbose' in sys.argv: keywords['verbose'] = 1 verbosity = ['-d+2'] if boost_build_path is None: boost_build_path = self.original_workdir program_list = [] if '--default-bjam' in sys.argv: program_list.append(executable) inpath_bjam = True else: program_list.append(os.path.join(jam_build_dir, executable)) inpath_bjam = None program_list.append('-sBOOST_BUILD_PATH=' + boost_build_path) if verbosity: program_list += verbosity program_list += ["--ignore-toolset-requirements"] if arguments: program_list += arguments.split(" ") TestCmd.TestCmd.__init__( self , program=program_list , match=match , workdir = workdir , inpath = inpath_bjam , **keywords) os.chdir(self.workdir) def cleanup(self): try: TestCmd.TestCmd.cleanup(self) os.chdir(self.original_workdir) except AttributeError: # Whe this is called during by TestCmd.TestCmd.__del__ we can have both # 'TestCmd' and 'os' unavailable in our scope. Do nothing in this case. pass # # Methods that change working directory's content # def set_tree(self, tree_location): # Seem like it's not possible to remove a directory which is # current. d = os.getcwd() os.chdir(os.path.dirname(self.workdir)) shutil.rmtree(self.workdir, ignore_errors=0) if not os.path.isabs(tree_location): tree_location = os.path.join(self.original_workdir, tree_location) shutil.copytree(tree_location, self.workdir) os.chdir(d) def make_writable(unused, dir, entries): for e in entries: name = os.path.join(dir, e) os.chmod(name, os.stat(name)[0] | 0222) os.path.walk(".", make_writable, None) def write(self, file, content): self.wait_for_time_change() nfile = self.native_file_name(file) try: os.makedirs(os.path.dirname(nfile)) except Exception, e: pass open(nfile, "wb").write(content) def rename(self, old, new): try: os.makedirs(os.path.dirname(new)) except: pass try: os.remove(new) except: pass os.rename(old, new) self.touch(new); def copy(self, src, dst): self.wait_for_time_change() try: self.write(dst, self.read(src)) except: self.fail_test(1) def copy_preserving_timestamp(self, src, dst): src_name = self.native_file_name(src) dst_name = self.native_file_name(dst) stats = os.stat(src_name) self.write(dst, self.read(src)) os.utime(dst_name, (stats.st_atime, stats.st_mtime)) def touch(self, names): self.wait_for_time_change() for name in self.adjust_names(names): os.utime(self.native_file_name(name), None) def rm(self, names): self.wait_for_time_change() if not type(names) == types.ListType: names = [names] # Avoid attempts to remove current dir os.chdir(self.original_workdir) for name in names: n = self.native_file_name(name) n = glob.glob(n) if n: n = n[0] if not n: n = self.glob_file(string.replace(name, "$toolset", self.toolset+"*")) if n: if os.path.isdir(n): shutil.rmtree(n, ignore_errors=0) else: os.unlink(n) # Create working dir root again, in case # we've removed it if not os.path.exists(self.workdir): os.mkdir(self.workdir) os.chdir(self.workdir) def expand_toolset(self, name): """Expands $toolset in the given file to tested toolset""" content = self.read(name) content = string.replace(content, "$toolset", self.toolset) self.write(name, content) def dump_stdio(self): annotation("STDOUT", self.stdout()) annotation("STDERR", self.stderr()) # # FIXME: Large portion copied from TestSCons.py, should be moved? # def run_build_system( self, extra_args='', subdir='', stdout = None, stderr = '', status = 0, match = None, pass_toolset = None, **kw): if os.path.isabs(subdir): if stderr: print "You must pass a relative directory to subdir <"+subdir+">." status = 1 return self.previous_tree = build_tree(self.workdir) if match is None: match = self.match if pass_toolset is None: pass_toolset = self.pass_toolset try: kw['program'] = [] kw['program'] += self.program if extra_args: kw['program'] += extra_args.split(" ") if pass_toolset: kw['program'].append(self.toolset) kw['chdir'] = subdir apply(TestCmd.TestCmd.run, [self], kw) except: self.dump_stdio() raise if status != None and _failed(self, status): expect = '' if status != 0: expect = " (expected %d)" % status annotation("failed command", '"%s" returned %d%s' % ( kw['program'], _status(self), expect)) annotation("reason", "error returned by bjam") self.fail_test(1) if not stdout is None and not match(self.stdout(), stdout): annotation("reason", "Unexpected stdout") annotation("Expected STDOUT", stdout) annotation("Actual STDOUT", self.stdout()) stderr = self.stderr() if stderr: annotation("STDERR", stderr) self.maybe_do_diff(self.stdout(), stdout) self.fail_test(1, dump_stdio = 0) # Intel tends to produce some message to stderr, which makes tests # fail intel_workaround = re.compile("^xi(link|lib): executing.*\n", re.M) actual_stderr = re.sub(intel_workaround, "", self.stderr()) if not stderr is None and not match(actual_stderr, stderr): annotation("reason", "Unexpected stderr") annotation("Expected STDERR", stderr) annotation("Actual STDERR", self.stderr()) annotation("STDOUT", self.stdout()) self.maybe_do_diff(actual_stderr, stderr) self.fail_test(1, dump_stdio = 0) self.tree = build_tree(self.workdir) self.difference = trees_difference(self.previous_tree, self.tree) self.difference.ignore_directories() self.unexpected_difference = copy.deepcopy(self.difference) self.last_build_time = time.time() def glob_file(self, name): result = None if hasattr(self,'difference'): for f in self.difference.added_files+self.difference.modified_files+self.difference.touched_files: if fnmatch.fnmatch(f,name): result = self.native_file_name(f) break if not result: result = glob.glob(self.native_file_name(name)) if result: result = result[0] return result def read(self, name): try: if self.toolset: name = string.replace(name, "$toolset", self.toolset+"*") name = self.glob_file(name) return open(name, "rU").read() except: annotation("reason", "Could not open '%s'" % name) self.fail_test(1) return '' def read_and_strip(self, name): lines = open(self.glob_file(name), "rb").readlines() result = string.join(map(string.rstrip, lines), "\n") if lines and lines[-1][-1] == '\n': return result + '\n' else: return result def fail_test(self, condition, dump_stdio = 1, *args): # If test failed, print the difference if condition and hasattr(self, 'difference'): f = StringIO() self.difference.pprint(f) annotation("changes causes by the last build command", f.getvalue()) if condition and dump_stdio: self.dump_stdio() if condition and '--preserve' in sys.argv: print print "*** Copying the state of working dir into 'failed_test' ***" print path = os.path.join(self.original_workdir, "failed_test") if os.path.isdir(path): shutil.rmtree(path, ignore_errors=0) elif os.path.exists(path): raise "The path " + path + " already exists and is not directory"; shutil.copytree(self.workdir, path) if condition: at = TestCmd.caller(traceback.extract_stack(), 0) annotation("stacktrace", at) sys.exit(1) # A number of methods below check expectations with actual difference # between directory trees before and after build. # All the 'expect*' methods require exact names to be passed. # All the 'ignore*' methods allow wildcards. # All names can be lists, which are taken to be directory components def expect_addition(self, names): for name in self.adjust_names(names): try: glob_remove(self.unexpected_difference.added_files,name) except: print "File %s not added as expected" % (name,) self.fail_test(1) def ignore_addition(self, wildcard): self.ignore_elements(self.unexpected_difference.added_files, wildcard) def expect_removal(self, names): for name in self.adjust_names(names): try: glob_remove(self.unexpected_difference.removed_files,name) except: print "File %s not removed as expected" % (name,) self.fail_test(1) def ignore_removal(self, wildcard): self.ignore_elements(self.unexpected_difference.removed_files, wildcard) def expect_modification(self, names): for name in self.adjust_names(names): try: glob_remove(self.unexpected_difference.modified_files,name) except: print "File %s not modified as expected" % (name,) self.fail_test(1) def ignore_modification(self, wildcard): self.ignore_elements(self.unexpected_difference.modified_files, wildcard) def expect_touch(self, names): d = self.unexpected_difference for name in self.adjust_names(names): # We need to check in both touched and modified files. # The reason is that: # (1) for windows binaries often have slight # differences even with identical inputs # (2) Intel's compiler for Linux has the same behaviour filesets = [d.modified_files, d.touched_files] while filesets: try: glob_remove(filesets[-1],name) break except ValueError: filesets.pop() if not filesets: annotation("reason", "File %s not touched as expected" % (name,)) self.fail_test(1) def ignore_touch(self, wildcard): self.ignore_elements(self.unexpected_difference.touched_files, wildcard) def ignore(self, wildcard): self.ignore_elements(self.unexpected_difference.added_files, wildcard) self.ignore_elements(self.unexpected_difference.removed_files, wildcard) self.ignore_elements(self.unexpected_difference.modified_files, wildcard) self.ignore_elements(self.unexpected_difference.touched_files, wildcard) def expect_nothing(self, names): for name in self.adjust_names(names): if name in self.difference.added_files: annotation("reason", "File %s is added, but no action was expected" % (name,)) self.fail_test(1) if name in self.difference.removed_files: annotation("reason", "File %s is removed, but no action was expected" % (name,)) self.fail_test(1) pass if name in self.difference.modified_files: annotation("reason", "File %s is modified, but no action was expected" % (name,)) self.fail_test(1) if name in self.difference.touched_files: annotation("reason", "File %s is touched, but no action was expected" % (name,)) self.fail_test(1) def expect_nothing_more(self): # not totally sure about this change, but I don't see a good alternative if windows: self.ignore('*.ilk') # msvc incremental linking files self.ignore('*.pdb') # msvc program database files self.ignore('*.rsp') # response files self.ignore('*.tds') # borland debug symbols self.ignore('*.manifest') # msvc DLL manifests # debug builds of bjam built with gcc produce this profiling data self.ignore('gmon.out') self.ignore('*/gmon.out') if not self.unexpected_difference.empty(): print 'FAILED' print '------- The following changes were unexpected ------- ' self.unexpected_difference.pprint() self.fail_test(1) def _expect_line(self, content, expected): expected = expected.strip() lines = content.splitlines() found = 0 for line in lines: line = line.strip() if fnmatch.fnmatch(line, expected): found = 1 break if not found: print "Did not found expected line in output:" print expected print "The output was:" print content self.fail_test(1) def expect_output_line(self, expected): self._expect_line(self.stdout(), expected) def expect_content_line(self, name, expected): content = self._read_file(name) self._expect_line(content, expected) def _read_file(self, name, exact=0): name = self.adjust_names(name)[0] result = "" try: if exact: result = self.read(name) else: result = string.replace(self.read_and_strip(name), "\\", "/") except (IOError, IndexError): print "Note: could not open file", name self.fail_test(1) return result def expect_content(self, name, content, exact=0): actual = self._read_file(name, exact) content = string.replace(content, "$toolset", self.toolset+"*") matched = 0 if exact: matched = fnmatch.fnmatch(actual,content) else: actual_ = map(lambda x: sorted(x.split()),actual.splitlines()) content_ = map(lambda x: sorted(x.split()),content.splitlines()) if len(actual_) == len(content_): matched = map( lambda x,y: map(lambda n,p: fnmatch.fnmatch(n,p),x,y), actual_, content_ ) matched = reduce( lambda x,y: x and reduce( lambda a,b: a and b, y ), matched ) if not matched: print "Expected:\n" print content print "Got:\n" print actual self.fail_test(1) def maybe_do_diff(self, actual, expected): if os.environ.has_key("DO_DIFF") and os.environ["DO_DIFF"] != '': e = tempfile.mktemp("expected") a = tempfile.mktemp("actual") open(e, "w").write(expected) open(a, "w").write(actual) print "DIFFERENCE" if os.system("diff -u " + e + " " + a): print "Unable to compute difference: diff -u %s %s" % (e,a) os.unlink(e) os.unlink(a) else: print "Set environmental variable 'DO_DIFF' to examine difference." # Helpers def mul(self, *arguments): if len(arguments) == 0: return None else: here = arguments[0] if type(here) == type(''): here = [here] if len(arguments) > 1: there = apply(self.mul, arguments[1:]) result = [] for i in here: for j in there: result.append(i + j) return result else: return here # Internal methods def ignore_elements(self, list, wildcard): """Removes in-place, element of 'list' that match the given wildcard.""" list[:] = filter(lambda x, w=wildcard: not fnmatch.fnmatch(x, w), list) def adjust_lib_name(self, name): global lib_prefix result = name pos = string.rfind(name, ".") if pos != -1: suffix = name[pos:] if suffix == ".lib": (head, tail) = os.path.split(name) if lib_prefix: tail = "lib" + tail result = os.path.join(head, tail) elif suffix == ".dll": (head, tail) = os.path.split(name) if dll_prefix: tail = "lib" + tail result = os.path.join(head, tail) return result def adjust_suffix(self, name): if not self.translate_suffixes: return name pos = string.rfind(name, ".") if pos != -1: suffix = name[pos:] name = name[:pos] if suffixes.has_key(suffix): suffix = suffixes[suffix] else: suffix = '' return name + suffix # Acceps either string of list of string and returns list of strings # Adjusts suffixes on all names. def adjust_names(self, names): if type(names) == types.StringType: names = [names] r = map(self.adjust_lib_name, names) r = map(self.adjust_suffix, r) r = map(lambda x, t=self.toolset: string.replace(x, "$toolset", t+"*"), r) return r def native_file_name(self, name): name = self.adjust_names(name)[0] elements = string.split(name, "/") return os.path.normpath(apply(os.path.join, [self.workdir]+elements)) # Wait while time is no longer equal to the time last "run_build_system" # call finished. def wait_for_time_change(self): while 1: f = time.time(); # In fact, I'm not sure why "+ 2" as opposed to "+ 1" is # needed but empirically, "+ 1" sometimes causes 'touch' # and other functions not to bump file time enough for # rebuild to happen. if math.floor(f) < math.floor(self.last_build_time) + 2: time.sleep(0.1) else: break class List: def __init__(self, s=""): elements = [] if isinstance(s, type("")): # Have to handle espaced spaces correctly s = string.replace(s, "\ ", '\001') elements = string.split(s) else: elements = s; self.l = [] for e in elements: self.l.append(string.replace(e, '\001', ' ')) def __len__(self): return len(self.l) def __getitem__(self, key): return self.l[key] def __setitem__(self, key, value): self.l[key] = value def __delitem__(self, key): del self.l[key] def __str__(self): return str(self.l) def __repr__(self): return ( self.__module__ + '.List(' + repr(string.join(self.l, ' ')) + ')') def __mul__(self, other): result = List() if not isinstance(other, List): other = List(other) for f in self: for s in other: result.l.append(f + s) return result def __rmul__(self, other): if not isinstance(other, List): other = List(other) return List.__mul__(other, self) def __add__(self, other): result = List() result.l = self.l[:] + other.l[:] return result # quickie tests. Should use doctest instead. if __name__ == '__main__': assert str(List("foo bar") * "/baz") == "['foo/baz', 'bar/baz']" assert repr("foo/" * List("bar baz")) == "__main__.List('foo/bar foo/baz')" print 'tests passed'