Subversion Repositories openrisc

#!/bin/sh
# Copyright 2009 The Go Authors. All rights reserved.
# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file.

# Using all the *_test.go files in the current directory, write out a file
# _testmain.go that runs all its tests. Compile everything and run the
# tests.
# If files are named on the command line, use them instead of *_test.go.

# Makes egrep,grep work better in general if we put them
# in ordinary C mode instead of what the current language is.
unset LANG
export LC_ALL=C
export LC_CTYPE=C

GC=${GC:-gccgo}
GL=${GL:-${GC-gccgo}}
GOLIBS=${GOLIBS:-}
export GC GL GOLIBS

NM=${NM:-nm}

# srcdir is where the source files are found.  basedir is where the
# source file paths are relative to.
# gofiles are the test files.  pkgfiles are the source files.
srcdir=.
basedir=.
gofiles=""
pkgfiles=""
loop=true
keep=false
prefix=
dejagnu=no
timeout=240
testname=""
trace=false
while $loop; do
        case "x$1" in
        x--srcdir)
                srcdir=$2
                shift
                shift
                ;;
        x--srcdir=*)
                srcdir=`echo $1 | sed -e 's/^--srcdir=//'`
                shift
                ;;
        x--basedir)
                basedir=$2
                shift
                shift
                ;;
        x--basedir=*)
                basedir=`echo $1 | sed -e 's/^--basedir=//'`
                shift
                ;;
        x--prefix)
                prefix=$2
                shift
                shift
                ;;
        x--prefix=*)
                prefix=`echo $1 | sed -e 's/^--prefix=//'`
                shift
                ;;
        x--keep)
                keep=true
                shift
                ;;
        x--pkgfiles)
                pkgfiles=$2
                shift
                shift
                ;;
        x--pkgfiles=*)
                pkgfiles=`echo $1 | sed -e 's/^--pkgfiles=//'`
                shift
                ;;
        x--dejagnu)
                dejagnu=$2
                shift
                shift
                ;;
        x--dejagnu=*)
                dejagnu=`echo $1 | sed -e 's/^--dejagnu=//'`
                shift
                ;;
        x--timeout)
                timeout=$2
                shift
                shift
                ;;
        x--timeout=*)
                timeout=`echo $1 | sed -e 's/^--timeout=//'`
                shift
                ;;
        x--testname)
                testname=$2
                shift
                shift
                ;;
        x--testname=*)
                testname=`echo $1 | sed -e 's/^--testname=//'`
                shift
                ;;
        x--trace)
                trace=true
                shift
                ;;
        x-*)
                loop=false
                ;;
        x)
                loop=false
                ;;
        *)
                gofiles="$gofiles $1"
                shift
                ;;
        esac
done

DIR=gotest$$
rm -rf $DIR
mkdir $DIR

cd $DIR

if test $keep = false; then
  trap "cd ..; rm -rf $DIR" 0 1 2 3 14 15
else
  trap "cd ..; echo Keeping $DIR" 0 1 2 3 14 15
fi

case "$srcdir" in
        /*)
                ;;
        *)
                srcdir="../$srcdir"
                ;;
esac

SRCDIR=$srcdir
export SRCDIR

case "$basedir" in
        /*)
                ;;
        *)
                basedir="../$basedir"
                ;;
esac

# Link all the files/directories in srcdir into our working directory,
# so that the tests do not have to refer to srcdir to find test data.
ln -s $srcdir/* .

# Some tests refer to a ../testdata directory.
if test -e $srcdir/../testdata; then
  rm -f ../testdata
  abssrcdir=`cd $srcdir && pwd`
  ln -s $abssrcdir/../testdata ../testdata
fi

# Copy the .go files because io/utils_test.go expects a regular file.
case "x$gofiles" in
x)
        case "x$pkgfiles" in
        x)
                for f in `cd $srcdir; ls *.go`; do
                    rm -f $f;
                    cp $srcdir/$f .
                done
                ;;
        *)
                for f in $pkgfiles; do
                    if test -f $basedir/$f; then
                        b=`basename $f`
                        rm -f $b
                        cp $basedir/$f $b
                    elif test -f ../$f; then
                        b=`basename $f`
                        rm -f $b
                        cp ../$f $b
                    else
                        echo "file $f not found" 1>&2
                        exit 1
                    fi
                done
                for f in `cd $srcdir; ls *_test.go`; do
                    rm -f $f
                    cp $srcdir/$f .
                done
                ;;
        esac
        ;;
*)
        for f in $gofiles; do
            b=`basename $f`
            rm -f $b
            cp $basedir/$f $b
        done
        case "x$pkgfiles" in
        x)
                for f in `cd $srcdir; ls *.go | grep -v *_test.go`; do
                    rm -f $f
                    cp $srcdir/$f .
                done
                ;;
        *)
                for f in $pkgfiles; do
                    if test -f $basedir/$f; then
                        b=`basename $f`
                        rm -f $b
                        cp $basedir/$f $b
                    elif test -f ../$f; then
                        b=`basename $f`
                        rm -f $b
                        cp ../$f $b
                    else
                        echo "file $f not found" 1>&2
                        exit 1
                    fi
                done
                ;;
        esac
        ;;
esac

# Some tests expect the _obj directory created by the gc Makefiles.
mkdir _obj

# Some tests expect the _test directory created by the gc Makefiles.
mkdir _test

case "x$gofiles" in
x)
        gofiles=`ls *_test.go 2>/dev/null`
esac

case "x$gofiles" in
x)
        echo 'no test files found' 1>&2
        exit 1
esac

# Run any commands given in sources, like
#   // gotest: $GC foo.go
# to build any test-only dependencies.
holdGC="$GC"
GC="$GC -g -c -I ."
sed -n 's/^\/\/ gotest: //p' $gofiles | sh
GC="$holdGC"

case "x$pkgfiles" in
x)
        pkgbasefiles=`ls *.go | grep -v _test.go 2>/dev/null`
        ;;
*)
        for f in $pkgfiles; do
            pkgbasefiles="$pkgbasefiles `basename $f`"
        done
        ;;
esac

case "x$pkgfiles" in
x)
        echo 'no source files found' 1>&2
        exit 1
        ;;
esac

# Split $gofiles into external gofiles (those in *_test packages)
# and internal ones (those in the main package).
for f in $gofiles; do
    package=`grep '^package[    ]' $f | sed 1q`
    case "$package" in
    *_test)
        xgofiles="$xgofiles $f"
        ;;
    *)
        ngofiles="$ngofiles $f"
        ;;
    esac
done
gofiles=$ngofiles

# External $O file
xofile=""
havex=false
if [ "x$xgofiles" != "x" ]; then
        xofile="_xtest_.o"
        havex=true
fi

set -e

package=`echo ${srcdir} | sed -e 's|^.*libgo/go/||'`

prefixarg=
if test -n "$prefix"; then
        prefixarg="-fgo-prefix=$prefix"
fi

if test "$trace" = "true"; then
  echo $GC -g $prefixarg -c -I . -fno-toplevel-reorder -o _gotest_.o $gofiles $pkgbasefiles
fi
$GC -g $prefixarg -c -I . -fno-toplevel-reorder -o _gotest_.o $gofiles $pkgbasefiles

if $havex; then
        mkdir -p `dirname $package`
        cp _gotest_.o `dirname $package`/lib`basename $package`.a
        if test "$trace" = "true"; then
            echo $GC -g -c -I . -fno-toplevel-reorder -o $xofile $xgofiles
        fi
        $GC -g -c -I . -fno-toplevel-reorder -o $xofile $xgofiles
fi

# They all compile; now generate the code to call them.

localname() {
        # The package main has been renamed to __main__ when imported.
        # Adjust its uses.
        echo $1 | sed 's/^main\./__main__./'
}

{
        # test functions are named TestFoo
        # the grep -v eliminates methods and other special names
        # that have multiple dots.
        pattern='Test([^a-z].*)?'
        # The -p option tells GNU nm not to sort.
        # The -v option tells Solaris nm to sort by value.
        tests=$($NM -p -v _gotest_.o $xofile | egrep ' T .*\.'$pattern'$' | grep -v '\..*\..*\.' | fgrep -v '$' | sed 's/.* //' | sed 's/.*\.\(.*\.\)/\1/')
        if [ "x$tests" = x ]; then
                echo 'gotest: warning: no tests matching '$pattern in _gotest_.o $xofile 1>&2
                exit 2
        fi
        # benchmarks are named BenchmarkFoo.
        pattern='Benchmark([^a-z].*)?'
        benchmarks=$($NM -p -v _gotest_.o $xofile | egrep ' T .*\.'$pattern'$' | grep -v '\..*\..*\.' | fgrep -v '$' | sed 's/.* //' | sed 's/.*\.\(.*\.\)/\1/')

        # examples are named ExampleFoo
        pattern='Example([^a-z].*)?'
        examples=$($NM -p -v _gotest_.o $xofile | egrep ' T .*\.'$pattern'$' | grep -v '\..*\..*\.' | fgrep -v '$' | sed 's/.* //' | sed 's/.*\.\(.*\.\)/\1/')

        # package spec
        echo 'package main'
        echo
        # imports
        if echo "$tests" | egrep -v '_test\.' >/dev/null; then
                echo 'import "./_gotest_"'
        fi
        if $havex; then
                echo 'import "./_xtest_"'
        fi
        echo 'import "testing"'
        echo 'import __regexp__ "regexp"' # rename in case tested package is called regexp
        # test array
        echo
        echo 'var tests = []testing.InternalTest {'
        for i in $tests
        do
                j=$(localname $i)
                echo '  {"'$i'", '$j'},'
        done
        echo '}'

        # benchmark array
        # The comment makes the multiline declaration
        # gofmt-safe even when there are no benchmarks.
        echo 'var benchmarks = []testing.InternalBenchmark{ //'
        for i in $benchmarks
        do
                j=$(localname $i)
                echo '  {"'$i'", '$j'},'
        done
        echo '}'

        # examples array
        echo 'var examples = []testing.InternalExample{ //'
        # This doesn't work because we don't pick up the output.
        #for i in $examples
        #do
        #       j=$(localname $i)
        #       echo '  {"'$i'", '$j', ""},'
        #done
        echo '}'

        # body
        echo \
'
var matchPat string
var matchRe *__regexp__.Regexp

func matchString(pat, str string) (result bool, err error) {
        if matchRe == nil || matchPat != pat {
                matchPat = pat
                matchRe, err = __regexp__.Compile(matchPat)
                if err != nil {
                        return
                }
        }
        return matchRe.MatchString(str), nil
}

func main() {
        testing.Main(matchString, tests, benchmarks, examples)
}'
}>_testmain.go

case "x$dejagnu" in
xno)
        if test "$trace" = "true"; then
            echo ${GC} -g -c _testmain.go
        fi
        ${GC} -g -c _testmain.go

        if test "$trace" = "true"; then
            echo ${GL} *.o ${GOLIBS}
        fi
        ${GL} *.o ${GOLIBS}

        if test "$trace" = "true"; then
            echo ./a.out -test.short -test.timeout=${timeout}s "$@"
        fi
        ./a.out -test.short -test.timeout=${timeout}s "$@" &
        pid=$!
        (sleep `expr $timeout + 10`
            echo > gotest-timeout
            echo "timed out in gotest" 1>&2
            kill -9 $pid) &
        alarmpid=$!
        wait $pid
        status=$?
        if ! test -f gotest-timeout; then
            kill $alarmpid
        fi
        exit $status
        ;;
xyes)
        rm -rf ../testsuite/*.o
        files=`echo *`
        for f in $files; do
                if test "$f" = "_obj" || test "$f" = "_test"; then
                        continue
                fi
                rm -rf ../testsuite/$f
                if test -f $f; then
                        cp $f ../testsuite/
                else
                        ln -s ../$DIR/$f ../testsuite/
                fi
        done
        cd ../testsuite
        rm -rf _obj _test
        mkdir _obj _test
        if test "$testname" != ""; then
            GOTESTNAME="$testname"
            export GOTESTNAME
        fi
        $MAKE check RUNTESTFLAGS="$RUNTESTFLAGS GOTEST_TMPDIR=$DIR"
        # Useful when using make check-target-libgo
        cat libgo.log >> libgo-all.log
        cat libgo.sum >> libgo-all.sum
        rm -rf $files
        ;;
esac