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

gobuild() {
    line=$(echo "$1" | sed -e 's|//go:build ||')
    line=$(echo "$line" | sed -e 's/go1\.[0-9]\+/1/g' -e 's/goexperiment\./goexperiment/')
    line=" $line "
    wrap='[ ()!&|]'
    for ones in $goarch $goos cgo gccgo goexperimentfieldtrack; do
	line=$(echo "$line" | sed -e "s/\\(${wrap}\\)${ones}\\(${wrap}\\)/"'\11\2/g')
    done
    # 386 is a special case since it looks like a number to the shell.
    # We need it to be 0 if it's not $goarch.
    if test "$goarch" != "386"; then
	line=$(echo "$line" | sed -e "s/\\(${wrap}\\)386\\(${wrap}\\)/\10\2/g")
    fi
    return $((!($line)))
}

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 | hurd | ios | illumos | js | linux | nacl | netbsd | openbsd | plan9 | solaris | windows | zos)
		tag1=nonmatchingtag
		;;
	    386 | amd64 | amd64p32 | arm | armbe | arm64 | arm64be | alpha | ia64 | m68k | mips | mipsle | mips64 | mips64le | mips64p32 | mips64p32le | nios2 | ppc | ppc64 | ppc64le | riscv | riscv64 | s390 | s390x | sh | shbe | sparc | sparc64 | wasm)
		tag1=nonmatchingtag
		;;
	    *)
		# File name like x_amd64_random.go, where tag1=random.
		# Don't match based on tag2.
		tag2=
		;;
	    esac

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

	    if test x$tag1 = xnonmatchingtag -o x$tag2 = xnonmatchingtag; then
		continue
	    fi

	    # Check for go:build line
	    build=$(sed '/^package /q' < $f | grep '^//go:build ' | cat)
	    if test -n "$build"; then
		if $(gobuild "$build"); then
		    gofiles="$gofiles $f"
		fi
		continue
	    fi

	    # No go:build line, check for +build lines.
	    tags=`sed '/^package /q' < $f | grep '^// *+build '`
	    omatch=true
	    first=true
	    match=false
	    for tag in $tags; do
		case $tag in
		    "//")
		    ;;
		    "+build" | "//+build")
			if test "$first" = "true"; then
			    first=false
			elif test "$match" = "false"; then
			    omatch=false
			fi
			match=false
			;;
		    $goos | $goarch | cgo | gccgo | goexperiment.fieldtrack | go1.[0-9] | go1.[0-9][0-9])
			match=true
			;;
		    "!"$goos | "!"$goarch | "!cgo" | "!gccgo" | "!goexperiment.fieldtrack" | "!"go1.[0-9] | "!"go1.1[0-7])
			;;
		    *,*)
			cmatch=true
			for ctag in `echo $tag | sed -e 's/,/ /g'`; do
			    case $ctag in
				$goos | $goarch | cgo | gccgo | goexperiment.fieldtrack | go1.[0-9] | go1.[0-9][0-9])
				;;
				"!"$goos | "!"$goarch | "!cgo" | "!gccgo" | "!goexperiment.fieldtrack" | "!"go1.[0-9] | "!"go1.1[0-7])
				    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
	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

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=
xpackage=
for f in $gofiles; do
    package=`grep '^package[ 	]' $f | sed 1q`
    case "$package" in
    *_test)
	xpackage=`echo $package | sed -e 's/package[ 	]//' -e 's/[ 	]*$//'`
	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

	# Force the test version of the package to be imported first,
	# so that its type definitions will be used, in case any new
	# methods appear in export_test.go files.
	echo "package $xpackage" > _first_test.go
	echo 'import _ "'$package'"' >> _first_test.go

	if test "$trace" = "true"; then
	    echo $GC -g $xpkgpatharg -c -I . -fno-toplevel-reorder -o $xofile _first_test.go $xgofiles
	fi
	$GC -g $xpkgpatharg -c -I . -fno-toplevel-reorder -o $xofile _first_test.go $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.
	# Also demangle underscores.
	echo $1 | sed 's/^main\./__main__./' | sed 's/__/_/'
}

# Takes a list of tests derived from 'nm' output (whose symbols are mangled)
# and emits a demangled list of tests, using only the terminal package.
# Example:
#
#    Original symbol:   foo/bar/leaf.Mumble
#    Mangled symbol:    foo_1fbar_1leaf.Mumble
#    Returned:          leaf.Mumble
#
symtogo() {
  result=""
  for tp in $*; do
    # Discard symbols with a leading dot.
    # On AIX, this will remove function text symbols (with a leading dot).
    # Therefore, only function descriptor symbols (without this leading dot)
    # will be used to retrieve the go symbols, avoiding duplication.
    if expr "$tp" : '^\.' >/dev/null 2>&1; then
      continue
    fi
    # Skip type descriptors.  These are normally skipped because they
    # are weak symbols, but if not using GNU nm we may see them here.
    if expr "$tp" : '^type\.\.' >/dev/null 2>&1; then
      continue
    fi
    s=$(echo "$tp" | sed -e 's/_1/%/g' | sed -e 's/.*%//')
    # Screen out methods (X.Y.Z).
    if ! expr "$s" : '^[^.]*\.[^.]*$' >/dev/null 2>&1; then
      continue
    fi
    tname=$(testname $s)
    # Skip TestMain.
    if test x$tname = xTestMain; then
      continue
    fi
    # Check that the function is defined in a test file,
    # not an ordinary non-test file.
    if grep "^func $tname(" $gofiles $xgofiles >/dev/null 2>&1; then
      echo "$s"
    fi
  done
}

# Find Go benchmark/fuzz/example functions.
# The argument is the function name prefix.
findfuncs() {
	pattern="$1([^a-z].*)?"
	syms=$($NM -p -v _gotest_.o | egrep " $text .*\."$pattern'$' | fgrep -v ' __go_' | egrep -v '\.\.\w+$' | sed 's/.* //')
	if $havex; then
	    xsyms=$($NM -p -v $xofile | egrep " $text .*\."$pattern'$' | fgrep -v ' __go_' | egrep -v '\.\.\w+$' | sed 's/.* //')
	    syms="$syms $xsyms"
	fi
        symtogo "$syms"
}

# Takes an example name and puts any output into the file example.txt.
# It strips comment markers but does not otherwise change the output.
exampleoutput() {
    n=$(testname $1)
    for f in $gofiles $xgofiles; do
	if ! grep "^func $n(" $f >/dev/null 2>&1; then
	    continue
	fi
	# Copy the output comment, if any, into example.txt.
	# Remove the comment markers.
	sed -n "/^func $n(/,/^}$/ p" $f |
	    sed -n '\|// \([Uu]nordered \)\?[Oo]utput:|,$ p' |
	    sed -n '\|//| s|[ 	]*// \?||p' > example.txt
	# Check whether we found an output comment.
	if ! sed -n '1p' < example.txt | grep '[Oo]utput:' >/dev/null 2>&1; then
	    rm -f example.txt
	fi
	return
    done
}

{
	# On systems using PPC64 ELF ABI v1 function symbols show up
	# as descriptors in the data section.
	text="[TD]"

	# 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.
        testsyms=$($NM -p -v _gotest_.o | egrep " $text .*\."$pattern'$' | fgrep -v ' __go_' | egrep -v '\.\.\w+$' | sed 's/.* //')
	testxsyms=
	if $havex; then
	    testxsyms=$($NM -p -v $xofile | egrep " $text .*\."$pattern'$' | fgrep -v ' __go_' | egrep -v '\.\.\w+$' | sed 's/.* //')
	    testsyms="$testsyms $testxsyms"
	fi
        tests=$(symtogo "$testsyms")
	if [ "x$tests" = x ]; then
		echo 'gotest: warning: no tests matching '$pattern in _gotest_.o $xofile 1>&2
		exit 2
	fi

	benchmarks=$(findfuncs Benchmark)
	fuzztargets=$(findfuncs Fuzz)
	examples=$(findfuncs Example)

	# package spec
	echo 'package main'
	echo
	# imports
	if echo "$tests" | egrep -v '_test\.' >/dev/null; then
		echo 'import "./_gotest_"'
	fi
	if $havex; then
	    needxtest=false
	    if test -n "$testxsyms"; then
		needxtest=true
	    elif echo "$benchmarks" | grep '_test\.' >/dev/null; then
		needxtest=true
	    else
		# Check whether any example has output.
		for i in $(echo "$examples" | grep '_test\.'); do
		    exampleoutput $i
		    if test -f example.txt; then
			rm -f example.txt
			needxtest=true
			break
		    fi
		done
	    fi
	    if test x$needxtest = xtrue; then
		echo 'import "./_xtest_"'
	    else
		echo 'import _ "./_xtest_"'
	    fi
	fi
	if test "$package" != "testing"; then
		echo 'import "testing"'
	fi
	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)
		j=$(localname $i)
		echo '	{"'$n'", '$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
		n=$(testname $i)
		j=$(localname $i)
		echo '	{"'$n'", '$j'},'
	done
	echo '}'

	# fuzz array
	echo 'var fuzzTargets = []testing.InternalFuzzTarget{'
	for i in $fuzztargets; do
		n=$(testname $i)
		j=$(localname $i)
		echo '  {"'$n'", '$j'},'
	done
	echo '}'

	# examples array
	echo 'var examples = []testing.InternalExample{'
	for i in $examples; do
		n=$(testname $i)
		j=$(localname $i)
		# Look for a //output comment.
		hasoutput=false
		unordered=false
		output=
		exampleoutput $i
		if ! test -f example.txt; then
		    continue
		fi
		# Check whether the output can be unordered.
		unordered=false
		if sed -n '1p' < example.txt | grep -i unordered >/dev/null 2>&1; then
		    unordered=true
		fi
		# Remove the output header.
		# Quote backslashes.
		# Quote quotation characters.
		# Turn tab into \t.
		# Turn pairs of spaces into " \x20", because $() will
		# drop duplicate spaces.
		# Drop trailing spaces, and turn newlines into \n.
		# Remove leading and trailing \n.
		sed '1 s/\([Uu]nordered \)\?[Oo]utput:[ 	]*//' < example.txt |
			     sed -e 's/\\/\\\\/g' \
				 -e 's/"/\\"/g' \
				 -e 's/	/\\t/g' \
				 -e 's/  / \\x20/g' \
				 -e 's/[ 	]*$/\\n/g' |
			     tr -d '\n' |
			     sed -e 's/^\(\\n\)*//' \
				 -e 's/\(\\n\)*$//' > example2.txt
		hasoutput=true
		echo '	{"'$n'", '$j','
		sed -e 's/^/		"/' -e 's/$/", /' < example2.txt
		echo $unordered'},'
		rm -f example.txt example2.txt
	done
	echo '}'

	# body
	echo \
'
func main() {
	m := testing.MainStart(testdeps.TestDeps{}, tests, benchmarks, fuzzTargets, 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