Changeset 933f32f for tests/test.py

Timestamp:

May 24, 2019, 10:19:41 AM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

d908563

Parents:

6a9d4b4 (diff), 292642a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into cleanup-dtors

File:

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

tests/test.py

@@ -1 @@
-#!/usr/bin/python
-from __future__ import print_function
+#!/usr/bin/python3
 
 from pybin.tools import *
@@ -9 +8 @@
 import re
 import sys
+import tempfile
 import time
 
@@ -15 +15 @@
 ################################################################################
 
-def findTests():
+def find_tests():
         expected = []
 
-        def matchTest(path):
+        def match_test(path):
                 match = re.search("^%s\/([\w\/\-_]*).expect\/([\w\-_]+)(\.[\w\-_]+)?\.txt$" % settings.SRCDIR, path)
                 if match :
@@ -28 +28 @@
                                 expected.append(test)
 
-        pathWalk( matchTest )
+        path_walk( match_test )
 
         return expected
 
 # reads the directory ./.expect and indentifies the tests
-def listTests( includes, excludes ):
+def list_tests( includes, excludes ):
         # tests directly in the .expect folder will always be processed
-        test_list = findTests()
+        test_list = find_tests()
 
         # 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 validTests( options ):
+def valid_tests( options ):
         tests = []
 
@@ -59 +59 @@
         if options.regenerate_expected :
                 for testname in options.tests :
-                        testname = canonicalPath( testname )
+                        testname = canonical_path( testname )
                         if Test.valid_name(testname):
-                                found = [test for test in allTests if canonicalPath( test.target() ) == testname]
+                                found = [test for test in all_tests if canonical_path( 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 allTests if pathCmp( t.target(), testname )]
+                        test = [t for t in all_tests if path_cmp( t.target(), testname )]
 
                         if test :
@@ -79 +79 @@
 
 # parses the option
-def getOptions():
+def parse_args():
         # 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 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)
+def no_rule(file, target):
+        return not settings.dry_run and file_contains_only(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)
@@ -145 +142 @@
         # build, skipping to next test on error
         with Timed() as comp_dur:
-                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
+                make_ret, _ = make( test.target(), output=subprocess.DEVNULL, error=out_file, error_file = err_file )
+
         run_dur = None
-        if success(make_ret):
-                with Timed() as run_dur:
-                        if isExe(exe_file):
-                                # run test
-                                retcode = run(exe_file, out_file, in_file)
+        # 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
                         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 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
+                                # 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
 
 
@@ -189 +188 @@
 # run a single test and handle the errors, outputs, printing, exception handling, etc.
 def run_test_worker(t) :
-
-        with SignalHandling():
+        try :
                 # print formated name
-                name_txt = "%24s  " % t.name
+                name_txt = '{0:{width}}  '.format(t.target(), width=settings.output_width)
 
                 retcode, error, duration = run_single_test(t)
@@ -200 +198 @@
 
                 #print result with error if needed
-                text = name_txt + result_txt
+                text = '\t' + name_txt + result_txt
                 out = sys.stdout
                 if error :
-                        text = text + "\n" + error
+                        text = text + '\n' + error
                         out = sys.stderr
 
@@ -210 +208 @@
                 sys.stderr.flush()
 
-        return retcode != TestResult.SUCCESS
+                return retcode != TestResult.SUCCESS
+        except KeyboardInterrupt:
+                False
 
 # run the given list of tests with the given parameters
 def run_tests(tests, jobs) :
         # clean the sandbox from previous commands
-        make('clean', redirects = '> /dev/null 2>&1')
+        make('clean', output=subprocess.DEVNULL, error=subprocess.DEVNULL)
 
         # create the executor for our jobs and handle the signal properly
-        pool = setupPool(jobs)
+        pool = multiprocessing.Pool(jobs)
 
         # for each test to run
@@ -233 +233 @@
 
         # clean the workspace
-        make('clean', redirects = '> /dev/null 2>&1')
+        make('clean', output=subprocess.DEVNULL, error=subprocess.DEVNULL)
 
         for failed in results:
@@ -248 +248 @@
 
         # parse the command line arguments
-        options = getOptions()
+        options = parse_args()
 
         # init global settings
@@ -254 +254 @@
 
         # fetch the liest of all valid tests
-        allTests = listTests( options.include, options.exclude )
+        all_tests = list_tests( 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 = allTests
+                tests = all_tests
 
         #otherwise we need to validate that the test list that was entered is valid
         else :
-                tests = validTests( options )
+                tests = valid_tests( 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: "%s" % (t.toString()), tests)))
+                fancy_print("\n".join(map(lambda t: t.toString(), tests)))
 
         else :
                 # check the build configuration works
+                settings.prep_output(tests)
                 settings.validate()
 
-                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',
+                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,
                         settings.arch.string,
-                        settings.debug.string,
-                        options.jobs
+                        settings.debug.string
                 ))