OSDN Git Service

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