Changes in tests/test.py [f806b61:0c13238]

File:

• tests/test.py (modified) (19 diffs)

tests/test.py

@@ -1 @@
-#!/usr/bin/python3
+#!/usr/bin/python
+from __future__ import print_function
 
 from pybin.tools import *
@@ -8 +9 @@
 import re
 import sys
-import tempfile
 import time
 
@@ -15 +15 @@
 ################################################################################
 
-def find_tests():
+def findTests():
         expected = []
 
-        def match_test(path):
+        def matchTest(path):
                 match = re.search("^%s\/([\w\/\-_]*).expect\/([\w\-_]+)(\.[\w\-_]+)?\.txt$" % settings.SRCDIR, path)
                 if match :
@@ -28 +28 @@
                                 expected.append(test)
 
-        path_walk( match_test )
+        pathWalk( matchTest )
 
         return expected
 
 # reads the directory ./.expect and indentifies the tests
-def list_tests( includes, excludes ):
+def listTests( includes, excludes ):
         # tests directly in the .expect folder will always be processed
-        test_list = find_tests()
+        test_list = findTests()
 
         # if we have a limited number of includes, filter by them
@@ -52 +52 @@
 
 # from the found tests, filter all the valid tests/desired tests
-def valid_tests( options ):
+def validTests( options ):
         tests = []
 
@@ -59 +59 @@
         if options.regenerate_expected :
                 for testname in options.tests :
-                        testname = canonical_path( testname )
+                        testname = canonicalPath( testname )
                         if Test.valid_name(testname):
-                                found = [test for test in all_tests if canonical_path( test.target() ) == testname]
+                                found = [test for test in allTests if canonicalPath( test.target() ) == testname]
                                 tests.append( found[0] if len(found) == 1 else Test.from_target(testname) )
                         else :
@@ -69 +69 @@
                 # 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 all_tests if path_cmp( t.target(), testname )]
+                        test = [t for t in allTests if pathCmp( t.target(), testname )]
 
                         if test :
@@ -79 +79 @@
 
 # parses the option
-def parse_args():
+def getOptions():
         # create a parser with the arguments for the tests script
         parser = argparse.ArgumentParser(description='Script which runs cforall tests')
@@ -102 +102 @@
                 print('ERROR: invalid arguments', file=sys.stderr)
                 parser.print_help(sys.stderr)
-                sys.exit(1)
+                sys.exit(1)
 
         # script must have at least some tests to run or be listing
@@ -112 +112 @@
         # check that exactly one of the booleans is set to true
         if not sum( (listing, all_tests, some_tests, some_dirs) ) > 0 :
-                print('''ERROR: must have option '--all', '--list', '--include', '-I' or non-empty test list''', file=sys.stderr)
+                print('ERROR: must have option \'--all\', \'--list\', \'--include\', \'-I\' or non-empty test list', file=sys.stderr)
                 parser.print_help()
                 sys.exit(1)
@@ -124 +124 @@
         return val == 0 or settings.dry_run
 
-def no_rule(file, target):
-        return not settings.dry_run and file_contains_only(file, "make: *** No rule to make target `%s'.  Stop." % target)
+def isExe(file):
+        return settings.dry_run or fileIsExecutable(file)
+
+def noRule(file, target):
+        return not settings.dry_run and fileContainsOnly(file, "make: *** No rule to make target `%s'.  Stop." % target)
 
 # logic to run a single test and return the result (No handling of printing or other test framework logic)
@@ -142 +145 @@
         # build, skipping to next test on error
         with Timed() as comp_dur:
-                make_ret, _ = make( test.target(), output=subprocess.DEVNULL, error=out_file, error_file = err_file )
-
+                make_ret, _ = make( test.target(),      redirects  = ("2> %s 1> /dev/null" % out_file), error_file = err_file )
+
+        # if the make command succeds continue otherwise skip to diff
         run_dur = None
-        # run everything in a temp directory to make sure core file are handled properly
-        with tempdir():
-                # if the make command succeds continue otherwise skip to diff
-                if success(make_ret):
-                        with Timed() as run_dur:
-                                if settings.dry_run or is_exe(exe_file):
-                                        # run test
-                                        retcode, _ = sh(exe_file, output=out_file, input=in_file, timeout=True)
-                                else :
-                                        # simply cat the result into the output
-                                        retcode = cat(exe_file, out_file)
-                else:
-                        retcode = mv(err_file, out_file)
-
-                if success(retcode):
-                        if settings.generating :
-                                # if we are ounly generating the output we still need to check that the test actually exists
-                                if no_rule(out_file, test.target()) :
-                                        retcode = 1
-                                        error = "\t\tNo make target for test %s!" % test.target()
-                                        rm(out_file)
-                                else:
-                                        error = None
+        if success(make_ret):
+                with Timed() as run_dur:
+                        if isExe(exe_file):
+                                # run test
+                                retcode = run(exe_file, out_file, in_file)
                         else :
-                                # fetch return code and error from the diff command
-                                retcode, error = diff(cmp_file, out_file)
-
-                else:
-                        with open (out_file, "r") as myfile:
-                                error = myfile.read()
-
-                        ret, info = core_info(exe_file)
-                        error = error + info if error else info
+                                # simply cat the result into the output
+                                retcode = cat(exe_file, out_file)
+        else:
+                retcode = mv(err_file, out_file)
+
+        if success(retcode):
+                if settings.generating :
+                        # if we are ounly generating the output we still need to check that the test actually exists
+                        if noRule(out_file, test.target()) :
+                                retcode = 1
+                                error = "\t\tNo make target for test %s!" % test.target()
+                                rm(out_file)
+                        else:
+                                error = None
+                else :
+                        # fetch return code and error from the diff command
+                        retcode, error = diff(cmp_file, out_file)
+
+        else:
+                with open (out_file, "r") as myfile:
+                        error = myfile.read()
+
+                ret, info = coreInfo(exe_file)
+                error = error + info
 
 
@@ -188 +189 @@
 # run a single test and handle the errors, outputs, printing, exception handling, etc.
 def run_test_worker(t) :
-        try :
+
+        with SignalHandling():
                 # print formated name
-                name_txt = '{0:{width}}  '.format(t.target(), width=settings.output_width)
+                name_txt = "%24s  " % t.name
 
                 retcode, error, duration = run_single_test(t)
@@ -198 +200 @@
 
                 #print result with error if needed
-                text = '\t' + name_txt + result_txt
+                text = name_txt + result_txt
                 out = sys.stdout
                 if error :
-                        text = text + '\n' + error
+                        text = text + "\n" + error
                         out = sys.stderr
 
@@ -208 +210 @@
                 sys.stderr.flush()
 
-                return retcode != TestResult.SUCCESS
-        except KeyboardInterrupt:
-                False
+        return retcode != TestResult.SUCCESS
 
 # run the given list of tests with the given parameters
 def run_tests(tests, jobs) :
         # clean the sandbox from previous commands
-        make('clean', output=subprocess.DEVNULL, error=subprocess.DEVNULL)
+        make('clean', redirects = '> /dev/null 2>&1')
 
         # create the executor for our jobs and handle the signal properly
-        pool = multiprocessing.Pool(jobs)
+        pool = setupPool(jobs)
 
         # for each test to run
@@ -233 +233 @@
 
         # clean the workspace
-        make('clean', output=subprocess.DEVNULL, error=subprocess.DEVNULL)
+        make('clean', redirects = '> /dev/null 2>&1')
 
         for failed in results:
@@ -248 +248 @@
 
         # parse the command line arguments
-        options = parse_args()
+        options = getOptions()
 
         # init global settings
@@ -254 +254 @@
 
         # fetch the liest of all valid tests
-        all_tests = list_tests( options.include, options.exclude )
+        allTests = listTests( options.include, options.exclude )
 
 
         # if user wants all tests than no other treatement of the test list is required
         if options.all or options.list or options.list_comp or options.include :
-                tests = all_tests
+                tests = allTests
 
         #otherwise we need to validate that the test list that was entered is valid
         else :
-                tests = valid_tests( options )
+                tests = validTests( options )
 
         # make sure we have at least some test to run
@@ -281 +281 @@
         elif options.list :
                 print("Listing for %s:%s"% (settings.arch.string, settings.debug.string))
-                fancy_print("\n".join(map(lambda t: t.toString(), tests)))
+                fancy_print("\n".join(map(lambda t: "%s" % (t.toString()), tests)))
 
         else :
                 # check the build configuration works
-                settings.prep_output(tests)
                 settings.validate()
 
-                options.jobs, forceJobs = job_count( options, tests )
-                settings.update_make_cmd(forceJobs, options.jobs)
-
-                print('%s %i tests on %i cores (%s:%s)' % (
-                        'Regenerating' if settings.generating else 'Running',
-                        len(tests),
-                        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.string,
-                        settings.debug.string
+                        settings.debug.string,
+                        options.jobs
                 ))