source: git/factory/fex/runfex @ 5df7d0

#! /bin/bash
# $Id$

#{{{ docu
#
# runfex - run factory example collection.
#
#}}}

set -o nounset
set -o noglob

trap signalHandlerInterrupt SIGINT
trap signalHandlerQuit SIGQUIT

#
# - functions.
#

#{{{ signalHandlerInterrupt (), signalHandlerQuit ()
#{{{ docu
#
# signalHandler*() - catch signals.
#
#}}}
signalHandlerInterrupt()
{
    warn "received signal SIGINT"
    exit
}

signalHandlerQuit()
{
    warn "received signal SIGQUIT"
    exit
}
#}}}

#{{{ warn ()
#{{{ docu
#
# warn() - print arguments to stderr prefixed by ExecName.
#
# ExecName (global constant): name of the shell script
#   being executed
#
#}}}
readonly ExecName="$0"

warn()
{
    echo "$ExecName:" "${@-}" >&2
}
#}}}

#{{{ usage ()
usage()
{
echo "
Usage: runfex [<options>] [<factoryOpts>] [<factoryEnvSpec>] <fexFile> [<examplePatterns>]

Runs all examples in <fexFile> matching <examplePattern>.
<examplePatterns> should be regular shell patterns, which may be
preceded by a \`^' to exclude all examples matching <examplePattern>.

When run in foreground, SIGQUIT immediately interrupts \`runfex',
while SIGINT only interrupts the example currently being
calculated.  In background, SIGTERM interrupts \`runfex' after the
current example has been finished.

<options>:  -d:         debug mode.  In debug mode, examples are
                        echoed to stdout instead of being executed.
            -C <runConfiguration>: specifies which object/executable
                        configuration to use.  Defaults to \`opt'.
            -t:         do not run checks

Besides from regular shell commands, the commands \`collection'
and \`example' may be used in a Factory example file.
\`collection' specifies options and environment common to a
collection of examples, \`example' defines an example.

collection <collectionName> [<collectionOptions>] [<factoryOpts>] [<factoryEnvSpec>]
example <exampleName> [<exampleOptions>] [<factoryOpts>] [<factoryEnvSpec>] <example>

<collectionOptions>/<exampleOptions>:
            -n <note>: specifies comment on the collection/example

<factoryOpts>:
            -a <time>:  sets alarm option
            -c <times>: sets times option
            -O <options>: specifies optional arguments
            -o <outputOptions>: specifies which results to print

<outputOptions>:
            <number>: column width              x: do not print anything
            h: header                           p: characteristic
            s: switches                         v: variables
            n: number fo runs                   g: random generator seed
            f: Factories version                t: time
            c: check                            r: result" \
    >& 2
}
#}}}

#{{{ defineSkip ()
#{{{ docu
#
# defineSkip() - define function skipExample().
#
# rest: the patterns
#
# One function at least that does not use neither global
# variables nor constants.
#
#}}}
defineSkip()
{
    typeset regExp=""
    typeset notRegExp=""
    typeset rawArg arg

    for rawArg; do
        # check for leading ^
        arg="${rawArg#^}"
        if [ "$rawArg" = "$arg" ]; then
            regExp="$regExp|$arg"
        else
            notRegExp="$notRegExp|$arg"
        fi
        shift
    done
    regExp="${regExp#|}"
    notRegExp="${notRegExp#|}"

    if [ -z "$regExp" -a -z "$notRegExp" ]; then
        eval "
skipExample()
{
    return 1
}
"
    elif [ -n "$regExp" -a -z "$notRegExp" ]; then
        eval "
skipExample()
{
    case \"\$1\" in
        ($regExp) return 1 ;;
        (*) return 0 ;;
    esac
}
"
    elif [ -z "$regExp" -a -n "$notRegExp" ]; then
        eval "
skipExample()
{
    case \"\$1\" in
        ($notRegExp) return 0 ;;
        (*) return 1 ;;
    esac
}
"
    else
        eval "
skipExample()
{
    case \"\$1\" in
        ($notRegExp) return 0 ;;
        ($regExp) return 1 ;;
        (*) return 0 ;;
    esac
}
"
    fi
}
#}}}

#{{{ runAlgorithm ()
#{{{ docu
#
# runAlgorithm() - run algorithm with the correct options.
#
# To a pity, there is a lot of global variables necessary to
# determine the "correct options".  The run* variables are set
# in main program, the collection* variables in collection()
# and the example* variables in example().
# All of these variables are exclusively used here.
#
# $1: debugMode
# $2: algorithm to run
# rest: its arguments
#
# runConfiguration (global variable): which configurations'
#   executables to use
# run* (global variables): options, optional arguments, and
#   environment specified at run level
# collection* (global variables): options, optional arguments,
#   and environment specified at collection level
# example* (global variables): options, optional arguments,
#   and environment specified at example level
#
#}}}
runConfiguration="opt"

runOptions=""
runOptArguments=""
runEnvironment=""

collectionOptions=""
collectionOptArguments=""
collectionEnvironment=""

exampleOptions=""
exampleOptArguments=""
exampleEnvironment=""

runAlgorithm()
{
    typeset debugMode="$1" \
            name="$2"
    shift 2

    # now its time to paste the options together
    $debugMode "$name.$runConfiguration" \
        $collectionOptions $exampleOptions $runOptions -oa -- \
        $collectionEnvironment $exampleEnvironment $runEnvironment \
        ${runOptArguments:-${exampleOptArguments:-${collectionOptArguments}}} \
        "$@"
}
#}}}

#{{{ printData ()
#{{{ docu
#
# printData() - print example data.
#
# Yet another bunch of global variables.  The *OutputOptions are
# set by the main program, collection(), and example(), resp.,
# and determine which information to print.  All the variables
# are used exclusively here.
#
# $1: name
# $2: note
#
# defColWidth (global constant): default width to print results
# *OutputOptions (global variables): which information to print
#
#}}}
typeset -ir defColWidth=80

runOutputOptions=""
collectionOutputOptions=""
exampleOutputOptions=""

printData()
{
    typeset -i colWidth

    typeset name="$1" \
            note="$2" \
            options="${runOutputOptions:-${exampleOutputOptions:-${collectionOutputOptions}}}" \
            line=""

    # get column width (we use line as a dummy here)
    line="$( echo "$options" | sed s/[^0-9]//g )"
    colWidth=${line:-$defColWidth}

    case "$options" in
        (*x*) return ;;
    esac

    case "$options" in
        (*h*)
            # do some pretty printing
            if [ ${#name} -lt 7 ]; then
                echo "$name:            $note."
            elif  [ ${#name} -lt 15 ]; then
                echo "$name:    $note."
            else
                echo "$name: $note."
            fi ;;
    esac
    if read line; then case "$options" in
        (*p*) echo "$line" ;;
    esac; fi
    if read line; then case "$options" in
        (*s*) echo "$line" ;;
    esac; fi
    if read line; then case "$options" in
        (*v*) echo "$line" ;;
    esac; fi
    if read line; then case "$options" in
        (*n*) echo "$line" ;;
    esac; fi
    if read line; then case "$options" in
        (*g*) echo "$line" ;;
    esac; fi
    if read line; then case "$options" in
        (*f*) echo "$line" ;;
    esac; fi
    if read line; then case "$options" in
        (*t*) echo "$line" ;;
    esac; fi
    if read line; then case "$options" in
        (*c*) echo "$line" ;;
    esac; fi

    # format the result
    case "$options" in
        (*r*)
            if [ $colWidth = 0 ]; then
                cat -u
            else
                fold -s -w "$colWidth"
            fi ;;
    esac
}
#}}}

#{{{ example ()
#{{{ docu
#
# example() - run an example.
#
# Sets the example* variables from the commandline.  Runs the
# example in dependency on debugMode and on the result of
# skipExample().  Collects data from the example in the alg*
# variables for printData().
#
# debugMode (global variable): set by main program.  Whether to
#   run examples or to print them.
#
#}}}
debugMode=""

example()
{
    typeset name="" \
            note="" \
            \
            options="" \
            optArguments="" \
            environment="" \
            \
            outputOptions=""

    # read example name and skip if necessary
    if [ "$#" = "0" ]; then
        warn "no example name specified"
        exit 1
    fi
    name="$1"
    shift

    if skipExample "$name"; then
        if [ -n "$debugMode" ]; then
            echo "skipping $name"
        fi
        return
    else
        warn "running $name"
    fi
    
    # read options
    typeset opt
    while getopts "n:a:c:O:o:" opt; do
        case "$opt" in
            (n) note="$OPTARG" ;;
            (a) options="$options -a$OPTARG" ;;
            (c) options="$options -c$OPTARG" ;;
            (O) optArguments="$optArguments $OPTARG" ;;
            (o) outputOptions="$OPTARG" ;;
            (?) warn "bad example option"; exit 1 ;;
        esac
    done
    # shift options and reset OPTIND
    typeset -i optind
    optind=OPTIND-1
    shift $optind
    OPTIND=1

    # read environment
    while [ "${1-}" != "${1+${1#/}}" ]; do
        environment="$environment $1"
        shift
    done

    # set global variables
    exampleOptions="$options"
    exampleOptArguments="$optArguments"
    exampleEnvironment="$environment"
    exampleOutputOptions="$outputOptions"

    # run algorithm and print data
    if [ -n "$debugMode" ]; then
        runAlgorithm "echo" "$@"
    else
        runAlgorithm "" "$@" | printData "$name" "$note"
    fi
}
#}}}

#{{{ collection ()
#{{{ docu
#
# collection() - set up collection data.
#
# Sets the collection* variables from commandline.
#
#}}}
collection()
{
    typeset options="" \
            optArguments="" \
            environment="" \
            \
            outputOptions="" \
    
    # read collection name (and ignore it)
    if [ "$#" = "0" ]; then
        warn "no collection name specified"
        exit 1
    fi
    shift

    # read options
    typeset opt
    while getopts "n:a:c:O:o:" opt; do
        case "$opt" in
            (n) : ;;
            (a) options="$options -a$OPTARG" ;;
            (c) options="$options -c$OPTARG" ;;
            (O) optArguments="$optArguments $OPTARG" ;;
            (o) outputOptions="$OPTARG" ;;
            (?) warn "bad collection option"; exit 1 ;;
        esac
    done
    # shift options and reset OPTIND
    typeset -i optind
    optind=OPTIND-1
    shift $optind
    OPTIND=1

    # read environment
    while [ "${1-}" != "${1+${1#/}}" ]; do
        environment="$environment $1"
        shift
    done

    # set global variables
    collectionOptions="$options"
    collectionOptArguments="$optArguments"
    collectionEnvironment="$environment"
    collectionOutputOptions="$outputOptions"
}
#}}}

#{{{ main program
#{{{ docu
#
# - main program.
#
# Sets the run* variables for runAlgorithm() and printData()
# from commandline.  Sets debugMode for example().  Reads the
# collection.
#
#}}}
typeset configuration="opt" \
        \
        options="" \
        optArguments="" \
        environment="" \
        \
        outputOptions="" \
        \
        fexFile=""

# read options
typeset opt
while getopts "dC:ta:c:O:o:" opt; do
    case "$opt" in
        (d)  debugMode="1" ;;
        (C)  configuration="$OPTARG" ;;
        (t)  options="$options -t" ;;
        (a)  options="$options -a$OPTARG" ;;
        (c)  options="$options -c$OPTARG" ;;
        (O)  optArguments="$optArguments $OPTARG" ;;
        (o)  outputOptions="$OPTARG" ;;
        (?)  warn "bad run option"; usage; exit 1 ;;
    esac
done
# shift options and reset OPTIND
typeset -i optind
optind=OPTIND-1
shift $optind
OPTIND=1

# read environment
while [ "${1-}" != "${1+${1#/}}" ]; do
    environment="$environment $1"
    shift
done

# process rest of arguments
if [ "$#" = "0" ]; then
    warn "no fexFile specified"
    usage
    exit 1
fi
fexFile="${1%.fex}"
shift

defineSkip "$@"

# before going on, check for existence of collection
if [ ! -f "$fexFile.fex" ]; then
    warn "collection $fexFile.fex not found"
    exit 1
fi

# reset factory environemnt to exclude external influences
FTEST_ENV=""
FTEST_CIRCLE=""
FTEST_ALARM=""

# set global variables and execute collection
runConfiguration="$configuration"
runOptions="$options"
runOptArguments="$optArguments"
runEnvironment="$environment"
runOutputOptions="$outputOptions"

. "$fexFile.fex"
#}}}