testlib.py 73.4 KB
Newer Older
1
#
2 3 4
# (c) Simon Marlow 2002
#

5 6 7
# This allows us to use the "with X:" syntax with python 2.5:
from __future__ import with_statement

8
import shutil
9 10
import sys
import os
11
import errno
12 13 14 15
import string
import re
import traceback
import copy
16
import glob
17
import types
ian@well-typed.com's avatar
ian@well-typed.com committed
18
from math import ceil, trunc
19

20 21 22 23 24 25 26
have_subprocess = False
try:
    import subprocess
    have_subprocess = True
except:
    print "Warning: subprocess not found, will fall back to spawnv"

27
from string import join
28
from testglobals import *
29 30
from testutil import *

31 32 33
if config.use_threads:
    import threading
    import thread
34

35 36 37 38 39 40 41 42
global wantToStop
wantToStop = False
def stopNow():
    global wantToStop
    wantToStop = True
def stopping():
    return wantToStop

43 44
# Options valid for the current test only (these get reset to
# testdir_testopts after each test).
45

ei@vuokko.info's avatar
ei@vuokko.info committed
46
global testopts_local
47 48 49 50 51 52
if config.use_threads:
    testopts_local = threading.local()
else:
    class TestOpts_Local:
        pass
    testopts_local = TestOpts_Local()
53 54

def getTestOpts():
ei@vuokko.info's avatar
ei@vuokko.info committed
55
    return testopts_local.x
56

ei@vuokko.info's avatar
ei@vuokko.info committed
57 58 59
def setLocalTestOpts(opts):
    global testopts_local
    testopts_local.x=opts
60 61 62 63

# This can be called at the top of a file of tests, to set default test options
# for the following tests.
def setTestOpts( f ):
64 65
    global thisdir_settings
    thisdir_settings = compose(thisdir_settings, f)
66 67 68 69 70 71 72 73 74 75 76 77

# -----------------------------------------------------------------------------
# Canned setup functions for common cases.  eg. for a test you might say
#
#      test('test001', normal, compile, [''])
#
# to run it without any options, but change it to
#
#      test('test001', expect_fail, compile, [''])
#
# to expect failure for this test.

78
def normal( name, opts ):
79 80
    return;

81
def skip( name, opts ):
82 83
    opts.skip = 1

84
def expect_fail( name, opts ):
85 86
    opts.expect = 'fail';

87
def reqlib( lib ):
88
    return lambda name, opts, l=lib: _reqlib (name, opts, l )
89

90 91 92 93
# Cache the results of looking to see if we have a library or not.
# This makes quite a difference, especially on Windows.
have_lib = {}

94
def _reqlib( name, opts, lib ):
95 96
    if have_lib.has_key(lib):
        got_it = have_lib[lib]
97
    else:
98 99 100
        if have_subprocess:
            # By preference we use subprocess, as the alternative uses
            # /dev/null which mingw doesn't have.
101
            p = subprocess.Popen([config.ghc_pkg, '--no-user-package-db', 'describe', lib],
102 103 104 105 106 107 108 109 110 111 112 113 114
                                 stdout=subprocess.PIPE,
                                 stderr=subprocess.PIPE)
            # read from stdout and stderr to avoid blocking due to
            # buffers filling
            p.communicate()
            r = p.wait()
        else:
            r = os.system(config.ghc_pkg + ' describe ' + lib
                                         + ' > /dev/null 2> /dev/null')
        got_it = r == 0
        have_lib[lib] = got_it

    if not got_it:
115
        opts.expect = 'missing-lib'
116

117
def req_profiling( name, opts ):
118 119 120
    if not config.have_profiling:
        opts.expect = 'fail'

121
def req_shared_libs( name, opts ):
Simon Marlow's avatar
Simon Marlow committed
122 123 124
    if not config.have_shared_libs:
        opts.expect = 'fail'

125
def req_interp( name, opts ):
Ian Lynagh's avatar
Ian Lynagh committed
126 127 128
    if not config.have_interp:
        opts.expect = 'fail'

129
def req_smp( name, opts ):
Simon Marlow's avatar
Simon Marlow committed
130 131 132
    if not config.have_smp:
        opts.expect = 'fail'

Ian Lynagh's avatar
Ian Lynagh committed
133
def expect_broken( bug ):
134
    return lambda name, opts, b=bug: _expect_broken (name, opts, b )
Ian Lynagh's avatar
Ian Lynagh committed
135

136
def _expect_broken( name, opts, bug ):
Ian Lynagh's avatar
Ian Lynagh committed
137 138
    opts.expect = 'fail';

139
def ignore_output( name, opts ):
140 141
    opts.ignore_output = 1

142
def no_stdin( name, opts ):
143 144
    opts.no_stdin = 1

145
def combined_output( name, opts ):
pcapriotti's avatar
pcapriotti committed
146 147
    opts.combined_output = True

148 149 150
# -----

def expect_fail_for( ways ):
151
    return lambda name, opts, w=ways: _expect_fail_for( name, opts, w )
152

153
def _expect_fail_for( name, opts, ways ):
154 155
    opts.expect_fail_for = ways

Ian Lynagh's avatar
Ian Lynagh committed
156
def expect_broken_for( bug, ways ):
157
    return lambda name, opts, b=bug, w=ways: _expect_broken_for( name, opts, b, w )
Ian Lynagh's avatar
Ian Lynagh committed
158

159
def _expect_broken_for( name, opts, bug, ways ):
Ian Lynagh's avatar
Ian Lynagh committed
160
    opts.expect_fail_for = ways
Ian Lynagh's avatar
Ian Lynagh committed
161

162 163 164
# -----

def omit_ways( ways ):
165
    return lambda name, opts, w=ways: _omit_ways( name, opts, w )
166

167
def _omit_ways( name, opts, ways ):
168 169 170 171
    opts.omit_ways = ways

# -----

172
def only_ways( ways ):
173
    return lambda name, opts, w=ways: _only_ways( name, opts, w )
174

175
def _only_ways( name, opts, ways ):
176 177 178 179
    opts.only_ways = ways

# -----

180
def extra_ways( ways ):
181
    return lambda name, opts, w=ways: _extra_ways( name, opts, w )
182

183
def _extra_ways( name, opts, ways ):
184 185 186 187
    opts.extra_ways = ways

# -----

ross's avatar
ross committed
188
def omit_compiler_types( compiler_types ):
189
   return lambda name, opts, c=compiler_types: _omit_compiler_types(name, opts, c)
ross's avatar
ross committed
190

191
def _omit_compiler_types( name, opts, compiler_types ):
ross's avatar
ross committed
192
    if config.compiler_type in compiler_types:
dterei's avatar
dterei committed
193
        opts.skip = 1
ross's avatar
ross committed
194 195 196 197

# -----

def only_compiler_types( compiler_types ):
198
   return lambda name, opts, c=compiler_types: _only_compiler_types(name, opts, c)
ross's avatar
ross committed
199

200
def _only_compiler_types( name, opts, compiler_types ):
ross's avatar
ross committed
201
    if config.compiler_type not in compiler_types:
dterei's avatar
dterei committed
202
        opts.skip = 1
ross's avatar
ross committed
203 204 205

# -----

206
def set_stdin( file ):
207
   return lambda name, opts, f=file: _set_stdin(name, opts, f);
208

209
def _set_stdin( name, opts, f ):
210 211 212 213 214
   opts.stdin = f

# -----

def exit_code( val ):
215
    return lambda name, opts, v=val: _exit_code(name, opts, v);
216

217
def _exit_code( name, opts, v ):
218 219 220 221
    opts.exit_code = v

# -----

222
def timeout_multiplier( val ):
223
    return lambda name, opts, v=val: _timeout_multiplier(name, opts, v)
224

225
def _timeout_multiplier( name, opts, v ):
226 227 228 229
    opts.timeout_multiplier = v

# -----

230
def extra_run_opts( val ):
231
    return lambda name, opts, v=val: _extra_run_opts(name, opts, v);
232

233
def _extra_run_opts( name, opts, v ):
234 235
    opts.extra_run_opts = v

236 237
# -----

Simon Marlow's avatar
Simon Marlow committed
238
def extra_hc_opts( val ):
239
    return lambda name, opts, v=val: _extra_hc_opts(name, opts, v);
Simon Marlow's avatar
Simon Marlow committed
240

241
def _extra_hc_opts( name, opts, v ):
Simon Marlow's avatar
Simon Marlow committed
242 243 244 245
    opts.extra_hc_opts = v

# -----

246
def extra_clean( files ):
247
    return lambda name, opts, v=files: _extra_clean(name, opts, v);
248

249
def _extra_clean( name, opts, v ):
250 251
    opts.clean_files = v

252 253
# -----

254 255 256 257 258 259 260 261 262 263 264 265 266 267
def stats_num_field( field, expecteds ):
    return lambda name, opts, f=field, e=expecteds: _stats_num_field(name, opts, f, e);

def _stats_num_field( name, opts, field, expecteds ):
    if field in opts.stats_range_fields:
        framework_fail(name, 'duplicate-numfield', 'Duplicate ' + field + ' num_field check')

    for (b, expected, dev) in expecteds:
        if b:
            opts.stats_range_fields[field] = (expected, dev)
            return

    framework_fail(name, 'numfield-no-expected', 'No expected value found for ' + field + ' in num_field check')

ian@well-typed.com's avatar
ian@well-typed.com committed
268
def stats_range_field( field, expected, dev ):
269
    return stats_num_field( field, [(True, expected, dev)] )
270

271 272
def compiler_stats_num_field( field, expecteds ):
    return lambda name, opts, f=field, e=expecteds: _compiler_stats_num_field(name, opts, f, e);
273

274 275 276 277 278 279 280 281
def _compiler_stats_num_field( name, opts, field, expecteds ):
    if field in opts.compiler_stats_range_fields:
        framework_fail(name, 'duplicate-numfield', 'Duplicate ' + field + ' num_field check')

    for (b, expected, dev) in expecteds:
        if b:
            opts.compiler_stats_range_fields[field] = (expected, dev)
            return
282

283 284 285 286
    framework_fail(name, 'numfield-no-expected', 'No expected value found for ' + field + ' in num_field check')

def compiler_stats_range_field( field, expected, dev ):
    return compiler_stats_num_field( field, [(True, expected, dev)] )
287 288 289

# -----

290
def skip_if_no_ghci(name, opts):
dterei's avatar
dterei committed
291 292
    if not ('ghci' in config.run_ways):
        opts.skip = 1
293

294 295
# ----

296
def skip_if_fast(name, opts):
dterei's avatar
dterei committed
297 298
    if config.fast:
        opts.skip = 1
299

Simon Marlow's avatar
Simon Marlow committed
300 301
# -----

302 303 304 305 306 307 308 309 310
def when(b, f):
    if b:
        return f
    else:
        return normal

def unless(b, f):
    return when(not b, f)

311
def if_platform( plat, f ):
Simon Marlow's avatar
Simon Marlow committed
312
    if config.platform == plat:
313
        return f
314 315 316
    else:
        return normal

317
def unless_platform( plat, f ):
Ian Lynagh's avatar
Ian Lynagh committed
318 319 320 321 322
    if config.platform != plat:
        return f
    else:
        return normal

323 324 325
def if_os( os, f ):
    if config.os == os:
        return f
326 327 328
    else:
        return normal

Ian Lynagh's avatar
Ian Lynagh committed
329 330 331 332 333 334
def unless_os( os, f ):
    if config.os == os:
        return normal
    else:
        return f

335 336 337 338 339 340
def if_arch( arch, f ):
    if config.arch == arch:
        return f
    else:
        return normal

341 342 343 344 345 346
def unless_arch( arch, f ):
    if config.arch == arch:
        return normal
    else:
        return f

347 348
def wordsize( ws ):
    return config.wordsize == str(ws)
tibbe's avatar
tibbe committed
349

ian@well-typed.com's avatar
ian@well-typed.com committed
350 351 352 353 354 355 356 357 358 359 360 361
def if_unregisterised( f ):
    if config.unregisterised:
        return f
    else:
        return normal

def unless_unregisterised( f ):
    if config.unregisterised:
        return normal
    else:
        return f

Ian Lynagh's avatar
Ian Lynagh committed
362 363 364 365 366 367 368 369 370 371 372 373
def if_msys( f ):
    if config.msys:
        return f
    else:
        return normal

def if_cygwin( f ):
    if config.cygwin:
        return f
    else:
        return normal

374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
def when_have_vanilla( f ):
    if config.have_vanilla:
        return f
    else:
        return normal

def unless_have_vanilla( f ):
    if config.have_vanilla:
        return normal
    else:
        return f

def when_have_dynamic( f ):
    if config.have_dynamic:
        return f
    else:
        return normal

def unless_have_dynamic( f ):
    if config.have_dynamic:
        return normal
    else:
        return f

def when_have_profiling( f ):
    if config.have_profiling:
        return f
    else:
        return normal

def unless_have_profiling( f ):
    if config.have_profiling:
        return normal
    else:
        return f

410 411
# ---

412 413 414 415 416 417
def if_ghci_dynamic( f ):
    if config.ghc_dynamic_by_default:
        return f
    else:
        return normal

418 419 420 421 422 423 424 425 426 427 428 429
def if_in_tree_compiler( f ):
    if config.in_tree_compiler:
        return f
    else:
        return normal

def unless_in_tree_compiler( f ):
    if config.in_tree_compiler:
        return normal
    else:
        return f

430 431 432 433 434
def if_compiler_type( compiler, f ):
    if config.compiler_type == compiler:
        return f
    else:
        return normal
435 436 437 438 439 440

def if_compiler_profiled( f ):
    if config.compiler_profiled:
        return f
    else:
        return normal
441

442 443 444 445 446 447
def unless_compiler_profiled( f ):
    if config.compiler_profiled:
        return normal
    else:
        return f

Ian Lynagh's avatar
Ian Lynagh committed
448
def if_compiler_lt( compiler, version, f ):
449
    if config.compiler_type == compiler and \
Ian Lynagh's avatar
Ian Lynagh committed
450 451 452 453
       version_lt(config.compiler_version, version):
        return f
    else:
        return normal
454

Ian Lynagh's avatar
Ian Lynagh committed
455
def if_compiler_le( compiler, version, f ):
456 457
    if config.compiler_type == compiler and \
       version_le(config.compiler_version, version):
Ian Lynagh's avatar
Ian Lynagh committed
458 459 460
        return f
    else:
        return normal
461

Ian Lynagh's avatar
Ian Lynagh committed
462
def if_compiler_gt( compiler, version, f ):
463
    if config.compiler_type == compiler and \
Ian Lynagh's avatar
Ian Lynagh committed
464 465 466 467
       version_gt(config.compiler_version, version):
        return f
    else:
        return normal
468

Ian Lynagh's avatar
Ian Lynagh committed
469
def if_compiler_ge( compiler, version, f ):
470
    if config.compiler_type == compiler and \
Ian Lynagh's avatar
Ian Lynagh committed
471 472 473 474
       version_ge(config.compiler_version, version):
        return f
    else:
        return normal
475

476 477 478 479 480 481
def if_compiler_debugged( f ):
    if config.compiler_debugged:
        return f
    else:
        return normal

Ian Lynagh's avatar
Ian Lynagh committed
482 483
def namebase( nb ):
   return lambda opts, nb=nb: _namebase(opts, nb)
484

Ian Lynagh's avatar
Ian Lynagh committed
485 486
def _namebase( opts, nb ):
    opts.with_namebase = nb
487

488 489
# ---

490
def if_tag( tag, f ):
491
    if tag in config.compiler_tags:
492 493 494
        return f
    else:
        return normal
495

496
def unless_tag( tag, f ):
497
    if not (tag in config.compiler_tags):
498 499 500
        return f
    else:
        return normal
501

ei@vuokko.info's avatar
ei@vuokko.info committed
502
# ---
503
def high_memory_usage(name, opts):
504 505
    opts.alone = True

Ian Lynagh's avatar
Ian Lynagh committed
506
# ---
507
def literate( name, opts ):
Ian Lynagh's avatar
Ian Lynagh committed
508 509
    opts.literate = 1;

510
def c_src( name, opts ):
511 512
    opts.c_src = 1;

513
def objc_src( name, opts ):
Austin Seipp's avatar
Austin Seipp committed
514 515
    opts.objc_src = 1;

516
def objcpp_src( name, opts ):
517 518
    opts.objcpp_src = 1;

519
def cmm_src( name, opts ):
520 521
    opts.cmm_src = 1;

522
def outputdir( odir ):
523
    return lambda name, opts, d=odir: _outputdir(name, opts, d)
524

525
def _outputdir( name, opts, odir ):
526 527
    opts.outputdir = odir;

528 529
# ----

530
def pre_cmd( cmd ):
531
    return lambda name, opts, c=cmd: _pre_cmd(name, opts, cmd)
532

533
def _pre_cmd( name, opts, cmd ):
534 535 536 537
    opts.pre_cmd = cmd

# ----

538
def clean_cmd( cmd ):
539
    return lambda name, opts, c=cmd: _clean_cmd(name, opts, cmd)
540

541
def _clean_cmd( name, opts, cmd ):
542 543 544 545
    opts.clean_cmd = cmd

# ----

546
def cmd_prefix( prefix ):
547
    return lambda name, opts, p=prefix: _cmd_prefix(name, opts, prefix)
548

549
def _cmd_prefix( name, opts, prefix ):
550 551 552 553 554
    opts.cmd_wrapper = lambda cmd, p=prefix: p + ' ' + cmd;

# ----

def cmd_wrapper( fun ):
555
    return lambda name, opts, f=fun: _cmd_wrapper(name, opts, fun)
556

557
def _cmd_wrapper( name, opts, fun ):
558
    opts.cmd_wrapper = fun
559

560 561
# ----

Ian Lynagh's avatar
Ian Lynagh committed
562
def compile_cmd_prefix( prefix ):
563
    return lambda name, opts, p=prefix: _compile_cmd_prefix(name, opts, prefix)
Ian Lynagh's avatar
Ian Lynagh committed
564

565
def _compile_cmd_prefix( name, opts, prefix ):
Ian Lynagh's avatar
Ian Lynagh committed
566 567 568 569
    opts.compile_cmd_prefix = prefix

# ----

570
def normalise_slashes( name, opts ):
571 572
    opts.extra_normaliser = normalise_slashes_

573
def normalise_exe( name, opts ):
574 575
    opts.extra_normaliser = normalise_exe_

576
def normalise_fun( fun ):
577
    return lambda name, opts, f=fun: _normalise_fun(name, opts, f)
578

579
def _normalise_fun( name, opts, f ):
580 581
    opts.extra_normaliser = f

582
def normalise_errmsg_fun( fun ):
583
    return lambda name, opts, f=fun: _normalise_errmsg_fun(name, opts, f)
584

585
def _normalise_errmsg_fun( name, opts, f ):
586 587 588 589 590
    opts.extra_errmsg_normaliser = f

def two_normalisers(f, g):
    return lambda x, f=f, g=g: f(g(x))

591 592 593
# ----
# Function for composing two opt-fns together

594 595 596
def composes( fs ):
    return reduce(lambda f, g: compose(f, g), fs)

597
def compose( f, g ):
598
    return lambda name, opts, f=f, g=g: _compose(name, opts, f, g)
599

600 601 602
def _compose( name, opts, f, g ):
    f(name, opts)
    g(name, opts)
603 604 605 606 607

# -----------------------------------------------------------------------------
# The current directory of tests

def newTestDir( dir ):
608
    global thisdir_settings
609
    # reset the options for this test directory
610 611 612 613 614
    thisdir_settings = lambda name, opts, dir=dir: _newTestDir( name, opts, dir )

def _newTestDir( name, opts, dir ):
    opts.testdir = dir
    opts.compiler_always_flags = config.compiler_always_flags
615 616 617 618

# -----------------------------------------------------------------------------
# Actually doing tests

619 620
parallelTests = []
aloneTests = []
621
allTestNames = set([])
622

623
def runTest (opts, name, func, args):
ei@vuokko.info's avatar
ei@vuokko.info committed
624 625
    ok = 0

626
    if config.use_threads:
ei@vuokko.info's avatar
ei@vuokko.info committed
627
        t.thread_pool.acquire()
628
        try:
629
            while config.threads<(t.running_threads+1):
630
                t.thread_pool.wait()
631
            t.running_threads = t.running_threads+1
632 633
            ok=1
            t.thread_pool.release()
634
            thread.start_new_thread(test_common_thread, (name, opts, func, args))
635 636 637 638 639
        except:
            if not ok:
                t.thread_pool.release()
    else:
        test_common_work (name, opts, func, args)
640

641
# name  :: String
642
# setup :: TestOpts -> IO ()
643
def test (name, setup, func, args):
644 645
    global aloneTests
    global parallelTests
646
    global allTestNames
647
    global thisdir_settings
648 649
    if name in allTestNames:
        framework_fail(name, 'duplicate', 'There are multiple tests with this name')
650
    if not re.match('^[0-9]*[a-zA-Z][a-zA-Z0-9._-]*$', name):
651
        framework_fail(name, 'bad_name', 'This test has an invalid name')
652 653 654 655 656

    # Make a deep copy of the default_testopts, as we need our own copy
    # of any dictionaries etc inside it. Otherwise, if one test modifies
    # them, all tests will see the modified version!
    myTestOpts = copy.deepcopy(default_testopts)
657 658 659 660

    if type(setup) is types.ListType:
       setup = composes(setup)

661 662
    setup = compose(thisdir_settings, setup)
    setup(name, myTestOpts)
663 664 665 666 667 668

    thisTest = lambda : runTest(myTestOpts, name, func, args)
    if myTestOpts.alone:
        aloneTests.append(thisTest)
    else:
        parallelTests.append(thisTest)
669
    allTestNames.add(name)
670

671
if config.use_threads:
672
    def test_common_thread(name, opts, func, args):
673 674 675 676 677 678
        t.lock.acquire()
        try:
            test_common_work(name,opts,func,args)
        finally:
            t.lock.release()
            t.thread_pool.acquire()
679
            t.running_threads = t.running_threads - 1
680 681
            t.thread_pool.notify()
            t.thread_pool.release()
682

683 684 685 686 687 688 689 690 691 692
def get_package_cache_timestamp():
    if config.package_conf_cache_file == '':
        return 0.0
    else:
        try:
            return os.stat(config.package_conf_cache_file).st_mtime
        except:
            return 0.0


ei@vuokko.info's avatar
ei@vuokko.info committed
693
def test_common_work (name, opts, func, args):
694 695 696 697 698 699 700 701 702
    try:
        t.total_tests = t.total_tests+1
        setLocalTestOpts(opts)

        package_conf_cache_file_start_timestamp = get_package_cache_timestamp()

        # All the ways we might run this test
        if func == compile or func == multimod_compile:
            all_ways = config.compile_ways
703
        elif func == compile_and_run or func == multimod_compile_and_run:
704 705 706 707 708 709
            all_ways = config.run_ways
        elif func == ghci_script:
            if 'ghci' in config.run_ways:
                all_ways = ['ghci']
            else:
                all_ways = []
710
        else:
711 712 713 714 715 716 717 718 719 720 721
            all_ways = ['normal']

        # A test itself can request extra ways by setting opts.extra_ways
        all_ways = all_ways + filter(lambda way: way not in all_ways,
                                     opts.extra_ways)

        t.total_test_cases = t.total_test_cases + len(all_ways)

        ok_way = lambda way: \
            not getTestOpts().skip \
            and (config.only == [] or name in config.only) \
722
            and (getTestOpts().only_ways == None or way in getTestOpts().only_ways) \
723 724 725 726 727 728 729 730 731 732 733 734 735
            and (config.cmdline_ways == [] or way in config.cmdline_ways) \
            and way not in getTestOpts().omit_ways

        # Which ways we are asked to skip
        do_ways = filter (ok_way,all_ways)

        # In fast mode, we skip all but one way
        if config.fast and len(do_ways) > 0:
            do_ways = [do_ways[0]]

        if not config.clean_only:
            # Run the required tests...
            for way in do_ways:
736 737
                if stopping():
                    break
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758
                do_test (name, way, func, args)

            for way in all_ways:
                if way not in do_ways:
                    skiptest (name,way)

        if getTestOpts().cleanup != '' and (config.clean_only or do_ways != []):
            clean(map (lambda suff: name + suff,
                      ['', '.exe', '.exe.manifest', '.genscript',
                       '.stderr.normalised',        '.stdout.normalised',
                       '.run.stderr',               '.run.stdout',
                       '.run.stderr.normalised',    '.run.stdout.normalised',
                       '.comp.stderr',              '.comp.stdout',
                       '.comp.stderr.normalised',   '.comp.stdout.normalised',
                       '.interp.stderr',            '.interp.stdout',
                       '.interp.stderr.normalised', '.interp.stdout.normalised',
                       '.stats', '.comp.stats',
                       '.hi', '.o', '.prof', '.exe.prof', '.hc',
                       '_stub.h', '_stub.c', '_stub.o',
                       '.hp', '.exe.hp', '.ps', '.aux', '.hcr', '.eventlog']))

759
            if func == multi_compile or func == multi_compile_fail:
760 761 762 763 764
                    extra_mods = args[1]
                    clean(map (lambda (f,x): replace_suffix(f, 'o'), extra_mods))
                    clean(map (lambda (f,x): replace_suffix(f, 'hi'), extra_mods))

            clean(getTestOpts().clean_files)
Ian Lynagh's avatar
Ian Lynagh committed
765

766 767 768 769 770 771 772
            if getTestOpts().outputdir != None:
                odir = in_testdir(getTestOpts().outputdir)
                try:
                    shutil.rmtree(odir)
                except:
                    pass

773 774 775 776 777
            try:
                shutil.rmtree(in_testdir('.hpc.' + name))
            except:
                pass

778 779 780 781 782 783 784 785
            try:
                cleanCmd = getTestOpts().clean_cmd
                if cleanCmd != None:
                    result = runCmdFor(name, 'cd ' + getTestOpts().testdir + ' && ' + cleanCmd)
                    if result != 0:
                        framework_fail(name, 'cleaning', 'clean-command failed: ' + str(result))
            except e:
                framework_fail(name, 'cleaning', 'clean-command exception')
786

787
        package_conf_cache_file_end_timestamp = get_package_cache_timestamp();
788

789 790
        if package_conf_cache_file_start_timestamp != package_conf_cache_file_end_timestamp:
            framework_fail(name, 'whole-test', 'Package cache timestamps do not match: ' + str(package_conf_cache_file_start_timestamp) + ' ' + str(package_conf_cache_file_end_timestamp))
791

792 793 794 795 796 797 798 799 800 801 802 803
        try:
            for f in files_written[name]:
                if os.path.exists(f):
                    try:
                        if not f in files_written_not_removed[name]:
                            files_written_not_removed[name].append(f)
                    except:
                        files_written_not_removed[name] = [f]
        except:
            pass
    except Exception, e:
        framework_fail(name, 'runTest', 'Unhandled exception: ' + str(e))
Ian Lynagh's avatar
Ian Lynagh committed
804

805 806 807 808
def clean(strs):
    for str in strs:
        for name in glob.glob(in_testdir(str)):
            clean_full_path(name)
809

810
def clean_full_path(name):
Ian Lynagh's avatar
Ian Lynagh committed
811 812 813 814
        try:
            # Remove files...
            os.remove(name)
        except OSError, e1:
815
            try:
Ian Lynagh's avatar
Ian Lynagh committed
816 817 818 819 820 821 822 823 824 825 826
                # ... and empty directories
                os.rmdir(name)
            except OSError, e2:
                # We don't want to fail here, but we do want to know
                # what went wrong, so print out the exceptions.
                # ENOENT isn't a problem, though, as we clean files
                # that don't necessarily exist.
                if e1.errno != errno.ENOENT:
                    print e1
                if e2.errno != errno.ENOENT:
                    print e2
827

828
def do_test(name, way, func, args):
829 830 831
    full_name = name + '(' + way + ')'

    try:
832
        print '=====>', full_name, t.total_tests, 'of', len(allTestNames), \
833 834 835
                        str([t.n_unexpected_passes,   \
                             t.n_unexpected_failures, \
                             t.n_framework_failures])
836

837 838
        if config.use_threads:
            t.lock.release()
839 840 841 842

        try:
            preCmd = getTestOpts().pre_cmd
            if preCmd != None:
843
                result = runCmdFor(name, 'cd ' + getTestOpts().testdir + ' && ' + preCmd)
844 845 846 847 848
                if result != 0:
                    framework_fail(name, way, 'pre-command failed: ' + str(result))
        except e:
            framework_fail(name, way, 'pre-command exception')

ei@vuokko.info's avatar
ei@vuokko.info committed
849 850 851
        try:
            result = apply(func, [name,way] + args)
        finally:
852 853
            if config.use_threads:
                t.lock.acquire()
854

855 856 857
        if getTestOpts().expect != 'pass' and \
                getTestOpts().expect != 'fail' and \
                getTestOpts().expect != 'missing-lib':
858
            framework_fail(name, way, 'bad expected ' + getTestOpts().expect)
859

860 861 862 863 864 865
        try:
            passFail = result['passFail']
        except:
            passFail = 'No passFail found'

        if passFail == 'pass':
ei@vuokko.info's avatar
ei@vuokko.info committed
866 867
            if getTestOpts().expect == 'pass' \
               and way not in getTestOpts().expect_fail_for:
868
                t.n_expected_passes = t.n_expected_passes + 1
869 870 871 872
                if name in t.expected_passes:
                    t.expected_passes[name].append(way)
                else:
                    t.expected_passes[name] = [way]
873 874 875
            else:
                print '*** unexpected pass for', full_name
                t.n_unexpected_passes = t.n_unexpected_passes + 1
876
                addPassingTestInfo(t.unexpected_passes, getTestOpts().testdir, name, way)
877
        elif passFail == 'fail':
ei@vuokko.info's avatar
ei@vuokko.info committed
878 879
            if getTestOpts().expect == 'pass' \
               and way not in getTestOpts().expect_fail_for:
880 881
                print '*** unexpected failure for', full_name
                t.n_unexpected_failures = t.n_unexpected_failures + 1
882 883
                reason = result['reason']
                addFailingTestInfo(t.unexpected_failures, getTestOpts().testdir, name, reason, way)
884
            else:
885 886 887 888 889 890
                if getTestOpts().expect == 'missing-lib':
                    t.n_missing_libs = t.n_missing_libs + 1
                    if name in t.missing_libs:
                        t.missing_libs[name].append(way)
                    else:
                        t.missing_libs[name] = [way]
891
                else:
892 893 894 895 896
                    t.n_expected_failures = t.n_expected_failures + 1
                    if name in t.expected_failures:
                        t.expected_failures[name].append(way)
                    else:
                        t.expected_failures[name] = [way]
897 898
        else:
            framework_fail(name, way, 'bad result ' + passFail)
899
    except KeyboardInterrupt:
900
        stopNow()
901
    except:
902
        framework_fail(name, way, 'do_test exception')
903 904
        traceback.print_exc()

905
def addPassingTestInfo (testInfos, directory, name, way):
906 907 908 909 910 911 912 913 914 915
    directory = re.sub('^\\.[/\\\\]', '', directory)

    if not directory in testInfos:
        testInfos[directory] = {}

    if not name in testInfos[directory]:
        testInfos[directory][name] = []

    testInfos[directory][name].append(way)

916 917 918 919 920 921 922 923 924 925 926 927 928 929
def addFailingTestInfo (testInfos, directory, name, reason, way):
    directory = re.sub('^\\.[/\\\\]', '', directory)

    if not directory in testInfos:
        testInfos[directory] = {}

    if not name in testInfos[directory]:
        testInfos[directory][name] = {}

    if not reason in testInfos[directory][name]:
        testInfos[directory][name][reason] = []

    testInfos[directory][name][reason].append(way)

930
def skiptest (name, way):
931 932
    # print 'Skipping test \"', name, '\"'
    t.n_tests_skipped = t