Changes in / [866f560:65197c2]


Ignore:
Location:
src
Files:
68 added
66 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • src/SymTab/Validate.cc

    r866f560 r65197c2  
    311311                } // if
    312312                // Always remove the hoisted aggregate from the inner structure.
    313                 GuardAction( [this, aggregateDecl]() { filter( aggregateDecl->members, isStructOrUnion, false ); } );
     313                GuardAction( [aggregateDecl]() { filter( aggregateDecl->members, isStructOrUnion, false ); } );
    314314        }
    315315
  • src/tests/Makefile.am

    r866f560 r65197c2  
    2020
    2121if BUILD_CONCURRENCY
    22 concurrent = yes
    23 quick_test += coroutine thread monitor
    24 concurrent_test =               \
    25         coroutine               \
    26         fmtLines                \
    27         pingpong                \
    28         prodcons                \
    29         thread                  \
    30         matrixSum               \
    31         monitor                 \
    32         multi-monitor           \
    33         boundedBuffer           \
    34         preempt                 \
    35         sched-int-block         \
    36         sched-int-disjoint      \
    37         sched-int-wait          \
    38         sched-ext-barge         \
    39         sched-ext-dtor          \
    40         sched-ext-else          \
    41         sched-ext-parse         \
    42         sched-ext-recurse       \
    43         sched-ext-statment      \
    44         sched-ext-when
     22concurrent=
    4523else
    46 concurrent=no
    47 concurrent_test=
     24concurrent='-Econcurrent'
    4825endif
    4926
     
    6239endif
    6340
    64 TEST_FLAGS = $(if $(test), 2> .err/${@}.log, )
     41TEST_FLAGS = $(if $(test), 2> $(test), )
    6542AM_CFLAGS = ${TEST_FLAGS} ${BUILD_FLAGS}
    6643CC = @CFA_BINDIR@/@CFA_NAME@
     
    7047
    7148fstream_test_SOURCES = fstream_test.c
    72 fstream_test_CFLAGS = $(if $(test), 2>> .err/fstream_test.log, ) ${BUILD_FLAGS}
     49fstream_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS}
    7350
    7451vector_test_SOURCES = vector/vector_int.c vector/array.c vector/vector_test.c
    75 vector_test_CFLAGS = $(if $(test), 2>> .err/vector_test.log, ) ${BUILD_FLAGS}
     52vector_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS}
    7653
    7754avl_test_SOURCES = avltree/avl_test.c avltree/avl0.c avltree/avl1.c avltree/avl2.c avltree/avl3.c avltree/avl4.c avltree/avl-private.c
    78 avl_test_CFLAGS = $(if $(test), 2>> .err/avl_test.log, ) ${BUILD_FLAGS}
     55avl_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS}
    7956
    8057all-local :
    81         @+python test.py --debug=${debug} --concurrent=${concurrent} ${quick_test}
     58        @+python test.py --debug=${debug} ${concurrent} ${quick_test}
    8259
    8360all-tests :
    84         @+python test.py --all --debug=${debug} --concurrent=${concurrent}              # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
     61        @+python test.py --all --debug=${debug} ${concurrent}           # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
    8562
    8663clean-local :
     
    8865
    8966list :
    90         @+python test.py --list --concurrent=${concurrent}
     67        @+python test.py --list ${concurrent}
    9168
    9269concurrency :
    93         @+python test.py --debug=${debug} --concurrent=${concurrent} ${concurrent_test}
     70        @+python test.py --debug=${debug} ${concurrent} ${concurrent_test}
    9471
    9572.dummy : .dummy.c @CFA_BINDIR@/@CFA_NAME@
  • src/tests/Makefile.in

    r866f560 r65197c2  
    9191build_triplet = @build@
    9292host_triplet = @host@
    93 @BUILD_CONCURRENCY_TRUE@am__append_1 = coroutine thread monitor
    94 @BUILD_DEBUG_FALSE@am__append_2 = -nodebug
    95 @BUILD_DEBUG_TRUE@@BUILD_RELEASE_FALSE@am__append_3 = -debug
    96 @BUILD_DEBUG_TRUE@@BUILD_RELEASE_TRUE@am__append_4 = ${DEBUG_FLAGS}
     93@BUILD_DEBUG_FALSE@am__append_1 = -nodebug
     94@BUILD_DEBUG_TRUE@@BUILD_RELEASE_FALSE@am__append_2 = -debug
     95@BUILD_DEBUG_TRUE@@BUILD_RELEASE_TRUE@am__append_3 = ${DEBUG_FLAGS}
    9796EXTRA_PROGRAMS = fstream_test$(EXEEXT) vector_test$(EXEEXT) \
    9897        avl_test$(EXEEXT)
     
    314313top_srcdir = @top_srcdir@
    315314debug = yes
    316 quick_test = vector_test avl_test operators numericConstants \
    317         expression enum array typeof cast dtor-early-exit init_once \
    318         attributes $(am__append_1)
    319 @BUILD_CONCURRENCY_FALSE@concurrent = no
    320 @BUILD_CONCURRENCY_TRUE@concurrent = yes
    321 @BUILD_CONCURRENCY_FALSE@concurrent_test =
    322 @BUILD_CONCURRENCY_TRUE@concurrent_test = \
    323 @BUILD_CONCURRENCY_TRUE@        coroutine               \
    324 @BUILD_CONCURRENCY_TRUE@        fmtLines                \
    325 @BUILD_CONCURRENCY_TRUE@        pingpong                \
    326 @BUILD_CONCURRENCY_TRUE@        prodcons                \
    327 @BUILD_CONCURRENCY_TRUE@        thread                  \
    328 @BUILD_CONCURRENCY_TRUE@        matrixSum               \
    329 @BUILD_CONCURRENCY_TRUE@        monitor                 \
    330 @BUILD_CONCURRENCY_TRUE@        multi-monitor           \
    331 @BUILD_CONCURRENCY_TRUE@        boundedBuffer           \
    332 @BUILD_CONCURRENCY_TRUE@        preempt                 \
    333 @BUILD_CONCURRENCY_TRUE@        sched-int-block         \
    334 @BUILD_CONCURRENCY_TRUE@        sched-int-disjoint      \
    335 @BUILD_CONCURRENCY_TRUE@        sched-int-wait          \
    336 @BUILD_CONCURRENCY_TRUE@        sched-ext-barge         \
    337 @BUILD_CONCURRENCY_TRUE@        sched-ext-dtor          \
    338 @BUILD_CONCURRENCY_TRUE@        sched-ext-else          \
    339 @BUILD_CONCURRENCY_TRUE@        sched-ext-parse         \
    340 @BUILD_CONCURRENCY_TRUE@        sched-ext-recurse       \
    341 @BUILD_CONCURRENCY_TRUE@        sched-ext-statment      \
    342 @BUILD_CONCURRENCY_TRUE@        sched-ext-when
    343 
     315quick_test = vector_test avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes
     316@BUILD_CONCURRENCY_FALSE@concurrent = '-Econcurrent'
     317@BUILD_CONCURRENCY_TRUE@concurrent =
    344318
    345319# applies to both programs
    346320DEBUG_FLAGS =
    347321BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ \
    348         $(am__append_2) $(am__append_3) $(am__append_4)
    349 TEST_FLAGS = $(if $(test), 2> .err/${@}.log, )
     322        $(am__append_1) $(am__append_2) $(am__append_3)
     323TEST_FLAGS = $(if $(test), 2> $(test), )
    350324AM_CFLAGS = ${TEST_FLAGS} ${BUILD_FLAGS}
    351325fstream_test_SOURCES = fstream_test.c
    352 fstream_test_CFLAGS = $(if $(test), 2>> .err/fstream_test.log, ) ${BUILD_FLAGS}
     326fstream_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS}
    353327vector_test_SOURCES = vector/vector_int.c vector/array.c vector/vector_test.c
    354 vector_test_CFLAGS = $(if $(test), 2>> .err/vector_test.log, ) ${BUILD_FLAGS}
     328vector_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS}
    355329avl_test_SOURCES = avltree/avl_test.c avltree/avl0.c avltree/avl1.c avltree/avl2.c avltree/avl3.c avltree/avl4.c avltree/avl-private.c
    356 avl_test_CFLAGS = $(if $(test), 2>> .err/avl_test.log, ) ${BUILD_FLAGS}
     330avl_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS}
    357331all: all-am
    358332
     
    833807
    834808all-local :
    835         @+python test.py --debug=${debug} --concurrent=${concurrent} ${quick_test}
     809        @+python test.py --debug=${debug} ${concurrent} ${quick_test}
    836810
    837811all-tests :
    838         @+python test.py --all --debug=${debug} --concurrent=${concurrent}              # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
     812        @+python test.py --all --debug=${debug} ${concurrent}           # '@' => do not echo command (SILENT), '+' => allows recursive make from within python program
    839813
    840814clean-local :
     
    842816
    843817list :
    844         @+python test.py --list --concurrent=${concurrent}
     818        @+python test.py --list ${concurrent}
    845819
    846820concurrency :
    847         @+python test.py --debug=${debug} --concurrent=${concurrent} ${concurrent_test}
     821        @+python test.py --debug=${debug} ${concurrent} ${concurrent_test}
    848822
    849823.dummy : .dummy.c @CFA_BINDIR@/@CFA_NAME@
  • src/tests/pybin/tools.py

    r866f560 r65197c2  
     1from __future__ import print_function
     2
    13import __main__
    24import argparse
     5import multiprocessing
    36import os
    47import re
     8import signal
    59import stat
    6 
     10import sys
     11
     12from pybin import settings
    713from subprocess import Popen, PIPE, STDOUT
    814
     15################################################################################
     16#               shell helpers
     17################################################################################
     18
    919# helper functions to run terminal commands
    10 def sh(cmd, dry_run = False, print2stdout = True):
    11         if dry_run :    # if this is a dry_run, only print the commands that would be ran
     20def sh(cmd, print2stdout = True, input = None):
     21        # add input redirection if needed
     22        if input and os.path.isfile(input):
     23                cmd += " < %s" % input
     24
     25        # if this is a dry_run, only print the commands that would be ran
     26        if settings.dry_run :
    1227                print("cmd: %s" % cmd)
    1328                return 0, None
    14         else :                  # otherwise create a pipe and run the desired command
     29
     30        # otherwise create a pipe and run the desired command
     31        else :
    1532                proc = Popen(cmd, stdout=None if print2stdout else PIPE, stderr=STDOUT, shell=True)
    1633                out, err = proc.communicate()
     
    1835
    1936# Remove 1 or more files silently
    20 def rm( files, dry_run = False ):
     37def rm( files ):
    2138        try:
    2239                for file in files:
    23                         sh("rm -f %s > /dev/null 2>&1" % file, dry_run)
     40                        sh("rm -f %s > /dev/null 2>&1" % file )
    2441        except TypeError:
    25                 sh("rm -f %s > /dev/null 2>&1" % files, dry_run)
     42                sh("rm -f %s > /dev/null 2>&1" % files )
    2643
    2744def chdir( dest = __main__.__file__ ):
     
    3047        os.chdir(dname)
    3148
    32 # helper function to replace patterns in a file
    33 def file_replace(fname, pat, s_after):
    34     # first, see if the pattern is even in the file.
    35     with open(fname) as f:
    36         if not any(re.search(pat, line) for line in f):
    37             return # pattern does not occur in file so we are done.
    38 
    39     # pattern is in the file, so perform replace operation.
    40     with open(fname) as f:
    41         out_fname = fname + ".tmp"
    42         out = open(out_fname, "w")
    43         for line in f:
    44             out.write(re.sub(pat, s_after, line))
    45         out.close()
    46         os.rename(out_fname, fname)
    47 
    48 # helper function to check if a files contains only a spacific string
    49 def fileContainsOnly(file, text) :
    50         with open(file) as f:
    51                 ff = f.read().strip()
    52                 result = ff == text.strip()
    53 
    54                 return result;
    55 
    56 # check whether or not a file is executable
    57 def fileIsExecutable(file) :
    58         try :
    59                 fileinfo = os.stat(file)
    60                 return bool(fileinfo.st_mode & stat.S_IXUSR)
    61         except Exception as inst:
    62                 print(type(inst))    # the exception instance
    63                 print(inst.args)     # arguments stored in .args
    64                 print(inst)
    65                 return False
    66 
    67 # check if arguments is yes or no
    68 def yes_no(string):
    69         if string == "yes" :
    70                 return True
    71         if string == "no" :
    72                 return False
    73         raise argparse.ArgumentTypeError(msg)
    74         return False
    75 
    7649# diff two files
    77 def diff( lhs, rhs, dry_run ):
     50def diff( lhs, rhs ):
    7851        # diff the output of the files
    7952        diff_cmd = ("diff --ignore-all-space "
     
    9467
    9568        # fetch return code and error from the diff command
    96         return sh(diff_cmd % (lhs, rhs), dry_run, False)
     69        return sh(diff_cmd % (lhs, rhs), False)
     70
     71# call make
     72def make(target, flags = '', redirects = '', error_file = None, silent = False):
     73        test_param = """test="%s" """ % (error_file) if error_file else ''
     74        cmd = ' '.join([
     75                settings.make,
     76                '-s' if silent else '',
     77                test_param,
     78                settings.debug.flags,
     79                flags,
     80                target,
     81                redirects
     82        ])
     83        return sh(cmd)
     84
     85################################################################################
     86#               file handling
     87################################################################################
     88
     89# helper function to replace patterns in a file
     90def file_replace(fname, pat, s_after):
     91    # first, see if the pattern is even in the file.
     92    with open(fname) as f:
     93        if not any(re.search(pat, line) for line in f):
     94            return # pattern does not occur in file so we are done.
     95
     96    # pattern is in the file, so perform replace operation.
     97    with open(fname) as f:
     98        out_fname = fname + ".tmp"
     99        out = open(out_fname, "w")
     100        for line in f:
     101            out.write(re.sub(pat, s_after, line))
     102        out.close()
     103        os.rename(out_fname, fname)
     104
     105# helper function to check if a files contains only a specific string
     106def fileContainsOnly(file, text) :
     107        with open(file) as f:
     108                ff = f.read().strip()
     109                result = ff == text.strip()
     110
     111                return result;
     112
     113# check whether or not a file is executable
     114def fileIsExecutable(file) :
     115        try :
     116                fileinfo = os.stat(file)
     117                return bool(fileinfo.st_mode & stat.S_IXUSR)
     118        except Exception as inst:
     119                print(type(inst))    # the exception instance
     120                print(inst.args)     # arguments stored in .args
     121                print(inst)
     122                return False
     123
     124# transform path to canonical form
     125def canonicalPath(path):
     126        return os.path.join('.', os.path.normpath(path) )
     127
     128# compare path even if form is different
     129def pathCmp(lhs, rhs):
     130        return canonicalPath( lhs ) == canonicalPath( rhs )
     131
     132# walk all files in a path
     133def pathWalk( op ):
     134        def step(_, dirname, names):
     135                for name in names:
     136                        path = os.path.join(dirname, name)
     137
     138                        op( path )
     139
     140        # Start the walk
     141        os.path.walk('.', step, '')
     142
     143################################################################################
     144#               system
     145################################################################################
     146
     147# parses the Makefile to find the machine type (32-bit / 64-bit)
     148def getMachineType():
     149        sh('echo "void ?{}(int&a,int b){}int main(){return 0;}" > .dummy.c')
     150        ret, out = make('.dummy', silent = True)
     151
     152        if ret != 0:
     153                print("Failed to identify architecture:")
     154                print(out)
     155                print("Stopping")
     156                rm( (".dummy.c",".dummy") )
     157                sys.exit(1)
     158
     159        _, out = sh("file .dummy", print2stdout=False)
     160        rm( (".dummy.c",".dummy") )
     161
     162        if settings.dry_run :
     163                return 'x64'
     164
     165        return re.search(r"[^,]+,([^,]+),", out).group(1).strip()
     166
     167# count number of jobs to create
     168def jobCount( options, tests ):
     169        # check if the user already passed in a number of jobs for multi-threading
     170        make_flags = os.environ.get('MAKEFLAGS')
     171        make_jobs_fds = re.search("--jobserver-(auth|fds)=\s*([0-9]+),([0-9]+)", make_flags) if make_flags else None
     172        if make_jobs_fds :
     173                tokens = os.read(int(make_jobs_fds.group(2)), 1024)
     174                options.jobs = len(tokens)
     175                os.write(int(make_jobs_fds.group(3)), tokens)
     176        else :
     177                options.jobs = multiprocessing.cpu_count()
     178
     179        # make sure we have a valid number of jobs that corresponds to user input
     180        if options.jobs <= 0 :
     181                print('ERROR: Invalid number of jobs', file=sys.stderr)
     182                sys.exit(1)
     183
     184        return min( options.jobs, len(tests) ), True if make_flags else False
     185
     186# setup a proper processor pool with correct signal handling
     187def setupPool(jobs):
     188        original_sigint_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
     189        pool = multiprocessing.Pool(jobs)
     190        signal.signal(signal.SIGINT, original_sigint_handler)
     191
     192        return pool
     193
     194# handle signals in scope
     195class SignalHandling():
     196        def __enter__(self):
     197                # enable signal handling
     198                signal.signal(signal.SIGINT, signal.SIG_DFL)
     199
     200        def __exit__(self, type, value, traceback):
     201                # disable signal handling
     202                signal.signal(signal.SIGINT, signal.SIG_IGN)
     203
     204################################################################################
     205#               misc
     206################################################################################
     207
     208# check if arguments is yes or no
     209def yes_no(string):
     210        if string == "yes" :
     211                return True
     212        if string == "no" :
     213                return False
     214        raise argparse.ArgumentTypeError(msg)
     215        return False
     216
     217
     218settings.set_machine_default( getMachineType )
  • src/tests/test.py

    r866f560 r65197c2  
    22from __future__ import print_function
    33
    4 from functools import partial
    5 from multiprocessing import Pool
    6 from os import listdir, environ
    7 from os.path import isfile, join, splitext
    84from pybin.tools import *
     5from pybin.test_run import *
     6from pybin import settings
    97
    108import argparse
    11 import multiprocessing
    12 import os
    139import re
    14 import signal
    1510import sys
    1611
     
    1914################################################################################
    2015
    21 # Test class that defines what a test is
    22 class Test:
    23     def __init__(self, name, path):
    24         self.name, self.path = name, path
    25 
    26 class TestResult:
    27         SUCCESS = 0
    28         FAILURE = 1
    29         TIMEOUT = 124
    30 
    31 # parses the Makefile to find the machine type (32-bit / 64-bit)
    32 def getMachineType():
    33         sh('echo "void ?{}(int&a,int b){}int main(){return 0;}" > .dummy.c')
    34         ret, out = sh("make .dummy -s", print2stdout=True)
    35 
    36         if ret != 0:
    37                 print("Failed to identify architecture:")
    38                 print(out)
    39                 print("Stopping")
    40                 rm( (".dummy.c",".dummy") )
    41                 sys.exit(1)
    42 
    43         _, out = sh("file .dummy", print2stdout=False)
    44         rm( (".dummy.c",".dummy") )
    45 
    46         return re.search("ELF\s([0-9]+)-bit", out).group(1)
    47 
    48 def listTestsFolder(folder) :
    49         path = ('./.expect/%s/' % folder) if folder else './.expect/'
    50         subpath = "%s/" % folder if folder else ""
     16def findTests():
     17        expected = []
     18
     19        def matchTest(path):
     20                match = re.search("(\.[\w\/\-_]*)\/.expect\/([\w\-_]+)(\.[\w\-_]+)?\.txt", path)
     21                if match :
     22                        test = Test()
     23                        test.name = match.group(2)
     24                        test.path = match.group(1)
     25                        test.arch = match.group(3)[1:] if match.group(3) else None
     26                        if settings.arch.match(test.arch):
     27                                expected.append(test)
     28
     29        pathWalk( matchTest )
     30
     31        return expected
     32
     33# reads the directory ./.expect and indentifies the tests
     34def listTests( includes, excludes ):
     35        includes = [canonicalPath( i ) for i in includes] if includes else None
     36        excludes = [canonicalPath( i ) for i in excludes] if excludes else None
    5137
    5238        # tests directly in the .expect folder will always be processed
    53         return map(lambda fname: Test(fname, subpath + fname),
    54                 [splitext(f)[0] for f in listdir( path )
    55                 if not f.startswith('.') and f.endswith('.txt')
    56                 ])
    57 
    58 # reads the directory ./.expect and indentifies the tests
    59 def listTests( concurrent ):
    60         machineType = getMachineType()
    61 
    62         # tests directly in the .expect folder will always be processed
    63         generic_list = listTestsFolder( "" )
    64 
    65         # tests in the machineType folder will be ran only for the corresponding compiler
    66         typed_list = listTestsFolder( machineType )
    67 
    68         # tests in the concurrent folder will be ran only if concurrency is enabled
    69         concurrent_list = listTestsFolder( "concurrent" ) if concurrent else []
    70 
    71         # append both lists to get
    72         return generic_list + typed_list + concurrent_list;
     39        test_list = findTests()
     40
     41        # if we have a limited number of includes, filter by them
     42        if includes:
     43                test_list = [x for x in test_list if
     44                        x.path.startswith( tuple(includes) )
     45                ]
     46
     47        # # if we have a folders to excludes, filter by them
     48        if excludes:
     49                test_list = [x for x in test_list if not
     50                        x.path.startswith( tuple(excludes) )
     51                ]
     52
     53        return test_list
    7354
    7455# from the found tests, filter all the valid tests/desired tests
     
    8061        if options.regenerate_expected :
    8162                for testname in options.tests :
    82                         if testname.endswith( (".c", ".cc", ".cpp") ):
     63                        if Test.valid_name(testname):
     64                                found = [test for test in allTests if test.target() == testname]
     65                                tests.append( found[0] if len(found) == 1 else Test.from_target(testname) )
     66                        else :
    8367                                print('ERROR: "%s", tests are not allowed to end with a C/C++/CFA extension, ignoring it' % testname, file=sys.stderr)
    84                         else :
    85                                 found = [test for test in allTests if test.name == testname]
    86                                 tests.append( found[0] if len(found) == 1 else Test(testname, testname) )
    8768
    8869        else :
    8970                # otherwise we only need to validate that all tests are present in the complete list
    9071                for testname in options.tests:
    91                         test = [t for t in allTests if t.name == testname]
    92 
    93                         if len(test) != 0 :
     72                        test = [t for t in allTests if pathCmp( t.target(), testname )]
     73
     74                        if test :
    9475                                tests.append( test[0] )
    9576                        else :
     
    9778
    9879        # make sure we have at least some test to run
    99         if len(tests) == 0 :
     80        if not tests :
    10081                print('ERROR: No valid test to run', file=sys.stderr)
    10182                sys.exit(1)
     
    10889        parser = argparse.ArgumentParser(description='Script which runs cforall tests')
    10990        parser.add_argument('--debug', help='Run all tests in debug or release', type=yes_no, default='no')
    110         parser.add_argument('--concurrent', help='Run concurrent tests', type=yes_no, default='yes')
     91        parser.add_argument('--arch', help='Test for specific architecture', type=str, default='')
    11192        parser.add_argument('--dry-run', help='Don\'t run the tests, only output the commands', action='store_true')
    11293        parser.add_argument('--list', help='List all test available', action='store_true')
     
    11596        parser.add_argument('-j', '--jobs', help='Number of tests to run simultaneously', type=int, default='8')
    11697        parser.add_argument('--list-comp', help='List all valide arguments', action='store_true')
     98        parser.add_argument('-I','--include', help='Directory of test to include, can be used multiple time, All  if omitted', action='append')
     99        parser.add_argument('-E','--exclude', help='Directory of test to exclude, can be used multiple time, None if omitted', action='append')
    117100        parser.add_argument('tests', metavar='test', type=str, nargs='*', help='a list of tests to run')
    118101
     
    123106        all_tests  = options.all
    124107        some_tests = len(options.tests) > 0
     108        some_dirs  = len(options.include) > 0 if options.include else 0
    125109
    126110        # check that exactly one of the booleans is set to true
    127         if not sum( (listing, all_tests, some_tests) ) == 1 :
    128                 print('ERROR: must have option \'--all\', \'--list\' or non-empty test list', file=sys.stderr)
     111        if not sum( (listing, all_tests, some_tests, some_dirs) ) > 0 :
     112                print('ERROR: must have option \'--all\', \'--list\', \'--include\', \'-I\' or non-empty test list', file=sys.stderr)
    129113                parser.print_help()
    130114                sys.exit(1)
     
    132116        return options
    133117
    134 def jobCount( options ):
    135         # check if the user already passed in a number of jobs for multi-threading
    136         make_flags = environ.get('MAKEFLAGS')
    137         make_jobs_fds = re.search("--jobserver-(auth|fds)=\s*([0-9]+),([0-9]+)", make_flags) if make_flags else None
    138         if make_jobs_fds :
    139                 tokens = os.read(int(make_jobs_fds.group(2)), 1024)
    140                 options.jobs = len(tokens)
    141                 os.write(int(make_jobs_fds.group(3)), tokens)
    142         else :
    143                 options.jobs = multiprocessing.cpu_count()
    144 
    145         # make sure we have a valid number of jobs that corresponds to user input
    146         if options.jobs <= 0 :
    147                 print('ERROR: Invalid number of jobs', file=sys.stderr)
    148                 sys.exit(1)
    149 
    150         return min( options.jobs, len(tests) ), True if make_flags else False
    151 
    152118################################################################################
    153119#               running test functions
    154120################################################################################
    155121# logic to run a single test and return the result (No handling of printing or other test framework logic)
    156 def run_single_test(test, generate, dry_run, debug):
     122def run_single_test(test):
    157123
    158124        # find the output file based on the test name and options flag
    159         out_file = (".out/%s.log" % test.name) if not generate else (".expect/%s.txt" % test.path)
    160         err_file = ".err/%s.log" % test.name
     125        out_file = test.target_output()
     126        err_file = test.error_log()
     127        cmp_file = test.expect()
     128        in_file  = test.input()
     129
     130        # prepare the proper directories
     131        test.prepare()
    161132
    162133        # remove any outputs from the previous tests to prevent side effects
    163         rm( (out_file, err_file, test.name), dry_run )
    164 
    165         options = "-debug" if debug else "-nodebug"
     134        rm( (out_file, err_file, test.target()) )
    166135
    167136        # build, skipping to next test on error
    168         make_ret, _ = sh("""%s test=yes DEBUG_FLAGS="%s" %s 2> %s 1> /dev/null""" % (make_cmd, options, test.name, out_file), dry_run)
    169 
    170         retcode = 0
    171         error = None
     137        make_ret, _ = make( test.target(),
     138                redirects  = "2> %s 1> /dev/null" % out_file,
     139                error_file = err_file
     140        )
    172141
    173142        # if the make command succeds continue otherwise skip to diff
    174         if make_ret == 0 :
    175                 # fetch optional input
    176                 stdinput = "< .in/%s.txt" % test.name if isfile(".in/%s.txt" % test.name) else ""
    177 
    178                 if fileIsExecutable(test.name) :
     143        if make_ret == 0 or settings.dry_run:
     144                if settings.dry_run or fileIsExecutable(test.target()) :
    179145                        # run test
    180                         retcode, _ = sh("timeout 60 ./%s %s > %s 2>&1" % (test.name, stdinput, out_file), dry_run)
     146                        retcode, _ = sh("timeout 60 %s > %s 2>&1" % (test.target(), out_file), input = in_file)
    181147                else :
    182148                        # simply cat the result into the output
    183                         sh("cat %s > %s" % (test.name, out_file), dry_run)
    184 
    185         else :
    186                 # command failed save the log to less temporary file
    187                 sh("mv %s %s" % (err_file, out_file), dry_run)
     149                        retcode, _ = sh("cat %s > %s" % (test.target(), out_file))
     150        else:
     151                retcode, _ = sh("mv %s %s" % (err_file, out_file))
     152
    188153
    189154        if retcode == 0:
    190                 if generate :
     155                if settings.generating :
    191156                        # if we are ounly generating the output we still need to check that the test actually exists
    192                         if not dry_run and fileContainsOnly(out_file, "make: *** No rule to make target `%s'.  Stop." % test.name) :
     157                        if not settings.dry_run and fileContainsOnly(out_file, "make: *** No rule to make target `%s'.  Stop." % test.target()) :
    193158                                retcode = 1;
    194                                 error = "\t\tNo make target for test %s!" % test.name
     159                                error = "\t\tNo make target for test %s!" % test.target()
    195160                                sh("rm %s" % out_file, False)
     161                        else:
     162                                error = None
    196163                else :
    197164                        # fetch return code and error from the diff command
    198                         retcode, error = diff(".expect/%s.txt" % test.path, ".out/%s.log" % test.name, dry_run)
     165                        retcode, error = diff(cmp_file, out_file)
    199166
    200167        else:
     
    204171
    205172        # clean the executable
    206         sh("rm -f %s > /dev/null 2>&1" % test.name, dry_run)
     173        sh("rm -f %s > /dev/null 2>&1" % test.target())
    207174
    208175        return retcode, error
    209176
    210177# run a single test and handle the errors, outputs, printing, exception handling, etc.
    211 def run_test_worker(t, generate, dry_run, debug) :
    212 
    213         signal.signal(signal.SIGINT, signal.SIG_DFL)
    214         # print formated name
    215         name_txt = "%20s  " % t.name
    216 
    217         retcode, error = run_single_test(t, generate, dry_run, debug)
    218 
    219         # update output based on current action
    220         if generate :
    221                 if   retcode == TestResult.SUCCESS:     result_txt = "Done"
    222                 elif retcode == TestResult.TIMEOUT:     result_txt = "TIMEOUT"
    223                 else :                                          result_txt = "ERROR code %d" % retcode
    224         else :
    225                 if   retcode == TestResult.SUCCESS:     result_txt = "PASSED"
    226                 elif retcode == TestResult.TIMEOUT:     result_txt = "TIMEOUT"
    227                 else :                                          result_txt = "FAILED with code %d" % retcode
    228 
    229         #print result with error if needed
    230         text = name_txt + result_txt
    231         out = sys.stdout
    232         if error :
    233                 text = text + "\n" + error
    234                 out = sys.stderr
    235 
    236         print(text, file = out)
    237         sys.stdout.flush()
    238         sys.stderr.flush()
    239         signal.signal(signal.SIGINT, signal.SIG_IGN)
     178def run_test_worker(t) :
     179
     180        with SignalHandling():
     181                # print formated name
     182                name_txt = "%20s  " % t.name
     183
     184                retcode, error = run_single_test(t)
     185
     186                # update output based on current action
     187                result_txt = TestResult.toString( retcode )
     188
     189                #print result with error if needed
     190                text = name_txt + result_txt
     191                out = sys.stdout
     192                if error :
     193                        text = text + "\n" + error
     194                        out = sys.stderr
     195
     196                print(text, file = out)
     197                sys.stdout.flush()
     198                sys.stderr.flush()
    240199
    241200        return retcode != TestResult.SUCCESS
    242201
    243202# run the given list of tests with the given parameters
    244 def run_tests(tests, generate, dry_run, jobs, debug) :
     203def run_tests(tests, jobs) :
    245204        # clean the sandbox from previous commands
    246         sh("%s clean > /dev/null 2>&1" % make_cmd, dry_run)
    247 
    248         # make sure the required folder are present
    249         sh('mkdir -p .out .expect .err', dry_run)
    250 
    251         if generate :
    252                 print( "Regenerate tests for: " )
     205        make('clean', redirects = '> /dev/null 2>&1')
    253206
    254207        # create the executor for our jobs and handle the signal properly
    255         original_sigint_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
    256         pool = Pool(jobs)
    257         signal.signal(signal.SIGINT, original_sigint_handler)
     208        pool = setupPool(jobs)
    258209
    259210        # for each test to run
    260211        try :
    261                 results = pool.map_async(partial(run_test_worker, generate=generate, dry_run=dry_run, debug=debug), tests, chunksize = 1 ).get(7200)
     212                results = pool.map_async(
     213                        run_test_worker,
     214                        tests,
     215                        chunksize = 1
     216                ).get(7200)
    262217        except KeyboardInterrupt:
    263218                pool.terminate()
     
    266221
    267222        # clean the workspace
    268         sh("%s clean > /dev/null 2>&1" % make_cmd, dry_run)
     223        make('clean', redirects = '> /dev/null 2>&1')
    269224
    270225        for failed in results:
     
    285240        options = getOptions()
    286241
     242        # init global settings
     243        settings.init( options )
     244
    287245        # fetch the liest of all valid tests
    288         allTests = listTests( options.concurrent )
     246        allTests = listTests( options.include, options.exclude )
    289247
    290248        # if user wants all tests than no other treatement of the test list is required
    291         if options.all or options.list or options.list_comp :
     249        if options.all or options.list or options.list_comp or options.include :
    292250                tests = allTests
    293251
     252        #otherwise we need to validate that the test list that was entered is valid
    294253        else :
    295                 #otherwise we need to validate that the test list that was entered is valid
    296254                tests = validTests( options )
    297255
    298256        # sort the test alphabetically for convenience
    299         tests.sort(key=lambda t: t.name)
     257        tests.sort(key=lambda t: (t.arch if t.arch else '') + t.target())
    300258
    301259        # users may want to simply list the tests
    302260        if options.list_comp :
    303                 print("-h --help --debug --concurrent --dry-run --list --all --regenerate-expected -j --jobs ", end='')
    304                 print(" ".join(map(lambda t: "%s" % (t.name), tests)))
     261                print("-h --help --debug --dry-run --list --arch --all --regenerate-expected -j --jobs ", end='')
     262                print(" ".join(map(lambda t: "%s" % (t.target()), tests)))
    305263
    306264        elif options.list :
    307                 print("\n".join(map(lambda t: "%s (%s)" % (t.name, t.path), tests)))
     265                print("Listing for %s:%s"% (settings.arch.string, settings.debug.string))
     266                print("\n".join(map(lambda t: "%s" % (t.toString()), tests)))
    308267
    309268        else :
    310                 options.jobs, forceJobs = jobCount( options )
    311 
    312                 print('Running (%s) on %i cores' % ("debug" if options.debug else "no debug", options.jobs))
    313                 make_cmd = "make" if forceJobs else ("make -j%i" % options.jobs)
     269                options.jobs, forceJobs = jobCount( options, tests )
     270                settings.updateMakeCmd(forceJobs, options.jobs)
     271
     272                print('%s (%s:%s) on %i cores' % (
     273                        'Regenerate tests' if settings.generating else 'Running',
     274                        settings.arch.string,
     275                        settings.debug.string,
     276                        options.jobs
     277                ))
    314278
    315279                # otherwise run all tests and make sure to return the correct error code
    316                 sys.exit( run_tests(tests, options.regenerate_expected, options.dry_run, options.jobs, options.debug) )
     280                sys.exit( run_tests(tests, options.jobs) )
Note: See TracChangeset for help on using the changeset viewer.