URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [testsuite/] [gotest] - Blame information for rev 747

Details | Compare with Previous | View Log


#!/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

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [testsuite/] [gotest] - Blame information for rev 747

Line No.	Rev	Author	Line
1	747	jeremybenn	`#!/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`