path: root/test/bin/scala-test

#!/bin/sh

##############################################################################
# test script for scala tools
##############################################################################

VERSION="1.01";
AUTHORS="Philippe Altherr";

# $OldId: scala-test,v 1.20 2002/12/12 14:13:54 paltherr Exp $
# $Id$

##############################################################################
# define prefix and script

SOURCE="$0";
while [ -h "$SOURCE" ]; do
    LOOKUP="`ls -ld "$SOURCE"`";
    TARGET="`expr "$LOOKUP" : '.*-> \(.*\)$'`";
    if expr "${TARGET:-.}/" : '/.*/$' > /dev/null; then
        SOURCE="${TARGET:-.}";
    else
        SOURCE="`dirname "$SOURCE"`/${TARGET:-.}";
    fi;
done;
PREFIX=`dirname "$SOURCE"`;
case "$PREFIX" in
    bin | */bin ) PREFIX=`dirname "$PREFIX"`;;
    *           ) PREFIX=`cd "$PREFIX/.."; pwd`;
esac
SCRIPT="`basename $SOURCE`";

##############################################################################
# flow control functions

abort() {
    echo "$0: $1" 1>&2;
    exit 1;
}

##############################################################################
# print functions

color_initialization() {
    case "$1" in
        many )
            SETCOLOR_OUTLINE="printf \\033[1;39m";
            SETCOLOR_SUCCESS="printf \\033[1;32m";
            SETCOLOR_FAILURE="printf \\033[1;31m";
            SETCOLOR_WARNING="printf \\033[1;33m";
            SETCOLOR_NORMAL="printf \\033[0;39m";
            ;;
        some )
            SETCOLOR_OUTLINE="printf \\033[1m";
            SETCOLOR_SUCCESS="printf \\033[0m";
            SETCOLOR_FAILURE="printf \\033[1m";
            SETCOLOR_WARNING="printf \\033[1m";
            SETCOLOR_NORMAL="printf \\033[0m";
            ;;
        none )
            SETCOLOR_OUTLINE="";
            SETCOLOR_SUCCESS="";
            SETCOLOR_FAILURE="";
            SETCOLOR_WARNING="";
            SETCOLOR_NORMAL="";
            ;;
        * )
            abort "unknown color mode \`$1'";
            ;;
    esac;
}

printf_outline() {
    $SETCOLOR_OUTLINE;
    printf "$@";
    $SETCOLOR_NORMAL;
}

printf_success() {
    $SETCOLOR_SUCCESS;
    printf "$@";
    $SETCOLOR_NORMAL;
}

printf_failure() {
    $SETCOLOR_FAILURE;
    printf "$@";
    $SETCOLOR_NORMAL;
}

printf_warning() {
    $SETCOLOR_WARNING;
    printf "$@";
    $SETCOLOR_NORMAL;
}

##############################################################################
# print functions

show_testing() {
    printf_outline "testing: ";
    printf "%-60s " "$1";
}

show_success() {
    printf "[";
    printf_success "  OK  ";
    printf "]\\n";
}

show_failure() {
    printf "[";
    printf_failure "FAILED";
    printf "]\\n";
}

##############################################################################
# test functions

test_interpretation() {
    $SURUS $TEST_FLAGS $FLAGS "$source" -- Test "int";
}

test_shell() {
    cat "$source" | $SURUS -interactive -nologo $TEST_FLAGS $FLAGS;
}

test_compilation() {
    output="$OBJDIR"/`expr "$source" : "\(.*\)\\.scala"`-$KIND.obj;
    classpath="$output";
    if $CYGWIN; then
        classpath=`cygpath -w -p "$classpath"`;
	os_output=`cygpath -w "$output"`;
    else
	os_output="$output";
    fi;
    rm -rf "$output";
    mkdir -p "$output" &&
    $SOCOS -d "$os_output" $TEST_FLAGS $FLAGS "$source" &&
    $SCALA -classpath "$classpath" Test "jvm" &&
    rm -rf "$output";
}

test_xml() {
    output="$OBJDIR"/`expr "$source" : "\(.*\)\\.scala"`-$KIND.obj;
    dtdfile="`expr "$source" : "\(.*\)\\.scala"`.dtd";
    xmlfile="`expr "$source" : "\(.*\)\\.scala"`.xml";
    objfile="$output/dtd.scala";
    classpath="$output";
    if $CYGWIN; then
        classpath=`cygpath -w -p "$classpath"`;
	os_output=`cygpath -w "$output"`;
    else
	os_output="$output";
    fi;
    rm -rf "$output";
    mkdir -p "$output" &&
    $DTD2SCALA -d "$os_output" "$dtdfile" dtd &&
    $SOCOS -d "$os_output" $TEST_FLAGS $FLAGS "$objfile" "$source" &&
    $SCALA -classpath "$classpath" Test "$xmlfile" &&
    rm -rf "$output";
}

test_disassembler() {
    scalapargs="`expr "$source" : "\(.*\)\\.scala"`.args";
    if [ -f "$scalapargs" ]; then
        SCALAP_ARGS=`cat "$scalapargs"`;
    else
        SCALAP_ARGS="";
    fi;
    output="$OBJDIR"/`expr "$source" : "\(.*\)\\.scala"`-$KIND.obj;
    classpath="$output";
    if $CYGWIN; then
        classpath=`cygpath -w -p "$classpath"`;
	os_output=`cygpath -w "$output"`;
    else
	os_output="$output";
    fi;
    rm -rf "$output";
    mkdir -p "$output" &&
    $SOCOS -d "$os_output" $TEST_FLAGS $FLAGS "$source" &&
    $SCALAP -classpath "$classpath" $SCALAP_ARGS &&
    rm -rf "$output";
}

test_compilation_success() {
    output="$OBJDIR"/`expr "$source" : "\(.*\)\\.scala"`-$KIND.obj;
    if $CYGWIN; then
	os_output=`cygpath -w "$output"`;
    else
	os_output="$output";
    fi;
    rm -rf "$output";
    mkdir -p "$output" &&
    $SOCOS -d "$os_output" $TEST_FLAGS $FLAGS "$source" &&
    rm -rf "$output";
}

test_compilation_failure() {
    (
        OBJDIR="$OBJDIR/"`dirname "$source"`;
        cd `dirname "$source"`;
        source=`basename "$source"`;
        if test_compilation_success "$@"; then false; else
            rm -rf "$output";
        fi;
    )
}

test_msil() {
    ASSEM="Test"
    IL_FILE=${ASSEM}".il"
    PE_FILE=${ASSEM}".EXE"

    ILASM=ilasm
    ILASM_ARGS="/qui /nol /out=${PE_FILE}"

    PEVERIFY=peverify
    PEVERIFY_ARGS="/il"

    rm -f $IL_FILE
    rm -f $PE_FILE

    $SOCOS -nowarn -target:msil -o ${ASSEM} $FLAGS "$source" &&

    ${ILASM} ${ILASM_ARGS} ${IL_FILE} > /dev/null &&
    if [ ! $? ] ; then
	echo "'$ILASM' failed!"
	return 1
    fi

#    $PEVERIFY $PEVERIFY_ARGS $PE_FILE > /dev/null
#    if [ ! $? ] ; then
#	echo "'$PEVERIFY' failed!"
#	rm -rf $PE_FILE
#	return 1
#    fi

    eval ./$PE_FILE "msil"
}

test_output() {
    if [ -f "$expect" ]; then
        $DIFF "$actual" "$expect";
    else
        cat /dev/null | $DIFF "$actual" -;
    fi;
}

test_file() {
    source="$FILE";
    flags="`expr "$source" : "\(.*\)\\.scala"`.flags";
    expect="`expr "$source" : "\(.*\)\\.scala"`-$KIND.check";
    if [ ! -f $expect ]; then
	expect="`expr "$source" : "\(.*\)\\.scala"`.check";
    fi;
    actual="`expr "$source" : "\(.*\)\\.scala"`-$KIND.log";
    if [ -f "$flags" ]; then
        TEST_FLAGS=`cat $flags`;
    else
        TEST_FLAGS="";
    fi;
    if [ "$FAILED" = "true" -a ! -f "$actual" ]; then
        continue;
    fi;
    if [ "$HEAD" != "true" ]; then
        printf_outline "$TEXT\\n";
        HEAD="true";
    fi;
    show_testing "$FILE";
    if [ "$NORUN" != "true" ]; then
        rm -f "$actual";
        "$TEST" 1> "$actual" 2>&1 && test_output 1> /dev/null 2>&1;
    else
        test ! -f "$actual";
    fi;
    if [ "$?" = 0 ]; then
        SUCCESS_COUNT=`echo "$SUCCESS_COUNT+1" | bc`;
        show_success;
        rm -f "$actual";
    else
        FAILURE_COUNT=`echo "$FAILURE_COUNT+1" | bc`;
        show_failure;
    fi;
    if [ -f "$actual" ]; then
        if [ "$SHOWLOG" = "true" ]; then
            cat "$actual";
        fi;
        if [ "$SHOWDIFF" = "true" ]; then
            test_output;
        fi;
    fi;
}

test_one() {
    HEAD="false";
    TEXT="$1"; shift 1;
    TEST="$1"; shift 1;
    KIND="$1"; shift 1;

    for FROM do
        if [ -d "$FROM" -o -f "$FROM" ]; then
            for FILE in . `find "$FROM" -name "*.obj" -prune -o -name "*.scala" -print`; do
                if [ "$FILE" = "." ]; then continue; fi;
                test_file;
            done;
        fi;
    done

    if [ "$HEAD" = "true" ]; then
        echo "";
    fi;
}


test_all() {
    printf_outline "Test configuration\\n";
    printf_outline "socos executable: "; echo "$SOCOS";
    printf_outline "surus executable: "; echo "$SURUS";
    printf_outline "scala executable: "; echo "$SCALA";
    echo "";

    test_one "Testing jvm backend" \
        test_compilation "jvm" $FILES_RUN $FILES_JVM;
    test_one "Testing interpreter" \
        test_interpretation "int" $FILES_RUN $FILES_INT;
    test_one "Testing interpreter shell" \
        test_shell "shl" $FILES_SHL;
    test_one "Testing dtd2scala tool" \
        test_xml "xml" $FILES_XML;
    test_one "Testing disassembler" \
        test_disassembler "dis" $FILES_DIS;
    test_one "Testing compiler (on files whose compilation should succeed)" \
        test_compilation_success "pos" $FILES_POS;
    test_one "Testing compiler (on files whose compilation should fail)" \
        test_compilation_failure "neg" $FILES_NEG;
    test_one "Testing msil backend" \
	test_msil "msil" $FILES_MSIL;
}

##############################################################################
# main functions

print_usage() {
    echo "Usage: $0 [OPTION]..."
}

print_help() {
    print_usage;
    echo "";
    echo "--auto          use filenames to select the test to run";
    echo "--run           next files test the interpreter and all backends";
    echo "--jvm           next files test the jvm backend";
    echo "--int           next files test the interpreter";
    echo "--shl           next files test the interpreter shell";
    echo "--xml           next files test the dtd2scala tool";
    echo "--dis           next files test the disassembler";
    echo "--pos           next files test a compilation success";
    echo "--neg           next files test a compilation failure";
    echo "--msil          next files test the .NET backend (requires Cygwin)"
    echo "--boot          use bootstrap compiler";
    echo "--no-run        run no test, use results of last run";
    echo "--show-log      show output of failed tests";
    echo "--show-diff     show differences between actual and expected output";
    echo "--failed        test only files that failed last time";
    echo "--errors=<int>  specify the number of expected errors";
    echo "--socos=<path>  specify the socos command";
    echo "--surus=<path>  specify the surus command";
    echo "--scala=<path>  specify the scala runtime class path";
    echo "--flags=<flags> specify flags to pass on to the executable";
    echo "--color=USAGE   control the color usage (USAGE=none|some|many)";
    echo "--objdir=<dir>  specify where to place generated files";
    echo "--help, -?      display this help and exit";
    echo "--version       output version information and exit";
}

print_version() {
    echo "$SCRIPT $VERSION";
    echo "Written by $AUTHORS";
}

find_program0() {
    # if there is a user-specified path, use this one
    if [ -n "$fullpath" ]; then
        if [ -x "$fullpath" ]; then
            return 0;
        else
            abort "file \`$fullpath' is not executable";
        fi;
    fi;

    # try the path used in the build tree
    fullpath="`cd "$PREFIX/../"; pwd`/bin/$filename";
    if [ -x "$fullpath" ]; then
        return 0;
    fi;

    # try the path used in the standard distribution
    fullpath="`cd "$PREFIX/../../../"; pwd`/bin/$filename";
    if [ -x "$fullpath" ]; then
        return 0;
    fi;

    # if the program can be found in the path, use it
    if type=`type "$filename" 2> /dev/null`; then
        fullpath=`expr "$type" : ".* is \(.*\)"`;
        return 0;
    fi;

    abort "could not locate executable \`$filename'";
}

find_program() {
    variable="$1"; shift 1;
    filename="$1"; shift 1;
    fullpath=`eval echo \\\$$variable`;
    find_program0;
    eval "$variable=\"$fullpath\"";
}

find_runtime0() {
    # if there is a user-specified path, use this one
    if [ -n "$fullpath" ]; then
        return 0;
    fi;

    # try the path used in the build tree
    fullpath="`dirname $filename`/..";
    fullpath="`cd "$fullpath"; pwd`/classes";
    if [ -d "$fullpath" ]; then
        return 0;
    fi;

    # try the path used in the standard distribution
    fullpath="`dirname $filename`/..";
    fullpath="`cd "$fullpath"; pwd`/lib/scala.jar";
    if [ -f "$fullpath" ]; then
        return 0;
    fi;

    abort "could not locate runtime classes for \`$filename'";
}

find_runtime() {
    variable="$1"; shift 1;
    filename="$1"; shift 1;
    fullpath=`eval echo \\\$$variable`;
    find_runtime0;
    eval "$variable=\"$fullpath\"";
}

add_file() {
    TEST_ALL="false";
    case "$TEST_TYPE" in
        auto ) ;;
        run  ) FILES_RUN="$FILES_RUN $1"; return;;
        jvm  ) FILES_JVM="$FILES_JVM $1"; return;;
        int  ) FILES_INT="$FILES_INT $1"; return;;
        shl  ) FILES_SHL="$FILES_SHL $1"; return;;
        xml  ) FILES_XML="$FILES_XML $1"; return;;
        dis  ) FILES_DIS="$FILES_DIS $1"; return;;
        pos  ) FILES_POS="$FILES_POS $1"; return;;
        neg  ) FILES_NEG="$FILES_NEG $1"; return;;
	msil ) FILES_MSIL="$FILES_MSIL $1"; return;;
        *    ) abort "unknown test type \`$TEST_TYPE'";;
    esac;
    case "$1" in
        run  | */run  | */run/*  | run/*  ) FILES_RUN="$FILES_RUN $1";;
        jvm  | */jvm  | */jvm/*  | jvm/*  ) FILES_JVM="$FILES_JVM $1";;
        int  | */int  | */int/*  | int/*  ) FILES_INT="$FILES_INT $1";;
        shl  | */shl  | */shl/*  | shl/*  ) FILES_SHL="$FILES_SHL $1";;
        xml  | */xml  | */xml/*  | xml/*  ) FILES_XML="$FILES_XML $1";;
        dis  | */dis  | */dis/*  | dis/*  ) FILES_DIS="$FILES_DIS $1";;
        pos  | */pos  | */pos/*  | pos/*  ) FILES_POS="$FILES_POS $1";;
        neg  | */neg  | */neg/*  | neg/*  ) FILES_NEG="$FILES_NEG $1";;
        msil | */msil | */msil/* | msil/* ) FILES_MSIL="$FILES_MSIL $1";;
        * ) abort "don't known what to do with \`$1'";;
    esac;
}

main() {
    BOOT="false";
    NORUN="false";
    SHOWLOG="false";
    SHOWDIFF="false";
    FAILED="false";
    ERRORS=0;
    SUCCESS_COUNT=0;
    FAILURE_COUNT=0;
    SRCDIR="$PREFIX/files";
    OBJDIR=".";

    TEST_ALL="true";
    TEST_TYPE="auto";
    FILES_RUN="";
    FILES_JVM="";
    FILES_INT="";
    FILES_SHL="";
    FILES_XML="";
    FILES_DIS="";
    FILES_POS="";
    FILES_NEG="";
    FILES_MSIL="";

    CYGWIN="false";
    DIFF="diff"
    case `uname` in
        CYGWIN* )
            CYGWIN="true";
            DIFF="diff --text --strip-trailing-cr";
            ;;
    esac

    while [ $# -gt 0 ]; do
        case "$1" in
            --auto       ) TEST_TYPE="auto"; shift 1;;
            --run        ) TEST_TYPE="run"; shift 1;;
            --jvm        ) TEST_TYPE="jvm"; shift 1;;
            --int        ) TEST_TYPE="int"; shift 1;;
            --shl        ) TEST_TYPE="shl"; shift 1;;
            --xml        ) TEST_TYPE="xml"; shift 1;;
            --dis        ) TEST_TYPE="dis"; shift 1;;
            --pos        ) TEST_TYPE="pos"; shift 1;;
            --neg        ) TEST_TYPE="neg"; shift 1;;
            --msil       ) TEST_TYPE="msil"; shift 1;;
            --boot       ) BOOT="true"; shift 1;;
            --no-run     ) NORUN="true"; shift 1;;
            --show-log   ) SHOWLOG="true"; shift 1;;
            --show-diff  ) SHOWDIFF="true"; shift 1;;
            --failed     ) FAILED="true"; shift 1;;
            --errors=    ) abort "illegal empty argument for option --errors";;
            --errors=*   )ERRORS=`expr "$1" : "--errors=\([0-9]*\)$"`;shift 1;;
            --socos=     ) abort "illegal empty argument for option --socos";;
            --socos=*    ) SOCOS=`expr "$1" : "--socos=\(.*\)"`; shift 1;;
            --surus=     ) abort "illegal empty argument for option --surus";;
            --surus=*    ) SURUS=`expr "$1" : "--surus=\(.*\)"`; shift 1;;
            --scala=     ) abort "illegal empty argument for option --scala";;
            --scala=*    ) SCALA=`expr "$1" : "--scala=\(.*\)"`; shift 1;;
            --flags=     ) abort "illegal empty argument for option --flags";;
            --flags=*    ) FLAGS=`expr "$1" : "--flags=\(.*\)"`; shift 1;;
            --color=     ) abort "illegal empty argument for option --color";;
            --color=*    ) COLOR=`expr "$1" : "--color=\(.*\)"`; shift 1;;
            --objdir=    ) abort "illegal empty argument for option --objdir";;
            --objdir=*   ) OBJDIR=`expr "$1" : "--objdir=\(.*\)"`; shift 1;;
            --help| -?   ) print_help; exit 0;;
            --version    ) print_version; exit 0;;
            -*           ) abort "unknown option $1";;
            *            ) add_file "$1"; shift 1;;
        esac;
    done;

    if [ -z "$ERRORS" ]; then
        abort "illegal non-numerical argument for option --errors";
    fi;

    if [ -z "$COLOR" -a -n "$EMACS" ]; then
        COLOR="none";
    fi;
    color_initialization "${COLOR:-many}";
    find_program SOCOS scalac;
    find_program SURUS scalarun;
    find_program SCALA scala;
    find_program DTD2SCALA dtd2scala;
    find_program SCALAP scalap;
    find_program SCALA_INFO scala-info;

    if [ "$BOOT" = true ]; then
        SOCOS=${SOCOS}boot;
    fi;

    if [ "$TEST_ALL" = "true" ]; then
        case "$TEST_TYPE" in
                   run ) FILES_RUN="$FILES_RUN $SRCDIR/run";;
        esac;
        case "$TEST_TYPE" in
            auto | jvm ) FILES_JVM="$FILES_JVM $SRCDIR/run $SRCDIR/jvm";;
        esac;
        case "$TEST_TYPE" in
            auto | int ) FILES_INT="$FILES_INT $SRCDIR/run";;
        esac;
        case "$TEST_TYPE" in
            auto | shl ) FILES_SHL="$FILES_SHL $SRCDIR/shl";;
        esac;
        case "$TEST_TYPE" in
            auto | xml ) FILES_XML="$FILES_XML $SRCDIR/xml";;
        esac;
        case "$TEST_TYPE" in
            auto | dis ) FILES_DIS="$FILES_DIS $SRCDIR/dis";;
        esac;
        case "$TEST_TYPE" in
            auto | pos ) FILES_POS="$FILES_POS $SRCDIR/pos";;
        esac;
        case "$TEST_TYPE" in
            auto | neg ) FILES_NEG="$FILES_NEG $SRCDIR/neg";;
        esac;
        case "$TEST_TYPE" in
                   msil ) FILES_MSIL="$FILES_MSIL $SRCDIR/run";;
        esac;
    fi;

    if [ -d "$OBJDIR" ]; then
        OBJDIR=`cd "$OBJDIR"; pwd`;
    else
        abort "could not access directory '$OBJDIR'";
    fi

    test_all;

    if [ $FAILURE_COUNT -eq 0 ]; then
        printf_success "All tests were successful\\n";
    elif [ $FAILURE_COUNT -eq 1 ]; then
        printf_failure "There was 1 test that failed\\n";
    else
        printf_failure "There were $FAILURE_COUNT tests that failed\\n";
    fi;

#    printf_failure "\\n";
#    printf_failure "Note that currently there are 2 tests in section \"jvm backend\" that fail anyway\\n";

    if [ $FAILURE_COUNT -eq "$ERRORS" ]; then
        exit 0;
    else
        exit 1;
    fi;
}

##############################################################################
main "$@";
##############################################################################