OSDN Git Service

gotest: Add external timeout if internal timeout fails.
[pf3gnuchains/gcc-fork.git] / libgo / testsuite / gotest
1 #!/bin/sh
2 # Copyright 2009 The Go Authors. All rights reserved.
3 # Use of this source code is governed by a BSD-style
4 # license that can be found in the LICENSE file.
5
6 # Using all the *_test.go files in the current directory, write out a file
7 # _testmain.go that runs all its tests. Compile everything and run the
8 # tests.
9 # If files are named on the command line, use them instead of *_test.go.
10
11 # Makes egrep,grep work better in general if we put them
12 # in ordinary C mode instead of what the current language is.
13 unset LANG
14 export LC_ALL=C
15 export LC_CTYPE=C
16
17 GC=${GC:-gccgo}
18 GL=${GL:-${GC-gccgo}}
19 GOLIBS=
20 export GC GL GOLIBS
21
22 NM=${NM:-nm}
23
24 # srcdir is where the source files are found.  basedir is where the
25 # source file paths are relative to.
26 # gofiles are the test files.  pkgfiles are the source files.
27 srcdir=.
28 basedir=.
29 gofiles=""
30 pkgfiles=""
31 loop=true
32 keep=false
33 prefix=
34 dejagnu=no
35 timeout=60
36 testname=""
37 while $loop; do
38         case "x$1" in
39         x--srcdir)
40                 srcdir=$2
41                 shift
42                 shift
43                 ;;
44         x--srcdir=*)
45                 srcdir=`echo $1 | sed -e 's/^--srcdir=//'`
46                 shift
47                 ;;
48         x--basedir)
49                 basedir=$2
50                 shift
51                 shift
52                 ;;
53         x--basedir=*)
54                 basedir=`echo $1 | sed -e 's/^--basedir=//'`
55                 shift
56                 ;;
57         x--prefix)
58                 prefix=$2
59                 shift
60                 shift
61                 ;;
62         x--prefix=*)
63                 prefix=`echo $1 | sed -e 's/^--prefix=//'`
64                 shift
65                 ;;
66         x--keep)
67                 keep=true
68                 shift
69                 ;;
70         x--pkgfiles)
71                 pkgfiles=$2
72                 shift
73                 shift
74                 ;;
75         x--pkgfiles=*)
76                 pkgfiles=`echo $1 | sed -e 's/^--pkgfiles=//'`
77                 shift
78                 ;;
79         x--dejagnu)
80                 dejagnu=$2
81                 shift
82                 shift
83                 ;;
84         x--dejagnu=*)
85                 dejagnu=`echo $1 | sed -e 's/^--dejagnu=//'`
86                 shift
87                 ;;
88         x--timeout)
89                 timeout=$2
90                 shift
91                 shift
92                 ;;
93         x--timeout=*)
94                 timeout=`echo $1 | sed -e 's/^--timeout=//'`
95                 shift
96                 ;;
97         x--testname)
98                 testname=$2
99                 shift
100                 shift
101                 ;;
102         x--testname=*)
103                 testname=`echo $1 | sed -e 's/^--testname=//'`
104                 shift
105                 ;;
106         x-*)
107                 loop=false
108                 ;;
109         x)
110                 loop=false
111                 ;;
112         *)
113                 gofiles="$gofiles $1"
114                 shift
115                 ;;
116         esac
117 done
118
119 DIR=gotest$$
120 rm -rf $DIR
121 mkdir $DIR
122
123 cd $DIR
124
125 if test $keep = false; then
126   trap "cd ..; rm -rf $DIR" 0 1 2 3 14 15
127 else
128   trap "cd ..; echo Keeping $DIR" 0 1 2 3 14 15
129 fi
130
131 case "$srcdir" in
132         /*)
133                 ;;
134         *)
135                 srcdir="../$srcdir"
136                 ;;
137 esac
138
139 SRCDIR=$srcdir
140 export SRCDIR
141
142 case "$basedir" in
143         /*)
144                 ;;
145         *)
146                 basedir="../$basedir"
147                 ;;
148 esac
149
150 # Link all the files/directories in srcdir into our working directory,
151 # so that the tests do not have to refer to srcdir to find test data.
152 ln -s $srcdir/* .
153
154 # Some tests refer to a ../testdata directory.
155 if test -e $srcdir/../testdata; then
156   rm -f ../testdata
157   abssrcdir=`cd $srcdir && pwd`
158   ln -s $abssrcdir/../testdata ../testdata
159 fi
160
161 # Copy the .go files because io/utils_test.go expects a regular file.
162 case "x$gofiles" in
163 x)
164         case "x$pkgfiles" in
165         x)
166                 for f in `cd $srcdir; ls *.go`; do
167                     rm -f $f;
168                     cp $srcdir/$f .
169                 done
170                 ;;
171         *)
172                 for f in $pkgfiles; do
173                     if test -f $basedir/$f; then
174                         b=`basename $f`
175                         rm -f $b
176                         cp $basedir/$f $b
177                     elif test -f ../$f; then
178                         b=`basename $f`
179                         rm -f $b
180                         cp ../$f $b
181                     else
182                         echo "file $f not found" 1>&2
183                         exit 1
184                     fi
185                 done
186                 for f in `cd $srcdir; ls *_test.go`; do
187                     rm -f $f
188                     cp $srcdir/$f .
189                 done
190                 ;;
191         esac
192         ;;
193 *)
194         for f in $gofiles; do
195             b=`basename $f`
196             rm -f $b
197             cp $basedir/$f $b
198         done
199         case "x$pkgfiles" in
200         x)
201                 for f in `cd $srcdir; ls *.go | grep -v *_test.go`; do
202                     rm -f $f
203                     cp $srcdir/$f .
204                 done
205                 ;;
206         *)
207                 for f in $pkgfiles; do
208                     if test -f $basedir/$f; then
209                         b=`basename $f`
210                         rm -f $b
211                         cp $basedir/$f $b
212                     elif test -f ../$f; then
213                         b=`basename $f`
214                         rm -f $b
215                         cp ../$f $b
216                     else
217                         echo "file $f not found" 1>&2
218                         exit 1
219                     fi
220                 done
221                 ;;
222         esac
223         ;;
224 esac
225
226 # Some tests expect the _obj directory created by the gc Makefiles.
227 mkdir _obj
228
229 # Some tests expect the _test directory created by the gc Makefiles.
230 mkdir _test
231
232 case "x$gofiles" in
233 x)
234         gofiles=`ls *_test.go 2>/dev/null`
235 esac
236
237 case "x$gofiles" in
238 x)
239         echo 'no test files found' 1>&2
240         exit 1
241 esac
242
243 # Run any commands given in sources, like
244 #   // gotest: $GC foo.go
245 # to build any test-only dependencies.
246 holdGC="$GC"
247 GC="$GC -g -c -I ."
248 sed -n 's/^\/\/ gotest: //p' $gofiles | sh
249 GC="$holdGC"
250
251 case "x$pkgfiles" in
252 x)
253         pkgbasefiles=`ls *.go | grep -v _test.go 2>/dev/null`
254         ;;
255 *)
256         for f in $pkgfiles; do
257             pkgbasefiles="$pkgbasefiles `basename $f`"
258         done
259         ;;
260 esac
261
262 case "x$pkgfiles" in
263 x)
264         echo 'no source files found' 1>&2
265         exit 1
266         ;;
267 esac
268
269 # Split $gofiles into external gofiles (those in *_test packages)
270 # and internal ones (those in the main package).
271 xgofiles=$(echo $(grep '^package[       ]' $gofiles /dev/null | grep ':.*_test' | sed 's/:.*//'))
272 gofiles=$(echo $(grep '^package[        ]' $gofiles /dev/null | grep -v ':.*_test' | sed 's/:.*//'))
273
274 # External $O file
275 xofile=""
276 havex=false
277 if [ "x$xgofiles" != "x" ]; then
278         xofile="_xtest_.o"
279         havex=true
280 fi
281
282 set -e
283
284 package=`echo ${srcdir} | sed -e 's|^.*libgo/go/||'`
285
286 prefixarg=
287 if test -n "$prefix"; then
288         prefixarg="-fgo-prefix=$prefix"
289 fi
290
291 $GC -g $prefixarg -c -I . -o _gotest_.o $gofiles $pkgbasefiles
292 if $havex; then
293         mkdir -p `dirname $package`
294         cp _gotest_.o `dirname $package`/lib`basename $package`.a
295         $GC -g -c -I . -o $xofile $xgofiles
296 fi
297
298 # They all compile; now generate the code to call them.
299
300 localname() {
301         # The package main has been renamed to __main__ when imported.
302         # Adjust its uses.
303         echo $1 | sed 's/^main\./__main__./'
304 }
305
306 {
307         # test functions are named TestFoo
308         # the grep -v eliminates methods and other special names
309         # that have multiple dots.
310         pattern='Test([^a-z].*)?'
311         # The -p option tells GNU nm not to sort.
312         # The -v option tells Solaris nm to sort by value.
313         tests=$($NM -p -v _gotest_.o $xofile | egrep ' T .*\.'$pattern'$' | grep -v '\..*\..*\.' | sed 's/.* //' | sed 's/.*\.\(.*\.\)/\1/')
314         if [ "x$tests" = x ]; then
315                 echo 'gotest: warning: no tests matching '$pattern in _gotest_.o $xofile 1>&2
316                 exit 2
317         fi
318         # benchmarks are named BenchmarkFoo.
319         pattern='Benchmark([^a-z].*)?'
320         benchmarks=$($NM -p -v _gotest_.o $xofile | egrep ' T .*\.'$pattern'$' | grep -v '\..*\..*\.' | sed 's/.* //' | sed 's/.*\.\(.*\.\)/\1/')
321
322         # package spec
323         echo 'package main'
324         echo
325         # imports
326         if echo "$tests" | egrep -v '_test\.' >/dev/null; then
327                 echo 'import "./_gotest_"'
328         fi
329         if $havex; then
330                 echo 'import "./_xtest_"'
331         fi
332         echo 'import "testing"'
333         echo 'import __os__     "os"' # rename in case tested package is called os
334         echo 'import __regexp__ "regexp"' # rename in case tested package is called regexp
335         # test array
336         echo
337         echo 'var tests = []testing.InternalTest {'
338         for i in $tests
339         do
340                 j=$(localname $i)
341                 echo '  {"'$i'", '$j'},'
342         done
343         echo '}'
344         # benchmark array
345         # The comment makes the multiline declaration
346         # gofmt-safe even when there are no benchmarks.
347         echo 'var benchmarks = []testing.InternalBenchmark{ //'
348         for i in $benchmarks
349         do
350                 j=$(localname $i)
351                 echo '  {"'$i'", '$j'},'
352         done
353         echo '}'
354         # body
355         echo \
356 '
357 var matchPat string
358 var matchRe *__regexp__.Regexp
359
360 func matchString(pat, str string) (result bool, err __os__.Error) {
361         if matchRe == nil || matchPat != pat {
362                 matchPat = pat
363                 matchRe, err = __regexp__.Compile(matchPat)
364                 if err != nil {
365                         return
366                 }
367         }
368         return matchRe.MatchString(str), nil
369 }
370
371 func main() {
372         testing.Main(matchString, tests, benchmarks)
373 }'
374 }>_testmain.go
375
376 case "x$dejagnu" in
377 xno)
378         ${GC} -g -c _testmain.go
379         ${GL} *.o ${GOLIBS}
380
381         ./a.out -test.short -test.timeout=$timeout "$@" &
382         pid=$!
383         (sleep `expr $timeout + 10`
384             echo > gotest-timeout
385             echo "timed out in gotest" 1>&2
386             kill -9 $pid) &
387         alarmpid=$!
388         wait $pid
389         status=$?
390         if ! test -f gotest-timeout; then
391             kill $alarmpid
392         fi
393         exit $status
394         ;;
395 xyes)
396         rm -rf ../testsuite/*.o
397         files=`echo *`
398         for f in $files; do
399                 if test "$f" = "_obj" || test "$f" = "_test"; then
400                         continue
401                 fi
402                 rm -rf ../testsuite/$f
403                 if test -f $f; then
404                         cp $f ../testsuite/
405                 else
406                         ln -s ../$DIR/$f ../testsuite/
407                 fi
408         done
409         cd ../testsuite
410         rm -rf _obj _test
411         mkdir _obj _test
412         if test "$testname" != ""; then
413             GOTESTNAME="$testname"
414             export GOTESTNAME
415         fi
416         $MAKE check RUNTESTFLAGS="$RUNTESTFLAGS GOTEST_TMPDIR=$DIR"
417         # Useful when using make check-target-libgo
418         cat libgo.log >> libgo-all.log
419         cat libgo.sum >> libgo-all.sum
420         rm -rf $files
421         ;;
422 esac