#!/bin/sh

type=float
abi=0
name=
srcdir="$(cd "${0%/*}" && pwd)/tests"
sim="$GCC_TEST_SIMULATOR"

# output_mode values:
# print only failures with minimal context
readonly really_quiet=0
# as above plus same-line output of last successful test
readonly same_line=1
# as above plus percentage
readonly percentage=2
# print one line per finished test with minimal context on failure
readonly verbose=3
# print one line per finished test with full output of the compiler and test
readonly really_verbose=4

output_mode=$really_quiet
[ -t 1 ] && output_mode=$same_line

timeout=180
run_expensive=false
if [ -n "$GCC_TEST_RUN_EXPENSIVE" ]; then
  run_expensive=true
fi
keep_failed=false
only=

usage() {
  cat <<EOF
Usage: $0 [Options] <g++ invocation>

Options:
  -h, --help          Print this message and exit.
  -q, --quiet         Disable same-line progress output (default if stdout is
                      not a tty).
  -p, --percentage    Add percentage to default same-line progress output.
  -v, --verbose       Print one line per test and minimal extra information on
                      failure.
  -vv                 Print all compiler and test output.
  -t <type>, --type <type>
                      The value_type to test (default: $type).
  -a [0-9], --abi [0-9]
                      The ABI tag subset to test (default: $abi).
  -n <name>, --name <name>
                      The name of the test (required).
  -k, --keep-failed   Keep executables of failed tests.
  --srcdir <path>     The source directory of the tests (default: $srcdir).
  --sim <executable>  Path to an executable that is prepended to the test
                      execution binary (default: the value of
                      GCC_TEST_SIMULATOR).
  --timeout-factor <x>
                      Multiply the default timeout with x.
  -x, --run-expensive Compile and run tests marked as expensive (default:
                      true if GCC_TEST_RUN_EXPENSIVE is set, false otherwise).
  -o <pattern>, --only <pattern>
                      Compile and run only tests matching the given pattern.
EOF
}

while [ $# -gt 0 ]; do
  case "$1" in
  -h|--help)
    usage
    exit
    ;;
  -q|--quiet)
    output_mode=$really_quiet
    ;;
  -p|--percentage)
    output_mode=$percentage
    ;;
  -v|--verbose)
    if [ $output_mode -lt $verbose ]; then
      output_mode=$verbose
    else
      output_mode=$really_verbose
    fi
    ;;
  -x|--run-expensive)
    run_expensive=true
    ;;
  -k|--keep-failed)
    keep_failed=true
    ;;
  -o|--only)
    only="$2"
    shift
    ;;
  -t|--type)
    type="$2"
    shift
    ;;
  -a|--abi)
    abi="$2"
    shift
    ;;
  -n|--name)
    name="$2"
    shift
    ;;
  --srcdir)
    srcdir="$2"
    shift
    ;;
  --sim)
    sim="$2"
    shift
    ;;
  --timeout-factor)
    timeout=$(awk "BEGIN { print int($timeout * $2) }")
    shift
    ;;
  --)
    shift
    break
    ;;
  --*=*)
    opt="$1"
    shift
    value=${opt#*=}
    set -- ${opt%=$value} "$value" ${1+"$@"}
    continue
    ;;
  -[ahknopqtvx][ahknopqtvx]*)
    opt="$1"
    shift
    next=${opt#??}
    set -- ${opt%$next} "-$next" ${1+"$@"}
    continue
    ;;
  -*)
    echo "Error: Unrecognized option '$1'" >&2
    exit 1
    ;;
  *)
    break
    ;;
  esac
  shift
done

if [ $output_mode = $percentage ]; then
  inc_progress() {
    {
      flock -n 9
      n=$(($(cat .progress) + 1))
      echo $n >&9
      echo $n
    } 9<>.progress
  }
fi

CXX="$1"
shift
CXXFLAGS="$@"
src="${srcdir}/${name}.cc"
shorttype=$(echo $type|sed -e 's/long /l/' -e 's/unsigned /u/' -e 's/signed /s/')
testname="${name}-${shorttype}-${abi}"
exe="${testname}.exe"
log="${testname}.log"
sum="${testname}.sum"
if [ -n "$only" ]; then
  if echo "$testname"|awk "{ exit /$only/ }"; then
    touch "$log" "$sum"
    [ $output_mode = $percentage ] && inc_progress >/dev/null
    exit 0
  fi
fi

if [ $abi -eq 0 ]; then
  abiflag=""
elif [ $abi -gt 0 -a $abi -lt 10 ]; then
  abiflag="-DEXTENDEDTESTS=$((abi-1))"
else
  echo "Error: The -a argument must be a value between 0 and 9 (inclusive)." >&2
  exit 1
fi

if [ $output_mode = $percentage ]; then
  show_progress() {
    n=$(inc_progress)
    read total < .progress_total
    total=${total}0
    printf "\e[1G\e[K[%3d %%] ${src##*/} $type $abiflag" \
      $((n * 1005 / total))
  }
  trap 'show_progress' EXIT
  prefix="\e[1G\e[K"
elif [ $output_mode = $same_line ]; then
  show_progress() {
    printf "\e[1G\e[K${src##*/} $type $abiflag"
  }
  trap 'show_progress' EXIT
  prefix="\e[1G\e[K"
else
  prefix=""
fi

fail() {
  printf "$prefix"
  echo "FAIL: $src $type $abiflag ($*)" | tee -a "$sum" "$log"
}

xpass() {
  printf "$prefix"
  echo "XPASS: $src $type $abiflag ($*)" | tee -a "$sum" "$log"
}

xfail() {
  [ $output_mode -ge $verbose ] && echo "XFAIL: $src $type $abiflag ($*)"
  echo "XFAIL: $src $type $abiflag ($*)" >> "$sum"
  echo "XFAIL: $src $type $abiflag ($*)" >> "$log"
}

pass() {
  [ $output_mode -ge $verbose ] && echo "PASS: $src $type $abiflag ($*)"
  echo "PASS: $src $type $abiflag ($*)" >> "$sum"
  echo "PASS: $src $type $abiflag ($*)" >> "$log"
}

unsupported() {
  test
  [ $output_mode -ge $verbose ] && echo "UNSUPPORTED: $src $type $abiflag ($*)"
  echo "UNSUPPORTED: $src $type $abiflag ($*)" >> "$sum"
  echo "UNSUPPORTED: $src $type $abiflag ($*)" >> "$log"
}

write_log_and_verbose() {
  echo "$*" >> "$log"
  if [ $output_mode = $really_verbose ]; then
    if [ -z "$COLUMNS" ] || ! type fmt>/dev/null; then
      echo "$*"
    else
      echo "$*" | fmt -w $COLUMNS -s - || cat
    fi
  fi
}

matches() {
  eval "case '$1' in
    $2) return 0;; esac"
  return 1
}

test_selector() {
  string="$1"
  pat_type="${string%% *}"
  if matches "$shorttype" "$pat_type"; then
    string="${string#* }"
    pat_abi="${string%% *}"
    if matches "$abi" "$pat_abi"; then
      string="${string#* }"
      pat_triplet="${string%% *}"
      [ -z "$target_triplet" ] && target_triplet=$($CXX -dumpmachine)
      if matches "$target_triplet" "$pat_triplet"; then
        pat_flags="${string#* }"
        if matches "$CXXFLAGS" "*$pat_flags*"; then
          return 0
        fi
      fi
    fi
  fi
  return 1
}

trap "rm -f '$log' '$sum' $exe; exit" INT
rm -f "$log" "$sum"
touch "$log" "$sum"

read_src_option() {
  local key tmp var
  key="$1"
  var="$2"
  [ -z "$var" ] && var="$1"
  local tmp="$(head -n25 "$src" | grep "^//\\s*${key}: ")"
  if [ -n "$tmp" ]; then
    tmp="$(echo "${tmp#//*${key}: }" | sed -e 's/ \+/ /g' -e 's/^ //' -e 's/$//')"
    eval "$var=\"$tmp\""
  else
    return 1
  fi
}

if read_src_option skip; then
  if test_selector "$skip"; then
    # silently skip this test
    exit 0
  fi
fi
if read_src_option only; then
  if ! test_selector "$only"; then
    # silently skip this test
    exit 0
  fi
fi

if ! $run_expensive; then
  if read_src_option expensive; then
    if test_selector "$expensive"; then
      unsupported "skip expensive tests"
      exit 0
    fi
  fi
fi

if read_src_option xfail; then
  if test_selector "${xfail#* }"; then
    xfail="${xfail%% *}"
  else
    unset xfail
  fi
fi

read_src_option timeout

if read_src_option timeout-factor factor; then
  timeout=$(awk "BEGIN { print int($timeout * $factor) }")
fi

log_output() {
  if [ $output_mode = $really_verbose ]; then
    maxcol=${1:-1024}
    awk "
BEGIN { count = 0 }
/^###exitstatus### [0-9]+$/ { exit \$2 }
{
  print >> \"$log\"
  if (count >= 1000) {
    print \"Aborting: too much output\" >> \"$log\"
    print \"Aborting: too much output\"
    exit 125
  }
  ++count
  if (length(\$0) > $maxcol) {
    i = 1
    while (i + $maxcol <= length(\$0)) {
      len = $maxcol
      line = substr(\$0, i, len)
      len = match(line, / [^ ]*$/)
      if (len <= 0) {
        len = match(substr(\$0, i), / [^ ]/)
        if (len <= 0) len = $maxcol
      }
      print substr(\$0, i, len)
      i += len
    }
    print substr(\$0, i)
  } else {
    print
  }
}
END { close(\"$log\") }
"
  else
    awk "
BEGIN { count = 0 }
/^###exitstatus### [0-9]+$/ { exit \$2 }
{
  print >> \"$log\"
  if (count >= 1000) {
    print \"Aborting: too much output\" >> \"$log\"
    print \"Aborting: too much output\"
    exit 125
  }
  ++count
}
END { close(\"$log\") }
"
  fi
}

verify_compilation() {
  log_output $COLUMNS
  exitstatus=$?
  if [ $exitstatus -eq 0 ]; then
    warnings=$(grep -ic 'warning:' "$log")
    if [ $warnings -gt 0 ]; then
      fail "excess warnings:" $warnings
      if [ $output_mode = $verbose ]; then
        grep -i 'warning:' "$log" | head -n5
      fi
    elif [ "$xfail" = "compile" ]; then
      xpass "test for excess errors"
    else
      pass "test for excess errors"
    fi
    return 0
  else
    if [ $exitstatus -eq 124 ]; then
      fail "timeout: test for excess errors"
    else
      errors=$(grep -ic 'error:' "$log")
      if [ "$xfail" = "compile" ]; then
        xfail "excess errors:" $errors
        exit 0
      else
        fail "excess errors:" $errors
      fi
    fi
    if [ $output_mode = $verbose ]; then
      grep -i 'error:' "$log" | head -n5
    fi
    return 1
  fi
}

verify_test() {
  log_output $COLUMNS
  exitstatus=$?
  if [ $exitstatus -eq 0 ]; then
    if [ "$xfail" = "run" ]; then
      $keep_failed || rm "$exe"
      xpass "execution test"
    else
      rm "$exe"
      pass "execution test"
    fi
    return 0
  else
    $keep_failed || rm "$exe"
    if [ $output_mode = $verbose ]; then
      grep -i fail "$log" | head -n5
    fi
    if [ $exitstatus -eq 124 ]; then
      fail "timeout: execution test"
    elif [ "$xfail" = "run" ]; then
      xfail "execution test"
    else
      fail "execution test"
    fi
    return 1
  fi
}

write_log_and_verbose "$CXX $src $@ -D_GLIBCXX_SIMD_TESTTYPE=$type $abiflag -o $exe"
{
  timeout --foreground $timeout "$CXX" "$src" "$@" "-D_GLIBCXX_SIMD_TESTTYPE=$type" $abiflag -o "$exe" 2>&1 <&-
  printf "###exitstatus### %d\n" $?
} | verify_compilation || exit 0
if [ -n "$sim" ]; then
  write_log_and_verbose "$sim ./$exe"
else
  write_log_and_verbose "./$exe"
  timeout=$(awk "BEGIN { print int($timeout / 2) }")
fi
{
  timeout --foreground $timeout $sim "./$exe" 2>&1 <&-
  printf "###exitstatus### %d\n" $?
} | verify_test || exit 0

# vim: sw=2 et cc=81 si