path: root/libgo/testsuite/gotest

#!/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.
LANG=C
LC_ALL=C
LC_CTYPE=C
export LANG LC_ALL LC_CTYPE

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=.
goarch=""
gofiles=""
goos=""
pkgfiles=""
loop=true
keep=false
pkgpath=
prefix=
dejagnu=no
timeout=240
testname=""
bench=""
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--goarch)
		goarch=$2
		shift
		shift
		;;
	x--goarch=*)
		goarch=`echo $1 | sed -e 's/^--goarch=//'`
		shift
		;;
	x--goos)
		goos=$2
		shift
		shift
		;;
	x--goos=*)
		goos=`echo $1 | sed -e 's/^--goos=//'`
		shift
		;;
	x--pkgpath)
		pkgpath=$2
		shift
		shift
		;;
	x--pkgpath=*)
		pkgpath=`echo $1 | sed -e 's/^--pkgpath=//'`
		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--bench)
		bench=$2
		shift
		shift
		;;
	x--bench=*)
		bench=`echo $1 | sed -e 's/^--bench=//'`
		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
mkdir test
cd test

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
                    case $f in
                    /*)
                        b=`basename $f`
                        rm -f $b
                        cp $f $b
                        ;;
                    *)
		        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
                        ;;
                    esac
		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
                    case $f in
                    /*)
                        b=`basename $f`
                        rm -f $b
                        cp $f $b
                        ;;
                    *)
		        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
                        ;;
                    esac
		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)
	for f in `ls *_test.go`; do
	    tag1=`echo $f | sed -e 's/^.*_\([^_]*\)_test.go$/\1/'`
	    tag2=`echo $f | sed -e 's/^.*_\([^_]*\)_[^_]*_test.go$/\1/'`
	    if test x$tag1 = x$f; then
		tag1=
	    fi
	    if test x$tag2 = x$f; then
		tag2=
	    fi

	    case "$tag1" in
	    "") ;;
	    $goarch) ;;
	    $goos) ;;
	    aix | android | darwin | dragonfly | freebsd | linux | nacl | netbsd | openbsd | plan9 | solaris | windows)
		tag1=nonmatchingtag
		;;
	    386 | amd64 | amd64p32 | arm | armbe | arm64 | arm64be | alpha | ia64 | m68k | mips | mipsle | mips64 | mips64le | mips64p32 | mips64p32le·| nios2 | ppc | ppc64 | ppc64le | riscv64 | s390 | s390x | sh | shbe | sparc | sparc64)
		tag1=nonmatchingtag
		;;
	    esac

	    case "$tag2" in
	    "") ;;
	    $goarch) ;;
	    $goos) ;;
	    aix | android | darwin | dragonfly | freebsd | linux | nacl | netbsd | openbsd | plan9 | solaris | windows)
		tag2=nonmatchingtag
		;;
	    386 | amd64 | amd64p32 | arm | armbe | arm64 | arm64be | alpha | ia64 | m68k | mips | mipsle | mips64 | mips64le | mips64p32 | mips64p32le·| nios2 | ppc | ppc64 | ppc64le | riscv64 | s390 | s390x | sh | shbe | sparc | sparc64)
		tag2=nonmatchingtag
		;;
	    esac

	    if test x$tag1 != xnonmatchingtag -a x$tag2 != xnonmatchingtag; then
		tags=`sed '/^package /q' < $f | grep '^// +build '`
		omatch=true
		first=true
		match=false
		for tag in $tags; do
		    case $tag in
		    "//")
			;;
		    "+build")
			if test "$first" = "true"; then
			    first=false
			elif test "$match" = "false"; then
			    omatch=false
			fi
			match=false
			;;
		    $goos | $goarch | cgo | gccgo | go1.[0-9])
			match=true
			;;
		    "!"$goos | "!"$goarch | "!cgo" | "!gccgo" | "!"go1.[0-9])
			;;
		    *,*)
			cmatch=true
			for ctag in `echo $tag | sed -e 's/,/ /g'`; do
			    case $ctag in
			    $goos | $goarch | cgo | gccgo | go1.[0-9])
				;;
			    "!"$goos | "!"$goarch | "!cgo" | "!gccgo" | "!"go1.[0-9])
				cmatch=false
				;;
			    "!"*)
			        ;;
			    *)
				cmatch=false
				;;
			    esac
			done
			if test "$cmatch" = "true"; then
			    match=true
			fi
			;;
		    "!"*)
			match=true
			;;
		    esac
		done

		if test "$match" = "false" -a "$first" = "false"; then
		    omatch=false
		fi

		if test "$omatch" = "true"; then
		    gofiles="$gofiles $f"
		fi
	    fi
	done
	;;
*)
	xgofiles=$gofiles
	gofiles=
	for f in $xgofiles; do
	    gofiles="$gofiles `basename $f`"
	done
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).
xgofiles=
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

testmain=
if $havex && fgrep 'func TestMain(' $xgofiles >/dev/null 2>&1; then
  package=`grep '^package[ 	]' $xgofiles | sed 1q | sed -e 's/.* //'`
  testmain="${package}.TestMain"
elif test -n "$gofiles" && fgrep 'func TestMain(' $gofiles >/dev/null 2>&1; then
  package=`grep '^package[ 	]' $gofiles | sed 1q | sed -e 's/.* //'`
  testmain="${package}.TestMain"
fi

set -e

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

pkgpatharg=
xpkgpatharg=
prefixarg=
if test -n "$pkgpath"; then
	pkgpatharg="-fgo-pkgpath=$pkgpath"
	xpkgpatharg="-fgo-pkgpath=${pkgpath}_test"
elif test -n "$prefix"; then
	prefixarg="-fgo-prefix=$prefix"
fi

if test "$trace" = "true"; then
  echo $GC -g $pkgpatharg $prefixarg -c -I . -fno-toplevel-reorder -o _gotest_.o $gofiles $pkgbasefiles
fi
$GC -g $pkgpatharg $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 $xpkgpatharg -c -I . -fno-toplevel-reorder -o $xofile $xgofiles
	fi
	$GC -g $xpkgpatharg -c -I . -fno-toplevel-reorder -o $xofile $xgofiles
fi

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

testname() {
	# Remove the package from the name used with the -test option.
	echo $1 | sed 's/^.*\.//'
}

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

{
	text="T"

	# On systems using PPC64 ELF ABI v1 function symbols show up
	# as descriptors in the data section.  We assume that $goarch
	# distinguishes v1 (ppc64) from v2 (ppc64le).
	if test "$goos" != "aix" && test "$goarch" = "ppc64"; then
	    text="[TD]"
	fi

	symtogo='sed -e s/_test\([^A-Za-z0-9]\)/XXXtest\1/ -e s/.*_\([^_]*\.\)/\1/ -e s/XXXtest/_test/'

	# 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 " $text .*\."$pattern'$' | grep -v '[^ ]\..*\.' | fgrep -v ' __go_' | sed 's/.* //' | $symtogo)
	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 " $text .*\."$pattern'$' | grep -v '[^ ]\..*\.' | fgrep -v ' __go_' | sed 's/.* //' | $symtogo)

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

	# 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 "testing/internal/testdeps"'
	if ! test -n "$testmain"; then
		echo 'import __os__ "os"'
	fi
	# test array
	echo
	echo 'var tests = []testing.InternalTest {'
	for i in $tests
	do
		n=$(testname $i)
		if test "$n" != "TestMain"; then
			j=$(localname $i)
			echo '	{"'$n'", '$j'},'
		fi
	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
		n=$(testname $i)
		j=$(localname $i)
		echo '	{"'$n'", '$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
	#	n=$(testname $i)
	#	j=$(localname $i)
	#	echo '	{"'$n'", '$j', ""},'
	#done
	echo '}'

	# body
	echo \
'
func main() {
	m := testing.MainStart(testdeps.TestDeps{}, tests, benchmarks, examples)
'
	if test -n "$testmain"; then
		echo "	${testmain}(m)"
	else
		echo '	__os__.Exit(m.Run())'
	fi

	echo '}'
}>_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}

	set +e
	if test "$bench" = ""; then
		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
		    sleeppid=`ps -o pid,ppid,comm | grep " $alarmpid " | grep sleep | sed -e 's/ *\([0-9]*\) .*$/\1/'`
		    kill $alarmpid
		    wait $alarmpid
		    if test "$sleeppid" != ""; then
			kill $sleeppid
		    fi
		fi
	else
		if test "$trace" = "true"; then
		    echo ./a.out -test.run=^\$ -test.bench="${bench}" "$@"
		fi
		./a.out -test.run=^\$ -test.bench="${bench}" "$@"
		status=$?
	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/test/$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/test"
	# Useful when using make check-target-libgo
	cat libgo.log >> libgo-all.log
	cat libgo.sum >> libgo-all.sum
	rm -rf $files
	;;
esac