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