Pass the test name to the test options

This allows them to give framework failures.

I also had to change how setTestOpts works. Now, rather than applying
the options to the directory's "default options", it just stores the
options to be applied for each test (i.e. once we know the test name).

24 files changed, 112 insertions, 118 deletions

diff --git a/testsuite/driver/runtests.py b/testsuite/driver/runtests.py
index f6581db8b3..04d69b734a 100644
--- a/testsuite/driver/runtests.py
+++ b/testsuite/driver/runtests.py
@@ -207,9 +207,6 @@ if windows or darwin:
 global testopts_local
 testopts_local.x = TestOptions()
 
-global thisdir_testopts
-thisdir_testopts = getThisDirTestOpts()
-
 if config.use_threads:
     t.lock = threading.Lock()
     t.thread_pool = threading.Condition(t.lock)
diff --git a/testsuite/driver/testlib.py b/testsuite/driver/testlib.py
index 13373922e5..7d744bb5f3 100644
--- a/testsuite/driver/testlib.py
+++ b/testsuite/driver/testlib.py
@@ -40,16 +40,6 @@ def stopNow():
 def stopping():
     return wantToStop
 
-# Options valid for all the tests in the current "directory".  After
-# each test, we reset the options to these.  To change the options for
-# multiple tests, the function setTestOpts() below can be used to alter
-# these options.
-global thisdir_testopts
-thisdir_testopts = TestOptions()
-
-def getThisDirTestOpts():
-    return thisdir_testopts
-
 # Options valid for the current test only (these get reset to
 # testdir_testopts after each test).
 
@@ -71,7 +61,8 @@ def setLocalTestOpts(opts):
 # This can be called at the top of a file of tests, to set default test options
 # for the following tests.
 def setTestOpts( f ):
-    f( thisdir_testopts );
+    global thisdir_settings
+    thisdir_settings = compose(thisdir_settings, f)
 
 # -----------------------------------------------------------------------------
 # Canned setup functions for common cases.  eg. for a test you might say
@@ -84,23 +75,23 @@ def setTestOpts( f ):
 #
 # to expect failure for this test.
 
-def normal( opts ):
+def normal( name, opts ):
     return;
 
-def skip( opts ):
+def skip( name, opts ):
     opts.skip = 1
 
-def expect_fail( opts ):
+def expect_fail( name, opts ):
     opts.expect = 'fail';
 
 def reqlib( lib ):
-    return lambda opts, l=lib: _reqlib (opts, l )
+    return lambda name, opts, l=lib: _reqlib (name, opts, l )
 
 # Cache the results of looking to see if we have a library or not.
 # This makes quite a difference, especially on Windows.
 have_lib = {}
 
-def _reqlib( opts, lib ):
+def _reqlib( name, opts, lib ):
     if have_lib.has_key(lib):
         got_it = have_lib[lib]
     else:
@@ -123,164 +114,164 @@ def _reqlib( opts, lib ):
     if not got_it:
         opts.expect = 'missing-lib'
 
-def req_profiling( opts ):
+def req_profiling( name, opts ):
     if not config.have_profiling:
         opts.expect = 'fail'
 
-def req_shared_libs( opts ):
+def req_shared_libs( name, opts ):
     if not config.have_shared_libs:
         opts.expect = 'fail'
 
-def req_interp( opts ):
+def req_interp( name, opts ):
     if not config.have_interp:
         opts.expect = 'fail'
 
-def req_smp( opts ):
+def req_smp( name, opts ):
     if not config.have_smp:
         opts.expect = 'fail'
 
 def expect_broken( bug ):
-    return lambda opts, b=bug: _expect_broken (opts, b )
+    return lambda name, opts, b=bug: _expect_broken (name, opts, b )
 
-def _expect_broken( opts, bug ):
+def _expect_broken( name, opts, bug ):
     opts.expect = 'fail';
 
-def ignore_output( opts ):
+def ignore_output( name, opts ):
     opts.ignore_output = 1
 
-def no_stdin( opts ):
+def no_stdin( name, opts ):
     opts.no_stdin = 1
 
-def combined_output( opts ):
+def combined_output( name, opts ):
     opts.combined_output = True
 
 # -----
 
 def expect_fail_for( ways ):
-    return lambda opts, w=ways: _expect_fail_for( opts, w )
+    return lambda name, opts, w=ways: _expect_fail_for( name, opts, w )
 
-def _expect_fail_for( opts, ways ):
+def _expect_fail_for( name, opts, ways ):
     opts.expect_fail_for = ways
 
 def expect_broken_for( bug, ways ):
-    return lambda opts, b=bug, w=ways: _expect_broken_for( opts, b, w )
+    return lambda name, opts, b=bug, w=ways: _expect_broken_for( name, opts, b, w )
 
-def _expect_broken_for( opts, bug, ways ):
+def _expect_broken_for( name, opts, bug, ways ):
     opts.expect_fail_for = ways
 
 # -----
 
 def omit_ways( ways ):
-    return lambda opts, w=ways: _omit_ways( opts, w )
+    return lambda name, opts, w=ways: _omit_ways( name, opts, w )
 
-def _omit_ways( opts, ways ):
+def _omit_ways( name, opts, ways ):
     opts.omit_ways = ways
 
 # -----
 
 def only_ways( ways ):
-    return lambda opts, w=ways: _only_ways( opts, w )
+    return lambda name, opts, w=ways: _only_ways( name, opts, w )
 
-def _only_ways( opts, ways ):
+def _only_ways( name, opts, ways ):
     opts.only_ways = ways
 
 # -----
 
 def extra_ways( ways ):
-    return lambda opts, w=ways: _extra_ways( opts, w )
+    return lambda name, opts, w=ways: _extra_ways( name, opts, w )
 
-def _extra_ways( opts, ways ):
+def _extra_ways( name, opts, ways ):
     opts.extra_ways = ways
 
 # -----
 
 def omit_compiler_types( compiler_types ):
-   return lambda opts, c=compiler_types: _omit_compiler_types(opts, c)
+   return lambda name, opts, c=compiler_types: _omit_compiler_types(name, opts, c)
 
-def _omit_compiler_types( opts, compiler_types ):
+def _omit_compiler_types( name, opts, compiler_types ):
     if config.compiler_type in compiler_types:
         opts.skip = 1
 
 # -----
 
 def only_compiler_types( compiler_types ):
-   return lambda opts, c=compiler_types: _only_compiler_types(opts, c)
+   return lambda name, opts, c=compiler_types: _only_compiler_types(name, opts, c)
 
-def _only_compiler_types( opts, compiler_types ):
+def _only_compiler_types( name, opts, compiler_types ):
     if config.compiler_type not in compiler_types:
         opts.skip = 1
 
 # -----
 
 def set_stdin( file ):
-   return lambda opts, f=file: _set_stdin(opts, f);
+   return lambda name, opts, f=file: _set_stdin(name, opts, f);
 
-def _set_stdin( opts, f ):
+def _set_stdin( name, opts, f ):
    opts.stdin = f
 
 # -----
 
 def exit_code( val ):
-    return lambda opts, v=val: _exit_code(opts, v);
+    return lambda name, opts, v=val: _exit_code(name, opts, v);
 
-def _exit_code( opts, v ):
+def _exit_code( name, opts, v ):
     opts.exit_code = v
 
 # -----
 
 def timeout_multiplier( val ):
-    return lambda opts, v=val: _timeout_multiplier(opts, v)
+    return lambda name, opts, v=val: _timeout_multiplier(name, opts, v)
 
-def _timeout_multiplier( opts, v ):
+def _timeout_multiplier( name, opts, v ):
     opts.timeout_multiplier = v
 
 # -----
 
 def extra_run_opts( val ):
-    return lambda opts, v=val: _extra_run_opts(opts, v);
+    return lambda name, opts, v=val: _extra_run_opts(name, opts, v);
 
-def _extra_run_opts( opts, v ):
+def _extra_run_opts( name, opts, v ):
     opts.extra_run_opts = v
 
 # -----
 
 def extra_hc_opts( val ):
-    return lambda opts, v=val: _extra_hc_opts(opts, v);
+    return lambda name, opts, v=val: _extra_hc_opts(name, opts, v);
 
-def _extra_hc_opts( opts, v ):
+def _extra_hc_opts( name, opts, v ):
     opts.extra_hc_opts = v
 
 # -----
 
 def extra_clean( files ):
-    return lambda opts, v=files: _extra_clean(opts, v);
+    return lambda name, opts, v=files: _extra_clean(name, opts, v);
 
-def _extra_clean( opts, v ):
+def _extra_clean( name, opts, v ):
     opts.clean_files = v
 
 # -----
 
 def stats_range_field( field, expected, dev ):
-    return lambda opts, f=field, x=expected, y=dev: _stats_range_field(opts, f, x, y);
+    return lambda name, opts, f=field, x=expected, y=dev: _stats_range_field(name, opts, f, x, y);
 
-def _stats_range_field( opts, f, x, y ):
+def _stats_range_field( name, opts, f, x, y ):
     opts.stats_range_fields[f] = (x, y)
 
 def compiler_stats_range_field( field, expected, dev ):
-    return lambda opts, f=field, x=expected, y=dev: _compiler_stats_range_field(opts, f, x, y);
+    return lambda name, opts, f=field, x=expected, y=dev: _compiler_stats_range_field(name, opts, f, x, y);
 
-def _compiler_stats_range_field( opts, f, x, y ):
+def _compiler_stats_range_field( name, opts, f, x, y ):
     opts.compiler_stats_range_fields[f] = (x, y)
 
 # -----
 
-def skip_if_no_ghci(opts):
+def skip_if_no_ghci(name, opts):
     if not ('ghci' in config.run_ways):
         opts.skip = 1
 
 # ----
 
-def skip_if_fast(opts):
+def skip_if_fast(name, opts):
     if config.fast:
         opts.skip = 1
 
@@ -487,89 +478,89 @@ def unless_tag( tag, f ):
         return normal
 
 # ---
-def high_memory_usage(opts):
+def high_memory_usage(name, opts):
     opts.alone = True
 
 # ---
-def literate( opts ):
+def literate( name, opts ):
     opts.literate = 1;
 
-def c_src( opts ):
+def c_src( name, opts ):
     opts.c_src = 1;
 
-def objc_src( opts ):
+def objc_src( name, opts ):
     opts.objc_src = 1;
 
-def objcpp_src( opts ):
+def objcpp_src( name, opts ):
     opts.objcpp_src = 1;
 
-def cmm_src( opts ):
+def cmm_src( name, opts ):
     opts.cmm_src = 1;
 
 def outputdir( odir ):
-    return lambda opts, d=odir: _outputdir(opts, d)
+    return lambda name, opts, d=odir: _outputdir(name, opts, d)
 
-def _outputdir( opts, odir ):
+def _outputdir( name, opts, odir ):
     opts.outputdir = odir;
 
 # ----
 
 def pre_cmd( cmd ):
-    return lambda opts, c=cmd: _pre_cmd(opts, cmd)
+    return lambda name, opts, c=cmd: _pre_cmd(name, opts, cmd)
 
-def _pre_cmd( opts, cmd ):
+def _pre_cmd( name, opts, cmd ):
     opts.pre_cmd = cmd
 
 # ----
 
 def clean_cmd( cmd ):
-    return lambda opts, c=cmd: _clean_cmd(opts, cmd)
+    return lambda name, opts, c=cmd: _clean_cmd(name, opts, cmd)
 
-def _clean_cmd( opts, cmd ):
+def _clean_cmd( name, opts, cmd ):
     opts.clean_cmd = cmd
 
 # ----
 
 def cmd_prefix( prefix ):
-    return lambda opts, p=prefix: _cmd_prefix(opts, prefix)
+    return lambda name, opts, p=prefix: _cmd_prefix(name, opts, prefix)
 
-def _cmd_prefix( opts, prefix ):
+def _cmd_prefix( name, opts, prefix ):
     opts.cmd_wrapper = lambda cmd, p=prefix: p + ' ' + cmd;
 
 # ----
 
 def cmd_wrapper( fun ):
-    return lambda opts, f=fun: _cmd_wrapper(opts, fun)
+    return lambda name, opts, f=fun: _cmd_wrapper(name, opts, fun)
 
-def _cmd_wrapper( opts, fun ):
+def _cmd_wrapper( name, opts, fun ):
     opts.cmd_wrapper = fun
 
 # ----
 
 def compile_cmd_prefix( prefix ):
-    return lambda opts, p=prefix: _compile_cmd_prefix(opts, prefix)
+    return lambda name, opts, p=prefix: _compile_cmd_prefix(name, opts, prefix)
 
-def _compile_cmd_prefix( opts, prefix ):
+def _compile_cmd_prefix( name, opts, prefix ):
     opts.compile_cmd_prefix = prefix
 
 # ----
 
-def normalise_slashes( opts ):
+def normalise_slashes( name, opts ):
     opts.extra_normaliser = normalise_slashes_
 
-def normalise_exe( opts ):
+def normalise_exe( name, opts ):
     opts.extra_normaliser = normalise_exe_
 
 def normalise_fun( fun ):
-    return lambda opts, f=fun: _normalise_fun(opts, f)
+    return lambda name, opts, f=fun: _normalise_fun(name, opts, f)
 
-def _normalise_fun( opts, f ):
+def _normalise_fun( name, opts, f ):
     opts.extra_normaliser = f
 
 def normalise_errmsg_fun( fun ):
-    return lambda opts, f=fun: _normalise_errmsg_fun(opts, f)
+    return lambda name, opts, f=fun: _normalise_errmsg_fun(name, opts, f)
 
-def _normalise_errmsg_fun( opts, f ):
+def _normalise_errmsg_fun( name, opts, f ):
     opts.extra_errmsg_normaliser = f
 
 def two_normalisers(f, g):
@@ -582,21 +573,23 @@ def composes( fs ):
     return reduce(lambda f, g: compose(f, g), fs)
 
 def compose( f, g ):
-    return lambda opts, f=f, g=g: _compose(opts,f,g)
+    return lambda name, opts, f=f, g=g: _compose(name, opts, f, g)
 
-def _compose( opts, f, g ):
-    f(opts)
-    g(opts)
+def _compose( name, opts, f, g ):
+    f(name, opts)
+    g(name, opts)
 
 # -----------------------------------------------------------------------------
 # The current directory of tests
 
 def newTestDir( dir ):
-    global thisdir_testopts
+    global thisdir_settings
     # reset the options for this test directory
-    thisdir_testopts = copy.copy(default_testopts)
-    thisdir_testopts.testdir = dir
-    thisdir_testopts.compiler_always_flags = config.compiler_always_flags
+    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
 
 # -----------------------------------------------------------------------------
 # Actually doing tests
@@ -629,18 +622,22 @@ def test (name, setup, func, args):
     global aloneTests
     global parallelTests
     global allTestNames
+    global thisdir_settings
     if name in allTestNames:
         framework_fail(name, 'duplicate', 'There are multiple tests with this name')
     if not re.match('^[0-9]*[a-zA-Z][a-zA-Z0-9._-]*$', name):
         framework_fail(name, 'bad_name', 'This test has an invalid name')
-    # We need a deepcopy so that dictionarys, such as the stats_range_fields
-    # dictionary, get copied too.
-    myTestOpts = copy.deepcopy(thisdir_testopts)
+
+    # 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)
 
     if type(setup) is types.ListType:
        setup = composes(setup)
 
-    setup(myTestOpts)
+    setup = compose(thisdir_settings, setup)
+    setup(name, myTestOpts)
 
     thisTest = lambda : runTest(myTestOpts, name, func, args)
     if myTestOpts.alone:
diff --git a/testsuite/tests/concurrent/should_run/all.T b/testsuite/tests/concurrent/should_run/all.T
index ec867ed4d3..97dc4b13a1 100644
--- a/testsuite/tests/concurrent/should_run/all.T
+++ b/testsuite/tests/concurrent/should_run/all.T
@@ -77,7 +77,7 @@ test('T5866', exit_code(1), compile_and_run, [''])
 # -----------------------------------------------------------------------------
 # These tests we only do for a full run
 
-def f( opts ):
+def f( name, opts ):
   if config.fast:
   	opts.skip = 1
 
diff --git a/testsuite/tests/cpranal/should_compile/all.T b/testsuite/tests/cpranal/should_compile/all.T
index 99ffed997f..2ec0a84e9a 100644
--- a/testsuite/tests/cpranal/should_compile/all.T
+++ b/testsuite/tests/cpranal/should_compile/all.T
@@ -1,5 +1,5 @@
 # Just do the opt way...
-def f( opts ):
+def f( name, opts ):
   opts.only_ways = ['optasm']
 
 setTestOpts(f)
diff --git a/testsuite/tests/deSugar/should_compile/all.T b/testsuite/tests/deSugar/should_compile/all.T
index b932a49a0e..979b1e7640 100644
--- a/testsuite/tests/deSugar/should_compile/all.T
+++ b/testsuite/tests/deSugar/should_compile/all.T
@@ -1,5 +1,5 @@
 # Just do the normal way...
-def f( opts ):
+def f( name, opts ):
   opts.only_ways = ['normal']
 
 setTestOpts(f)
diff --git a/testsuite/tests/ffi/should_compile/all.T b/testsuite/tests/ffi/should_compile/all.T
index 99c5eef8f4..a192a7b0cc 100644
--- a/testsuite/tests/ffi/should_compile/all.T
+++ b/testsuite/tests/ffi/should_compile/all.T
@@ -1,5 +1,5 @@
 
-def ffi( opts ):
+def ffi( name, opts ):
   opts.extra_hc_opts = '-XForeignFunctionInterface -optc-Wno-implicit'
 
 setTestOpts(ffi)
diff --git a/testsuite/tests/ghci/prog004/prog004.T b/testsuite/tests/ghci/prog004/prog004.T
index a67ebf35c8..ed17afd088 100644
--- a/testsuite/tests/ghci/prog004/prog004.T
+++ b/testsuite/tests/ghci/prog004/prog004.T
@@ -1,6 +1,6 @@
 setTestOpts(only_compiler_types(['ghc']))
 
-def f(opts):
+def f(name, opts):
   if not ('ghci' in config.run_ways):
 	opts.skip = 1
 setTestOpts(f)
diff --git a/testsuite/tests/ghci/should_run/all.T b/testsuite/tests/ghci/should_run/all.T
index d34eade39b..a2552f6f93 100644
--- a/testsuite/tests/ghci/should_run/all.T
+++ b/testsuite/tests/ghci/should_run/all.T
@@ -2,7 +2,7 @@
 setTestOpts(if_compiler_profiled(skip))
 
 # We only want to run these tests with GHCi
-def just_ghci( opts ):
+def just_ghci( name, opts ):
   opts.only_ways = ['ghci']
 
 test('ghcirun001', just_ghci, compile_and_run, [''])
diff --git a/testsuite/tests/llvm/should_compile/all.T b/testsuite/tests/llvm/should_compile/all.T
index 16a91e0acb..448e8e0097 100644
--- a/testsuite/tests/llvm/should_compile/all.T
+++ b/testsuite/tests/llvm/should_compile/all.T
@@ -1,6 +1,6 @@
 # Tests for LLVM code generator
 
-def f( opts ):
+def f( name, opts ):
   opts.only_ways = ['optllvm', 'llvm', 'debugllvm']
 
 setTestOpts(f)
diff --git a/testsuite/tests/perf/compiler/all.T b/testsuite/tests/perf/compiler/all.T
index 24fb98c25e..09a02975a2 100644
--- a/testsuite/tests/perf/compiler/all.T
+++ b/testsuite/tests/perf/compiler/all.T
@@ -1,4 +1,4 @@
-def no_lint(opts):
+def no_lint(name, opts):
    opts.compiler_always_flags = \
        filter(lambda opt: opt != '-dcore-lint' and opt != '-dcmm-lint', opts.compiler_always_flags)
 
diff --git a/testsuite/tests/plugins/all.T b/testsuite/tests/plugins/all.T
index 68225aed7b..2f0fc44c9b 100644
--- a/testsuite/tests/plugins/all.T
+++ b/testsuite/tests/plugins/all.T
@@ -1,4 +1,4 @@
-def f(opts):
+def f(name, opts):
   if (ghc_with_interpreter == 0):
 	opts.skip = 1
 
diff --git a/testsuite/tests/programs/okeefe_neural/test.T b/testsuite/tests/programs/okeefe_neural/test.T
index cf329cf716..326dd6b0f0 100644
--- a/testsuite/tests/programs/okeefe_neural/test.T
+++ b/testsuite/tests/programs/okeefe_neural/test.T
@@ -1,7 +1,7 @@
 
 # this one causes the compiler to run out of heap in the simplifier
 
-def set_opts( opts ):
+def set_opts( name, opts ):
   opts.expect = 'fail'
 
 test('okeefe_neural',
diff --git a/testsuite/tests/rts/all.T b/testsuite/tests/rts/all.T
index 2c0ae61800..05510e9ad1 100644
--- a/testsuite/tests/rts/all.T
+++ b/testsuite/tests/rts/all.T
@@ -115,7 +115,7 @@ test('return_mem_to_os', normal, compile_and_run, [''])
 
 test('T4850', normal, run_command, ['$MAKE -s --no-print-directory T4850'])
 
-def config_T5250(opts):
+def config_T5250(name, opts):
     if not (config.arch in ['i386','x86_64']):
         opts.skip = 1;
 
diff --git a/testsuite/tests/safeHaskell/check/all.T b/testsuite/tests/safeHaskell/check/all.T
index ca6ba0f372..59ab4fdb97 100644
--- a/testsuite/tests/safeHaskell/check/all.T
+++ b/testsuite/tests/safeHaskell/check/all.T
@@ -2,7 +2,7 @@
 # check of safe haskell is working properly.
 
 # Just do the normal way, SafeHaskell is all in the frontend
-def f( opts ):
+def f( name, opts ):
   opts.only_ways = ['normal']
 
 setTestOpts(f)
diff --git a/testsuite/tests/safeHaskell/check/pkg01/all.T b/testsuite/tests/safeHaskell/check/pkg01/all.T
index 16f6ba6f7c..08f0b61820 100644
--- a/testsuite/tests/safeHaskell/check/pkg01/all.T
+++ b/testsuite/tests/safeHaskell/check/pkg01/all.T
@@ -1,5 +1,5 @@
 # Just do the normal way, SafeHaskell is all in the frontend
-def f( opts ):
+def f( name, opts ):
   opts.only_ways = ['normal']
 
 def normaliseArrayPackage(str):
diff --git a/testsuite/tests/safeHaskell/flags/all.T b/testsuite/tests/safeHaskell/flags/all.T
index 713439567d..fff8841797 100644
--- a/testsuite/tests/safeHaskell/flags/all.T
+++ b/testsuite/tests/safeHaskell/flags/all.T
@@ -4,7 +4,7 @@
 # has been dropped.
 
 # Just do the normal way, SafeHaskell is all in the frontend
-def f( opts ):
+def f( name, opts ):
   opts.only_ways = ['normal']
 
 setTestOpts(f)
diff --git a/testsuite/tests/safeHaskell/safeInfered/all.T b/testsuite/tests/safeHaskell/safeInfered/all.T
index dee056a614..47e9656279 100644
--- a/testsuite/tests/safeHaskell/safeInfered/all.T
+++ b/testsuite/tests/safeHaskell/safeInfered/all.T
@@ -2,7 +2,7 @@
 # mode safe inference works correctly.
 
 # Just do the normal way, SafeHaskell is all in the frontend
-def f( opts ):
+def f( name, opts ):
   opts.only_ways = ['normal']
 
 setTestOpts(f)
diff --git a/testsuite/tests/safeHaskell/safeLanguage/all.T b/testsuite/tests/safeHaskell/safeLanguage/all.T
index 506b45d432..f8479b12c3 100644
--- a/testsuite/tests/safeHaskell/safeLanguage/all.T
+++ b/testsuite/tests/safeHaskell/safeLanguage/all.T
@@ -4,7 +4,7 @@
 # works correctly (incluidng testing safe imports a little).
 
 # Just do the normal way, SafeHaskell is all in the frontend
-def f( opts ):
+def f( name, opts ):
   opts.only_ways = ['normal']
 
 setTestOpts(f)
diff --git a/testsuite/tests/safeHaskell/unsafeLibs/all.T b/testsuite/tests/safeHaskell/unsafeLibs/all.T
index eddf9566cf..69d1804b02 100644
--- a/testsuite/tests/safeHaskell/unsafeLibs/all.T
+++ b/testsuite/tests/safeHaskell/unsafeLibs/all.T
@@ -4,7 +4,7 @@
 # Checking base package is properly safe basically
 
 # Just do the normal way, SafeHaskell is all in the frontend
-def f( opts ):
+def f( name, opts ):
   opts.only_ways = ['normal']
 
 setTestOpts(f)
diff --git a/testsuite/tests/simplCore/should_run/all.T b/testsuite/tests/simplCore/should_run/all.T
index 40c553fe8c..545dadbf6e 100644
--- a/testsuite/tests/simplCore/should_run/all.T
+++ b/testsuite/tests/simplCore/should_run/all.T
@@ -4,7 +4,7 @@
 #	expected process return value, if not zero
 
 # Only compile with optimisation
-def f( opts ):
+def f( name, opts ):
   opts.only_ways = ['optasm']
 
 setTestOpts(f)
diff --git a/testsuite/tests/th/TH_spliceViewPat/test.T b/testsuite/tests/th/TH_spliceViewPat/test.T
index c93e1cb3a7..b177c075b3 100644
--- a/testsuite/tests/th/TH_spliceViewPat/test.T
+++ b/testsuite/tests/th/TH_spliceViewPat/test.T
@@ -1,4 +1,4 @@
-def f(opts):
+def f(name, opts):
   opts.extra_hc_opts = '-XTemplateHaskell -package template-haskell'
   if (ghc_with_interpreter == 0):
 	opts.skip = 1
diff --git a/testsuite/tests/th/all.T b/testsuite/tests/th/all.T
index 2d190dd5c7..e9c6c08cd1 100644
--- a/testsuite/tests/th/all.T
+++ b/testsuite/tests/th/all.T
@@ -3,7 +3,7 @@
 # to run it !if_compiler_profiled
 test('T4255', unless_compiler_profiled(skip), compile_fail, ['-v0'])
 
-def f(opts):
+def f(name, opts):
   opts.extra_hc_opts = '-XTemplateHaskell -package template-haskell'
   if (ghc_with_interpreter == 0):
 	opts.skip = 1
diff --git a/testsuite/tests/typecheck/should_compile/all.T b/testsuite/tests/typecheck/should_compile/all.T
index 94ebf41fd1..da91233691 100644
--- a/testsuite/tests/typecheck/should_compile/all.T
+++ b/testsuite/tests/typecheck/should_compile/all.T
@@ -1,6 +1,6 @@
 # Args to vtc are: extra compile flags
 
-def f( opts ):
+def f( name, opts ):
   opts.extra_hc_opts = '-fno-warn-incomplete-patterns'
 
 setTestOpts(f)
diff --git a/testsuite/tests/typecheck/should_run/all.T b/testsuite/tests/typecheck/should_run/all.T
index 4c9d7abffb..083088c3e2 100755
--- a/testsuite/tests/typecheck/should_run/all.T
+++ b/testsuite/tests/typecheck/should_run/all.T
@@ -16,7 +16,7 @@ test('Defer01', normal, compile_and_run, [''])
 # -----------------------------------------------------------------------------
 # Skip everything else if fast is on
 
-def f(opts):
+def f(name, opts):
   if config.fast:
 	opts.skip = 1
 setTestOpts(f)