Changeset f3b9efc


Ignore:
Timestamp:
Dec 5, 2017, 1:29:12 PM (4 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
86ad276
Parents:
099a40d
Message:

Tests now properly work with multiple architectures

Location:
src/tests
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • src/tests/pybin/settings.py

    r099a40d rf3b9efc  
     1import sys
    12
    23class Architecture:
    3         def __init__(self, cmd):
    4                 if cmd:
     4        KnownArchitectures = {
     5                'x64'                   : 'x64',
     6                'x86-64'                : 'x64',
     7                'x86'                   : 'x86',
     8                'i386'          : 'x86',
     9                'i486'          : 'x86',
     10                'i686'          : 'x86',
     11                'Intel 80386'   : 'x86',
     12                'arm'                   : 'arm',
     13                'ARM'                   : 'arm',
     14        }
     15
     16        def __init__(self, arch):
     17                if arch:
    518                        self.cross_compile = True
    6                         self.target = cmd
     19                        try:
     20                                self.target = Architecture.makeCanonical( arch )
     21                        except KeyError:
     22                                print("Unkown architecture %s" % arch)
     23                                sys.exit(1)
    724                else:
    825                        self.cross_compile = False
    9                         self.target = 'x64'
     26                        try:
     27                                arch = machine_default()
     28                                self.target = Architecture.makeCanonical( arch )
     29                        except KeyError:
     30                                print("Running on unkown architecture %s" % arch)
     31                                sys.exit(1)
    1032
    11         def toString(self):
    12                 return self.target
     33                self.string = self.target
     34
     35        def update(self):
     36                if not self.cross_compile:
     37                        self.target = machine_default()
     38                        self.string = self.target
     39                        print("updated to %s" % self.target)
     40
     41        def match(self, arch):
     42                return True if not arch else self.target == arch
     43
     44        @classmethod
     45        def makeCanonical(_, arch):
     46                return Architecture.KnownArchitectures[arch]
     47
     48
     49class Debug:
     50        def __init__(self, value):
     51                self.string = "debug" if value else "no debug"
     52                self.flags  = """DEBUG_FLAGS="%s" """ % ("-debug" if value else "-nodebug")
    1353
    1454def init( options ):
     
    2060        global debugFlag
    2161
    22         arch       = Architecture(options.arch)
    2362        dry_run    = options.dry_run
    2463        generating = options.regenerate_expected
    25         make       = './make_command_not_initialized'
    26         debug        = "debug" if options.debug else "no debug"
    27         debugFlag  = """DEBUG_FLAGS="%s" """ % ("-debug" if debug else "-nodebug")
     64        make       = 'make'
     65        debug        = Debug(options.debug)
     66        arch       = Architecture(options.arch)
    2867
    2968def updateMakeCmd(force, jobs):
    3069        global make
    3170
    32         make = "make" if force else ("make -j%i" % jobs)
     71        make = "make" if not force else ("make -j%i" % jobs)
     72
     73
     74def set_machine_default( func ):
     75        global machine_default
     76
     77        machine_default = func
  • src/tests/pybin/test_run.py

    r099a40d rf3b9efc  
    2121
    2222        def expect(self):
    23                 return ("%s/.expect/%s.txt" % (self.path, self.name))
     23                return ("%s/.expect/%s%s.txt" % (self.path, self.name, '' if not self.arch else ".%s" % self.arch))
    2424
    2525        def error_log(self):
     
    3939
    4040        @classmethod
    41         def valid_name(cls, name):
     41        def valid_name(_, name):
    4242                return not name.endswith( ('.c', '.cc', '.cpp', '.cfa') )
    4343
    4444        @classmethod
    45         def from_target(cls, target):
     45        def from_target(_, target):
    4646                test = Test()
    4747                test.name = os.path.basename(target)
  • src/tests/pybin/tools.py

    r099a40d rf3b9efc  
    7676                '-s' if silent else '',
    7777                test_param,
    78                 settings.debugFlag,
     78                settings.debug.flags,
    7979                flags,
    8080                target,
     
    147147# parses the Makefile to find the machine type (32-bit / 64-bit)
    148148def getMachineType():
    149         return 'x64'
    150149        sh('echo "void ?{}(int&a,int b){}int main(){return 0;}" > .dummy.c')
    151150        ret, out = make('.dummy', silent = True)
     
    161160        rm( (".dummy.c",".dummy") )
    162161
    163         return out
    164         return re.search("ELF\s([0-9]+)-bit", out).group(1)
     162        if settings.dry_run :
     163                return 'x64'
     164
     165        return re.search(r"[^,]+,([^,]+),", out).group(1).strip()
    165166
    166167# count number of jobs to create
     
    213214        raise argparse.ArgumentTypeError(msg)
    214215        return False
     216
     217
     218settings.set_machine_default( getMachineType )
  • src/tests/test.py

    r099a40d rf3b9efc  
    1717        expected = []
    1818
    19         def findTest(path):
     19        def matchTest(path):
    2020                match = re.search("(\.[\w\/\-_]*)\/.expect\/([\w\-_]+)(\.[\w\-_]+)?\.txt", path)
    2121                if match :
     
    2424                        test.path = match.group(1)
    2525                        test.arch = match.group(3)[1:] if match.group(3) else None
    26                         expected.append(test)
    27 
    28         pathWalk( findTest )
     26                        if settings.arch.match(test.arch):
     27                                expected.append(test)
     28
     29        pathWalk( matchTest )
    2930
    3031        return expected
     
    7778
    7879        # make sure we have at least some test to run
    79         if tests :
     80        if not tests :
    8081                print('ERROR: No valid test to run', file=sys.stderr)
    8182                sys.exit(1)
     
    139140        )
    140141
    141         retcode = 0
    142         error = None
    143 
    144142        # if the make command succeds continue otherwise skip to diff
    145143        if make_ret == 0 or settings.dry_run:
     
    149147                else :
    150148                        # simply cat the result into the output
    151                         sh("cat %s > %s" % (test.target(), out_file))
     149                        retcode, _ = sh("cat %s > %s" % (test.target(), out_file))
    152150        else:
    153                 sh("mv %s %s" % (err_file, out_file))
     151                retcode, _ = sh("mv %s %s" % (err_file, out_file))
    154152
    155153
     
    161159                                error = "\t\tNo make target for test %s!" % test.target()
    162160                                sh("rm %s" % out_file, False)
     161                        else:
     162                                error = None
    163163                else :
    164164                        # fetch return code and error from the diff command
     
    250250                tests = allTests
    251251
     252        #otherwise we need to validate that the test list that was entered is valid
    252253        else :
    253                 #otherwise we need to validate that the test list that was entered is valid
    254254                tests = validTests( options )
    255255
    256256        # sort the test alphabetically for convenience
    257         tests.sort(key=lambda t: t.target())
     257        tests.sort(key=lambda t: (t.arch if t.arch else '') + t.target())
    258258
    259259        # users may want to simply list the tests
    260260        if options.list_comp :
    261                 print("-h --help --debug --dry-run --list --all --regenerate-expected -j --jobs ", end='')
     261                print("-h --help --debug --dry-run --list --arch --all --regenerate-expected -j --jobs ", end='')
    262262                print(" ".join(map(lambda t: "%s" % (t.target()), tests)))
    263263
    264264        elif options.list :
    265                 print("Listing for %s:%s"% (settings.arch.toString(), settings.debug))
     265                print("Listing for %s:%s"% (settings.arch.string, settings.debug.string))
    266266                print("\n".join(map(lambda t: "%s" % (t.toString()), tests)))
    267267
     
    272272                print('%s (%s:%s) on %i cores' % (
    273273                        'Regenerate tests' if settings.generating else 'Running',
    274                         settings.arch.toString(),
    275                         settings.debug,
     274                        settings.arch.string,
     275                        settings.debug.string,
    276276                        options.jobs
    277277                ))
Note: See TracChangeset for help on using the changeset viewer.