testman

#!/bin/bash

# errors on
set -e

# program name and test directory
P="$(realpath "$0")"
N="$(basename "${P}")"
D="$(dirname "${P}")"
T="${D}/tests"

# load library
LIB_SH=true
. "${D}/lib.sh"

# Override user-specified filter
export CPLR_DUMP_FILTER="cat -n -"

# genvariant <name> <options> <command>...
#
# Generate or regenerate a test variant.
#
genvariant() {
    local vname="$1"
    local vopts="$2" # always 'ignore' when command given
    shift 2
    # command result
    local cres=""

    # run test and create reference
    if [ -n "$*" ]; then
        # generation - use new data
        echo "Generating test variant '${vname}'"
        # save the command
        ( nquote "$@"; echo ) > "${vname}.cmd"
        # run the test
        tee "${vname}.in" | (
          set +e
          eval "$@" 2>&1
          echo "$?" > "${vname}.res"
          set -e
        ) | tee "${vname}.out"
    else
        # regeneration - use existing data
        echo "Regenerating test variant '${vname}'"
        # run the test
        (
          set +e
          . "${vname}.cmd" 2>&1
          echo "$?" > "${vname}.res"
          set -e
        ) < "${vname}.in" | tee "${vname}.out"
    fi

    # report and store result code
    cres="$(cat "${vname}.res")"
    echo "Result: ${cres}"
    echo "${cres}" > "${vname}.res"
}

gentest() {
    local name="$1"
    shift 1

    # name of base test
    local base="${name}.base"

    if [ -n "$*" ]; then
        # generating new test
        echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! GENERATING ${name}"
        # capture input
        tee "${base}.in"
    else
        # regenerating existing test
        echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! REGENERATING ${name}"
    fi
    echo ""

    # generate variants
    local opts=""
    local vname=""
    local vopts=""
    for d in "" d; do
        for n in "" n; do
            for p in "" p; do
                for v in "" v vv; do
                    # determine name and options
                    opts="$d$n$p$v"
                    vopts=""
                    if [ -z "${opts}" ]; then
                        vname="${base}"
                    else
                        vname="${name}.variant.$d$n$p$v"
                        vopts="-$d$n$p$v"
                    fi
                    echo "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! VARIANT ${vname}"
                    # take care of automatic variants
                    if [ -n "${opts}" ]; then
                        # link the input
                        ln -f -s "${base}.in" "${vname}.in"
                        sed 's/\w+#.*$//' "${base}.cmd" | (
                            local done=""
                            while read -r line; do
                              if (echo "${line}" | grep -q " \-\-"); then
                                #say "case a: ${line}"
                                echo "${line}" | sed "s/ --/ ${vopts} --/"
                                done=true
                              elif [ -n "${done}" ] || (echo "${line}" | grep -q -e '[\\]$' -e '^[[:space:]]*$'); then
                                #say "case b: ${line}"
                                # empty lines and continued lines copied verbatim
                                echo "${line}"
                              else
                                #say "case c: ${line}"
                                printf '%s %q\n' "${line}" "${vopts}"
                                done=true
                              fi
                            done
                        ) | tee "${vname}.cmd"
                    fi
                    echo ""
                    if [ -z "${vopts}" ]; then
                        genvariant "${vname}" "ignore" "$@" < "${vname}.in"
                    else
                        genvariant "${vname}" "${vopts}" < "${vname}.in"
                    fi
                    echo ""
                done
            done
        done
    done
}

main() {
    local command="$1"
    if [ -n "${command}" ]; then
        shift 1
    fi

    # change to test directory
    cd "${T}"

    # check arguments
    if [ "${command}" = "ls" ]; then
	for test in $(alltests); do
	    echo "${test}"
	done
    elif [ "${command}" = "gen" ]; then
        local name="$1"
        if [ -n "${name}" ]; then
            shift 1
        fi
        local tests="$@"
        if [ -z "${name}" ] || [ "${name}" = "all" ]; then
            tests="$(alltests)"
        fi
        for test in ${tests}; do
            gentest "${test}"
        done
    elif [ "${command}" = "new" ]; then
        local name="$1"
        shift 1
        gentest ${name} "$@"
    elif [ "${command}" = "edit" ]; then
        local test="$1"
        if [ -z "${test}" ]; then
            command="help"
        else
            local file="$2"
            if [ -z "${file}" ]; then
                file="cmd"
            fi
            local path="${test}.base.${file}"
	    local stamp=".edit.stamp"
            touch "${stamp}"
            run_editor "${path}" && if [ "${path}" -nt "${stamp}" ]; then
                gentest "${test}"
            fi && rm -f "${stamp}" *~
        fi
    else
      command="help"
    fi

    if [ "${command}" = "help" ] || [ "${command}" = "-h" ] || [ -z "${command}" ]; then
        echo "Usage:"
        echo "    ${N} ls "
        echo "      List all base tests."
	echo ""
        echo "    ${N} new <name> <command>..."
        echo "      Execute COMMAND and generate test reference."
        echo "      User must provide INPUT. Use 'echo' as dummy."
	echo ""
	echo "    ${N} edit <name> [<file>]"
	echo "      Edit file associated with test NAME."
	echo "      Allowed files: cmd, in"
	echo "      Test will be regenerated automatically if changed."
        echo ""
        echo "    ${N} gen [all | <name>...]"
        echo "      Regenerate test reference from stored commands."
        echo "      If no names are provided then all tests will regen."
        echo ""
        return 1
    fi
}

# entry point
main "$@"