testglobals.py 7.03 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 
# (c) Simon Marlow 2002
#

# -----------------------------------------------------------------------------
# Configuration info

# There is a single global instance of this structure, stored in the
# variable config below.  The fields of the structure are filled in by
# the appropriate config script(s) for this compiler/platform, in
# ../config.
# 
# Bits of the structure may also be filled in from the command line,
# via the build system, using the '-e' option to runtests.

class TestConfig:
    def __init__(self):

19
20
21
        # Where the testsuite root is
        self.top = ''

22
23
        # Directories below which to look for test description files (foo.T)
        self.rootdirs = []
24
25
26
27
28
29
30
31
32
33

        # Run these tests only (run all tests if empty)
        self.only = []

        # Accept new output which differs from the sample?
        self.accept = 0

        # File in which to save the summary
        self.output_summary = ''

34
35
36
        # File in which to save the times
        self.times_file = ''

37
38
        # What platform are we running on?
        self.platform = ''
39
        self.os = ''
40
        self.arch = ''
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

        # What is the wordsize (in bits) of this platform?
        self.wordsize = ''

        # Verbosity level
        self.verbose = 1

        # run the "fast" version of the test suite
        self.fast = 0

        # Compiler type (ghc, hugs, nhc, etc.)
        self.compiler_type = ''

        # Path to the compiler
        self.compiler = ''
56
57
        # and ghc-pkg
        self.ghc_pkg = ''
58

59
60
        # Compiler version info
        self.compiler_version = ''
61
        self.compiler_maj_version = ''
62
63
        self.compiler_tags = []

64
65
66
67
68
69
70
71
        # Flags we always give to this compiler
        self.compiler_always_flags = []
        
        # Which ways to run tests (when compiling and running respectively)
        # Other ways are added from the command line if we have the appropriate
        # libraries.
        self.compile_ways = []
        self.run_ways     = []
72
73
74
75
        self.other_ways   = []

        # The ways selected via the command line.
        self.cmdline_ways = []
76
77
78
79
80

        # Lists of flags for each way
        self.way_flags = {}
        self.way_rts_flags = {}

81
82
83
        # Do we have vanilla libraries?
        self.have_vanilla = False

84
85
86
        # Do we have dynamic libraries?
        self.have_dynamic = False

87
88
89
        # Do we have profiling support?
        self.have_profiling = False

Ian Lynagh's avatar
Ian Lynagh committed
90
91
92
        # Do we have interpreter support?
        self.have_interp = False

Simon Marlow's avatar
Simon Marlow committed
93
94
95
        # Do we have shared libraries?
        self.have_shared_libs = False

Simon Marlow's avatar
Simon Marlow committed
96
97
98
        # Do we have SMP support?
        self.have_smp = False

99
100
101
        # Are we testing an in-tree compiler?
        self.in_tree_compiler = True

102
103
104
105
106
107
        # the timeout program
        self.timeout_prog = ''
        self.timeout = 300
        
        # threads
        self.threads = 1
108
        self.use_threads = 0
109

110
111
112
        # Should we check for files being written more than once?
        self.check_files_written = False

113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
global config
config = TestConfig()

def getConfig():
    return config

# -----------------------------------------------------------------------------
# Information about the current test run

class TestRun:
   def __init__(self):
       self.start_time = ''
       self.total_tests = 0
       self.total_test_cases = 0
       self.n_framework_failures = 0
       self.framework_failures = {}
       self.n_tests_skipped = 0
       self.tests_skipped = {}
       self.n_expected_passes = 0
       self.expected_passes = {}
       self.n_expected_failures = 0
       self.expected_failures = {}
135
136
       self.n_missing_libs = 0
       self.missing_libs = {}
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
       self.n_unexpected_passes = 0
       self.unexpected_passes = {}
       self.n_unexpected_failures = 0
       self.unexpected_failures = {}
       
global t
t = TestRun()

def getTestRun():
    return t

# -----------------------------------------------------------------------------
# Information about the current test

class TestOptions:
   def __init__(self):
153
154
       # if not None then we look for namebase.stderr etc rather than
       # using the test name
155
       self.with_namebase = None
156

157
       # skip this test?
158
       self.skip = 0
159
160
161
162

       # skip these ways
       self.omit_ways = []

163
164
       # skip all ways except these (None == do all ways)
       self.only_ways = None
165

166
167
168
       # add these ways to the default set
       self.extra_ways = []

169
       # the result we normally expect for this test
170
       self.expect = 'pass'
171
172

       # override the expected result for certain ways
173
       self.expect_fail_for = []
174
175
176
177

       # the stdin file that this test will use (empty for <name>.stdin)
       self.stdin = ''

178
179
180
       # don't compare output
       self.ignore_output = 0

181
182
183
       # don't give anything as stdin
       self.no_stdin = 0

184
185
186
       # compile this test to .hc only
       self.compile_to_hc = 0

187
188
189
190
191
       # We sometimes want to modify the compiler_always_flags, so
       # they are copied from config.compiler_always_flags when we
       # make a new instance of TestOptions.
       self.compiler_always_flags = []

192
193
194
195
196
197
198
199
200
201
202
203
       # extra compiler opts for this test
       self.extra_hc_opts = ''

       # extra run opts for this test
       self.extra_run_opts = ''

       # expected exit code
       self.exit_code = 0

       # should we clean up after ourselves?
       self.cleanup = ''

204
205
206
       # extra files to clean afterward
       self.clean_files = []

207
208
209
210
211
212
213
214
215
216
       # which -t numeric fields do we want to look at, and what bounds must
       # they fall within?
       # Elements of these lists should be things like
       # ('bytes allocated',
       #   9300000000,
       #   10)
       # To allow a 10% deviation from 9300000000.
       self.compiler_stats_range_fields = {}
       self.stats_range_fields = {}

217
218
       # should we run this test alone, i.e. not run it in parallel with
       # any other threads
219
       self.alone = False
220

Ian Lynagh's avatar
Ian Lynagh committed
221
222
223
       # Does this test use a literate (.lhs) file?
       self.literate = 0

224
225
226
227
       # Does this test use a .c, .m or .mm file?
       self.c_src      = 0
       self.objc_src   = 0
       self.objcpp_src = 0
228

229
230
231
       # Does this test use a .cmm file?
       self.cmm_src    = 0

232
233
234
       # Should we put .hi/.o files in a subdirectory?
       self.outputdir = None

235
236
237
       # Command to run before the test
       self.pre_cmd = None

238
239
240
       # Command to run for extra cleaning
       self.clean_cmd = None

241
242
       # Command wrapper: a function to apply to the command before running it
       self.cmd_wrapper = None
243

Ian Lynagh's avatar
Ian Lynagh committed
244
245
246
       # Prefix to put on the command before compiling it
       self.compile_cmd_prefix = ''

247
248
249
       # Extra output normalisation
       self.extra_normaliser = lambda x: x

250
251
252
       # Extra normalisation for compiler error messages
       self.extra_errmsg_normaliser = lambda x: x

253
254
255
       # The directory the test is in
       self.testdir = '.'

pcapriotti's avatar
pcapriotti committed
256
257
258
       # Should we redirect stdout and stderr to a single file?
       self.combined_output = False

259
260
261
       # How should the timeout be adjusted on this test?
       self.timeout_multiplier = 1.0

262
263
264
265
# The default set of options
global default_testopts
default_testopts = TestOptions()