Index: src/tests/pybin/settings.py
===================================================================
--- src/tests/pybin/settings.py	(revision bacc36ce667997c9f0ed8001bf0911d0fe811ee1)
+++ src/tests/pybin/settings.py	(revision bacc36ce667997c9f0ed8001bf0911d0fe811ee1)
@@ -0,0 +1,28 @@
+
+class Architecture:
+	def __init__(self, cmd):
+		if cmd:
+			self.cross_compile = True
+			self.target = cmd
+		else:
+			self.cross_compile = False
+			self.target = 'x64'
+
+	def toString(self):
+		return self.target
+
+def init( options ):
+	global arch
+	global dry_run
+	global generating
+	global make
+
+	arch       = Architecture(options.arch)
+	dry_run    = options.dry_run
+	generating = options.regenerate_expected
+	make       = './make_command_not_initialized'
+
+def updateMakeCmd(force, jobs):
+	global make
+
+	make = "make" if force else ("make -j%i" % jobs)
Index: src/tests/pybin/test_run.py
===================================================================
--- src/tests/pybin/test_run.py	(revision 0ad0c55af834cd60b4644acba851192ddc6839bd)
+++ src/tests/pybin/test_run.py	(revision bacc36ce667997c9f0ed8001bf0911d0fe811ee1)
@@ -3,4 +3,5 @@
 from pybin.tools import *
 
+import pybin.settings
 
 # Test class that defines what a test is
@@ -14,21 +15,53 @@
 		return "{:25s} ({:5s} {:s})".format( self.name, self.arch if self.arch else "Any", self.target() )
 
-	def prepare(self, dry_run):
-		sh("mkdir -p %s" % os.path.join(self.path, '.err'), dry_run)
-		sh("mkdir -p %s" % os.path.join(self.path, '.out'), dry_run)
-		sh("mkdir -p %s" % os.path.join(self.path, '.in' ), dry_run)
+	def prepare(self):
+		sh("mkdir -p %s" % os.path.join(self.path, '.err'))
+		sh("mkdir -p %s" % os.path.join(self.path, '.out'))
+		sh("mkdir -p %s" % os.path.join(self.path, '.in' ))
 
-	def expect_file(self):
+	def expect(self):
 		return ("%s/.expect/%s.txt" % (self.path, self.name))
 
-	def error_file(self):
+	def error_log(self):
 		return ("%s/.err/%s.log"    % (self.path, self.name))
 
-	def output_file(self):
+	def output_log(self):
 		return ("%s/.out/%s.log"    % (self.path, self.name))
 
-	def input_file(self):
+	def input(self):
 		return ("%s/.in/%s.txt"     % (self.path, self.name))
+
+	def target_output(self):
+		return self.output_log() if not settings.generating else self.expect()
 
 	def target(self):
 		return os.path.join(self.path, self.name)
+
+	@classmethod
+	def valid_name(cls, name):
+		return not name.endswith( ('.c', '.cc', '.cpp', '.cfa') )
+
+	@classmethod
+	def from_target(cls, target):
+		test = Test()
+		test.name = os.path.basename(target)
+		test.path = os.path.dirname (target)
+		test.arch = settings.arch.toString() if settings.arch.cross_compile else ''
+		return test
+
+
+class TestResult:
+	SUCCESS = 0
+	FAILURE = 1
+	TIMEOUT = 124
+
+	@classmethod
+	def toString( cls, retcode ):
+		if settings.generating :
+			if   retcode == TestResult.SUCCESS: 	return "Done"
+			elif retcode == TestResult.TIMEOUT: 	return "TIMEOUT"
+			else :						return "ERROR code %d" % retcode
+		else :
+			if   retcode == TestResult.SUCCESS: 	return "PASSED"
+			elif retcode == TestResult.TIMEOUT: 	return "TIMEOUT"
+			else :						return "FAILED with code %d" % retcode
Index: src/tests/pybin/tools.py
===================================================================
--- src/tests/pybin/tools.py	(revision 0ad0c55af834cd60b4644acba851192ddc6839bd)
+++ src/tests/pybin/tools.py	(revision bacc36ce667997c9f0ed8001bf0911d0fe811ee1)
@@ -1,16 +1,33 @@
+from __future__ import print_function
+
 import __main__
 import argparse
+import multiprocessing
 import os
 import re
+import signal
 import stat
-
+import sys
+
+from pybin import settings
 from subprocess import Popen, PIPE, STDOUT
 
+################################################################################
+#               shell helpers
+################################################################################
+
 # helper functions to run terminal commands
-def sh(cmd, dry_run = False, print2stdout = True):
-	if dry_run : 	# if this is a dry_run, only print the commands that would be ran
+def sh(cmd, print2stdout = True, input = None):
+	# add input redirection if needed
+	if input and os.path.isfile(input):
+		cmd += " < %s" % input
+
+	# if this is a dry_run, only print the commands that would be ran
+	if settings.dry_run :
 		print("cmd: %s" % cmd)
 		return 0, None
-	else :			# otherwise create a pipe and run the desired command
+
+	# otherwise create a pipe and run the desired command
+	else :
 		proc = Popen(cmd, stdout=None if print2stdout else PIPE, stderr=STDOUT, shell=True)
 		out, err = proc.communicate()
@@ -18,10 +35,10 @@
 
 # Remove 1 or more files silently
-def rm( files, dry_run = False ):
+def rm( files ):
 	try:
 		for file in files:
-			sh("rm -f %s > /dev/null 2>&1" % file, dry_run)
+			sh("rm -f %s > /dev/null 2>&1" % file )
 	except TypeError:
-		sh("rm -f %s > /dev/null 2>&1" % files, dry_run)
+		sh("rm -f %s > /dev/null 2>&1" % files )
 
 def chdir( dest = __main__.__file__ ):
@@ -30,50 +47,6 @@
 	os.chdir(dname)
 
-# helper function to replace patterns in a file
-def file_replace(fname, pat, s_after):
-    # first, see if the pattern is even in the file.
-    with open(fname) as f:
-        if not any(re.search(pat, line) for line in f):
-            return # pattern does not occur in file so we are done.
-
-    # pattern is in the file, so perform replace operation.
-    with open(fname) as f:
-        out_fname = fname + ".tmp"
-        out = open(out_fname, "w")
-        for line in f:
-            out.write(re.sub(pat, s_after, line))
-        out.close()
-        os.rename(out_fname, fname)
-
-# helper function to check if a files contains only a specific string
-def fileContainsOnly(file, text) :
-	with open(file) as f:
-		ff = f.read().strip()
-		result = ff == text.strip()
-
-		return result;
-
-# check whether or not a file is executable
-def fileIsExecutable(file) :
-	try :
-		fileinfo = os.stat(file)
-		return bool(fileinfo.st_mode & stat.S_IXUSR)
-	except Exception as inst:
-		print(type(inst))    # the exception instance
-		print(inst.args)     # arguments stored in .args
-		print(inst)
-		return False
-
-# check if arguments is yes or no
-def yes_no(string):
-	if string == "yes" :
-		return True
-	if string == "no" :
-		return False
-	raise argparse.ArgumentTypeError(msg)
-	return False
-
 # diff two files
-def diff( lhs, rhs, dry_run ):
+def diff( lhs, rhs ):
 	# diff the output of the files
 	diff_cmd = ("diff --ignore-all-space "
@@ -94,5 +67,80 @@
 
 	# fetch return code and error from the diff command
-	return sh(diff_cmd % (lhs, rhs), dry_run, False)
+	return sh(diff_cmd % (lhs, rhs), False)
+
+# call make
+def make(target, flags = '', redirects = '', error_file = None, silent = False):
+	test_param = """test="%s" """ % (error_file) if error_file else ''
+	cmd = ' '.join([
+		settings.make,
+		'-s' if silent else '',
+		test_param,
+		flags,
+		target,
+		redirects
+	])
+	return sh(cmd)
+
+################################################################################
+#               file handling
+################################################################################
+
+# helper function to replace patterns in a file
+def file_replace(fname, pat, s_after):
+    # first, see if the pattern is even in the file.
+    with open(fname) as f:
+        if not any(re.search(pat, line) for line in f):
+            return # pattern does not occur in file so we are done.
+
+    # pattern is in the file, so perform replace operation.
+    with open(fname) as f:
+        out_fname = fname + ".tmp"
+        out = open(out_fname, "w")
+        for line in f:
+            out.write(re.sub(pat, s_after, line))
+        out.close()
+        os.rename(out_fname, fname)
+
+# helper function to check if a files contains only a specific string
+def fileContainsOnly(file, text) :
+	with open(file) as f:
+		ff = f.read().strip()
+		result = ff == text.strip()
+
+		return result;
+
+# check whether or not a file is executable
+def fileIsExecutable(file) :
+	try :
+		fileinfo = os.stat(file)
+		return bool(fileinfo.st_mode & stat.S_IXUSR)
+	except Exception as inst:
+		print(type(inst))    # the exception instance
+		print(inst.args)     # arguments stored in .args
+		print(inst)
+		return False
+
+# transform path to canonical form
+def canonicalPath(path):
+	return os.path.join('.', os.path.normpath(path) )
+
+# compare path even if form is different
+def pathCmp(lhs, rhs):
+	return canonicalPath( lhs ) == canonicalPath( rhs )
+
+# walk all files in a path
+def pathWalk( op ):
+	def step(_, dirname, names):
+		for name in names:
+			path = os.path.join(dirname, name)
+
+			op( path )
+
+	# Start the walk
+	os.path.walk('.', step, '')
+
+################################################################################
+#               system
+################################################################################
 
 # parses the Makefile to find the machine type (32-bit / 64-bit)
@@ -100,5 +148,5 @@
 	return 'x64'
 	sh('echo "void ?{}(int&a,int b){}int main(){return 0;}" > .dummy.c')
-	ret, out = sh("make .dummy -s", print2stdout=True)
+	ret, out = make('.dummy', silent = True)
 
 	if ret != 0:
@@ -114,2 +162,52 @@
 	return out
 	return re.search("ELF\s([0-9]+)-bit", out).group(1)
+
+# count number of jobs to create
+def jobCount( options, tests ):
+	# check if the user already passed in a number of jobs for multi-threading
+	make_flags = os.environ.get('MAKEFLAGS')
+	make_jobs_fds = re.search("--jobserver-(auth|fds)=\s*([0-9]+),([0-9]+)", make_flags) if make_flags else None
+	if make_jobs_fds :
+		tokens = os.read(int(make_jobs_fds.group(2)), 1024)
+		options.jobs = len(tokens)
+		os.write(int(make_jobs_fds.group(3)), tokens)
+	else :
+		options.jobs = multiprocessing.cpu_count()
+
+	# make sure we have a valid number of jobs that corresponds to user input
+	if options.jobs <= 0 :
+		print('ERROR: Invalid number of jobs', file=sys.stderr)
+		sys.exit(1)
+
+	return min( options.jobs, len(tests) ), True if make_flags else False
+
+# setup a proper processor pool with correct signal handling
+def setupPool(jobs):
+	original_sigint_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
+	pool = multiprocessing.Pool(jobs)
+	signal.signal(signal.SIGINT, original_sigint_handler)
+
+	return pool
+
+# handle signals in scope
+class SignalHandling():
+	def __enter__(self):
+		# enable signal handling
+	    	signal.signal(signal.SIGINT, signal.SIG_DFL)
+
+	def __exit__(self, type, value, traceback):
+		# disable signal handling
+		signal.signal(signal.SIGINT, signal.SIG_IGN)
+
+################################################################################
+#               misc
+################################################################################
+
+# check if arguments is yes or no
+def yes_no(string):
+	if string == "yes" :
+		return True
+	if string == "no" :
+		return False
+	raise argparse.ArgumentTypeError(msg)
+	return False
Index: src/tests/test.py
===================================================================
--- src/tests/test.py	(revision 0ad0c55af834cd60b4644acba851192ddc6839bd)
+++ src/tests/test.py	(revision bacc36ce667997c9f0ed8001bf0911d0fe811ee1)
@@ -2,16 +2,11 @@
 from __future__ import print_function
 
-from functools import partial
-from multiprocessing import Pool
-from os import listdir, environ
-from os.path import isfile, join, splitext
 from pybin.tools import *
 from pybin.test_run import *
+from pybin import settings
 
 import argparse
-import multiprocessing
-import os
+import functools
 import re
-import signal
 import sys
 
@@ -23,18 +18,14 @@
 	expected = []
 
-	def step(_, dirname, names):
-		for name in names:
-			path = os.path.join(dirname, name)
-
-			match = re.search("(\.[\w\/\-_]*)\/.expect\/([\w\-_]+)(\.[\w\-_]+)?\.txt", path)
-			if match :
-				test = Test()
-				test.name = match.group(2)
-				test.path = match.group(1)
-				test.arch = match.group(3)[1:] if match.group(3) else None
-				expected.append(test)
-
-	# Start the walk
-	os.path.walk('.', step, '')
+	def findTest(path):
+		match = re.search("(\.[\w\/\-_]*)\/.expect\/([\w\-_]+)(\.[\w\-_]+)?\.txt", path)
+		if match :
+			test = Test()
+			test.name = match.group(2)
+			test.path = match.group(1)
+			test.arch = match.group(3)[1:] if match.group(3) else None
+			expected.append(test)
+
+	pathWalk( findTest )
 
 	return expected
@@ -42,6 +33,6 @@
 # reads the directory ./.expect and indentifies the tests
 def listTests( includes, excludes ):
-	includes = [os.path.normpath( os.path.join('.',i) ) for i in includes] if includes else None
-	excludes = [os.path.normpath( os.path.join('.',i) ) for i in excludes] if excludes else None
+	includes = [canonicalPath( i ) for i in includes] if includes else None
+	excludes = [canonicalPath( i ) for i in excludes] if excludes else None
 
 	# tests directly in the .expect folder will always be processed
@@ -51,5 +42,5 @@
 	if includes:
 		test_list = [x for x in test_list if
-			os.path.normpath( x.path ).startswith( tuple(includes) )
+			x.path.startswith( tuple(includes) )
 		]
 
@@ -57,5 +48,5 @@
 	if excludes:
 		test_list = [x for x in test_list if not
-			os.path.normpath( x.path ).startswith( tuple(excludes) )
+			x.path.startswith( tuple(excludes) )
 		]
 
@@ -70,16 +61,16 @@
 	if options.regenerate_expected :
 		for testname in options.tests :
-			if testname.endswith( (".c", ".cc", ".cpp") ):
+			if Test.valid_name(testname):
+				found = [test for test in allTests if test.target() == testname]
+				tests.append( found[0] if len(found) == 1 else Test.from_target(testname) )
+			else :
 				print('ERROR: "%s", tests are not allowed to end with a C/C++/CFA extension, ignoring it' % testname, file=sys.stderr)
-			else :
-				found = [test for test in allTests if test.name == testname]
-				tests.append( found[0] if len(found) == 1 else Test(testname, testname) )
 
 	else :
 		# otherwise we only need to validate that all tests are present in the complete list
 		for testname in options.tests:
-			test = [t for t in allTests if os.path.normpath( t.target() ) == os.path.normpath( testname )]
-
-			if len(test) != 0 :
+			test = [t for t in allTests if pathCmp( t.target(), testname )]
+
+			if test :
 				tests.append( test[0] )
 			else :
@@ -87,14 +78,9 @@
 
 	# make sure we have at least some test to run
-	if len(tests) == 0 :
+	if tests :
 		print('ERROR: No valid test to run', file=sys.stderr)
 		sys.exit(1)
 
 	return tests
-
-class TestResult:
-	SUCCESS = 0
-	FAILURE = 1
-	TIMEOUT = 124
 
 # parses the option
@@ -103,5 +89,5 @@
 	parser = argparse.ArgumentParser(description='Script which runs cforall tests')
 	parser.add_argument('--debug', help='Run all tests in debug or release', type=yes_no, default='no')
-	parser.add_argument('--arch', help='Test for specific architecture', type=str, default=getMachineType())
+	parser.add_argument('--arch', help='Test for specific architecture', type=str, default='')
 	parser.add_argument('--dry-run', help='Don\'t run the tests, only output the commands', action='store_true')
 	parser.add_argument('--list', help='List all test available', action='store_true')
@@ -130,45 +116,30 @@
 	return options
 
-def jobCount( options ):
-	# check if the user already passed in a number of jobs for multi-threading
-	make_flags = environ.get('MAKEFLAGS')
-	make_jobs_fds = re.search("--jobserver-(auth|fds)=\s*([0-9]+),([0-9]+)", make_flags) if make_flags else None
-	if make_jobs_fds :
-		tokens = os.read(int(make_jobs_fds.group(2)), 1024)
-		options.jobs = len(tokens)
-		os.write(int(make_jobs_fds.group(3)), tokens)
-	else :
-		options.jobs = multiprocessing.cpu_count()
-
-	# make sure we have a valid number of jobs that corresponds to user input
-	if options.jobs <= 0 :
-		print('ERROR: Invalid number of jobs', file=sys.stderr)
-		sys.exit(1)
-
-	return min( options.jobs, len(tests) ), True if make_flags else False
-
 ################################################################################
 #               running test functions
 ################################################################################
 # logic to run a single test and return the result (No handling of printing or other test framework logic)
-def run_single_test(test, generate, dry_run, debug):
+def run_single_test(test, debug):
 
 	# find the output file based on the test name and options flag
-	out_file = test.output_file() if not generate else test.expect_file()
-	err_file = test.error_file()
-	cmp_file = test.expect_file()
-	in_file  = test.input_file()
+	out_file = test.target_output()
+	err_file = test.error_log()
+	cmp_file = test.expect()
+	in_file  = test.input()
 
 	# prepare the proper directories
-	test.prepare( dry_run )
+	test.prepare()
 
 	# remove any outputs from the previous tests to prevent side effects
-	rm( (out_file, err_file, test.target()), dry_run )
+	rm( (out_file, err_file, test.target()) )
 
 	options = "-debug" if debug else "-nodebug"
 
-
 	# build, skipping to next test on error
-	make_ret, _ = sh("""%s  DEBUG_FLAGS="%s" %s test="%s" 2> %s 1> /dev/null""" % (make_cmd, options, test.target(), err_file, out_file), dry_run)
+	make_ret, _ = make( test.target(),
+		flags      = """DEBUG_FLAGS="%s" """ % options,
+		redirects  = "2> %s 1> /dev/null" % out_file,
+		error_file = err_file
+	)
 
 	retcode = 0
@@ -176,22 +147,19 @@
 
 	# if the make command succeds continue otherwise skip to diff
-	if make_ret == 0 or dry_run:
-		# fetch optional input
-		stdinput = "< %s" % in_file if isfile(in_file) else ""
-
-		if dry_run or fileIsExecutable(test.target()) :
+	if make_ret == 0 or settings.dry_run:
+		if settings.dry_run or fileIsExecutable(test.target()) :
 			# run test
-			retcode, _ = sh("timeout 60 ./%s %s > %s 2>&1" % (test.target(), stdinput, out_file), dry_run)
+			retcode, _ = sh("timeout 60 %s > %s 2>&1" % (test.target(), out_file), input = in_file)
 		else :
 			# simply cat the result into the output
-			sh("cat %s > %s" % (test.target(), out_file), dry_run)
+			sh("cat %s > %s" % (test.target(), out_file))
 	else:
-		sh("mv %s %s" % (err_file, out_file), dry_run)
+		sh("mv %s %s" % (err_file, out_file))
 
 
 	if retcode == 0:
-		if generate :
+		if settings.generating :
 			# if we are ounly generating the output we still need to check that the test actually exists
-			if not dry_run and fileContainsOnly(out_file, "make: *** No rule to make target `%s'.  Stop." % test.target()) :
+			if not settings.dry_run and fileContainsOnly(out_file, "make: *** No rule to make target `%s'.  Stop." % test.target()) :
 				retcode = 1;
 				error = "\t\tNo make target for test %s!" % test.target()
@@ -199,5 +167,5 @@
 		else :
 			# fetch return code and error from the diff command
-			retcode, error = diff(cmp_file, out_file, dry_run)
+			retcode, error = diff(cmp_file, out_file)
 
 	else:
@@ -207,57 +175,48 @@
 
 	# clean the executable
-	sh("rm -f %s > /dev/null 2>&1" % test.target(), dry_run)
+	sh("rm -f %s > /dev/null 2>&1" % test.target())
 
 	return retcode, error
 
 # run a single test and handle the errors, outputs, printing, exception handling, etc.
-def run_test_worker(t, generate, dry_run, debug) :
-
-	signal.signal(signal.SIGINT, signal.SIG_DFL)
-	# print formated name
-	name_txt = "%20s  " % t.name
-
-	retcode, error = run_single_test(t, generate, dry_run, debug)
-
-	# update output based on current action
-	if generate :
-		if   retcode == TestResult.SUCCESS: 	result_txt = "Done"
-		elif retcode == TestResult.TIMEOUT: 	result_txt = "TIMEOUT"
-		else :						result_txt = "ERROR code %d" % retcode
-	else :
-		if   retcode == TestResult.SUCCESS: 	result_txt = "PASSED"
-		elif retcode == TestResult.TIMEOUT: 	result_txt = "TIMEOUT"
-		else :						result_txt = "FAILED with code %d" % retcode
-
-	#print result with error if needed
-	text = name_txt + result_txt
-	out = sys.stdout
-	if error :
-		text = text + "\n" + error
-		out = sys.stderr
-
-	print(text, file = out)
-	sys.stdout.flush()
-	sys.stderr.flush()
-	signal.signal(signal.SIGINT, signal.SIG_IGN)
+def run_test_worker(t, debug) :
+
+	with SignalHandling():
+		# print formated name
+		name_txt = "%20s  " % t.name
+
+		retcode, error = run_single_test(t, debug)
+
+		# update output based on current action
+		result_txt = TestResult.toString( retcode )
+
+		#print result with error if needed
+		text = name_txt + result_txt
+		out = sys.stdout
+		if error :
+			text = text + "\n" + error
+			out = sys.stderr
+
+		print(text, file = out)
+		sys.stdout.flush()
+		sys.stderr.flush()
 
 	return retcode != TestResult.SUCCESS
 
 # run the given list of tests with the given parameters
-def run_tests(tests, generate, dry_run, jobs, debug) :
+def run_tests(tests, jobs, debug) :
 	# clean the sandbox from previous commands
-	sh("%s clean > /dev/null 2>&1" % make_cmd, dry_run)
-
-	if generate :
-		print( "Regenerate tests for: " )
+	make('clean', redirects = '> /dev/null 2>&1')
 
 	# create the executor for our jobs and handle the signal properly
-	original_sigint_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
-	pool = Pool(jobs)
-	signal.signal(signal.SIGINT, original_sigint_handler)
+	pool = setupPool(jobs)
 
 	# for each test to run
 	try :
-		results = pool.map_async(partial(run_test_worker, generate=generate, dry_run=dry_run, debug=debug), tests, chunksize = 1 ).get(7200)
+		results = pool.map_async(
+			functools.partial(run_test_worker, debug=debug),
+			tests,
+			chunksize = 1
+		).get(7200)
 	except KeyboardInterrupt:
 		pool.terminate()
@@ -266,5 +225,5 @@
 
 	# clean the workspace
-	sh("%s clean > /dev/null 2>&1" % make_cmd, dry_run)
+	make('clean', redirects = '> /dev/null 2>&1')
 
 	for failed in results:
@@ -285,4 +244,7 @@
 	options = getOptions()
 
+	# init global settings
+	settings.init( options )
+
 	# fetch the liest of all valid tests
 	allTests = listTests( options.include, options.exclude )
@@ -297,5 +259,5 @@
 
 	# sort the test alphabetically for convenience
-	tests.sort(key=lambda t: os.path.join(t.path, t.name))
+	tests.sort(key=lambda t: t.target())
 
 	# users may want to simply list the tests
@@ -305,13 +267,18 @@
 
 	elif options.list :
-		print("Listing for %s:%s"% (options.arch, "debug" if options.debug else "no debug"))
+		print("Listing for %s:%s"% (settings.arch.toString(), "debug" if options.debug else "no debug"))
 		print("\n".join(map(lambda t: "%s" % (t.toString()), tests)))
 
 	else :
-		options.jobs, forceJobs = jobCount( options )
-
-		print('Running (%s:%s) on %i cores' % (options.arch, "debug" if options.debug else "no debug", options.jobs))
-		make_cmd = "make" if forceJobs else ("make -j%i" % options.jobs)
+		options.jobs, forceJobs = jobCount( options, tests )
+		settings.updateMakeCmd(forceJobs, options.jobs)
+
+		print('%s (%s:%s) on %i cores' % (
+			'Regenerate tests' if settings.generating else 'Running',
+			settings.arch.toString(),
+			"debug" if options.debug else "no debug",
+			options.jobs
+		))
 
 		# otherwise run all tests and make sure to return the correct error code
-		sys.exit( run_tests(tests, options.regenerate_expected, options.dry_run, options.jobs, options.debug) )
+		sys.exit( run_tests(tests, options.jobs, options.debug) )