kakoune

Fork of kakoune, an acceptable text editor
git clone git://git.laack.co/kakoune.git
Log | Files | Refs

run (6680B)


      1 #!/bin/sh
      2 
      3 # Color codes ├──────────────────────────────────────────────────────────────────
      4 none='\033[0m'; red='\033[31m'; green='\033[32m'; yellow='\033[33m'; magenta='\033[35m'; bold='\033[1m'
      5 
      6 # Main ├────────────────────────────────────────────────────────────────────────
      7 
      8 main() {
      9   kak_commands='
     10         set global autoreload yes
     11         set global autoinfo ""
     12         set global autocomplete ""
     13         try %{
     14             exec -save-regs / %{%s%\(\K[^)]+\)<ret>a<backspace><esc>i<backspace><backspace><c-u><esc><a-;>}
     15         } catch %{ exec gg }
     16         try %{
     17             eval -no-hooks -draft %{ edit -existing rc; delete-buffer }
     18             try %{ source rc } catch %{ echo -to-file stderr -end-of-line %val{error}; kill! 1 }
     19         }
     20         try %{ eval -no-hooks -draft %{ edit cmd; exec \%H"zy; delete-buffer } }
     21         hook global RuntimeError "\d+:\d+: (.+)" %{ echo -to-file stderr -end-of-line %val{hook_param_capture_1}; kill! 1 }
     22         exec -with-maps -with-hooks %reg{z}
     23         exec -with-hooks <c-l>
     24       '
     25 
     26   root="$PWD"
     27   testdir="$(dirname $0)"
     28   kak="$(realpath $testdir)/../src/kak"
     29   tmpdir="${TMPDIR:-/tmp}"
     30   work=$(mktemp -d $tmpdir/kak-tests.XXXXXXXX)
     31   session="kak-tests"
     32   if [ -n "$XDG_RUNTIME_DIR" ]; then
     33     session_path="${XDG_RUNTIME_DIR}/kakoune/$session"
     34   else
     35     session_path="${TMPDIR:-/tmp}/kakoune/${USER}/$session"
     36   fi
     37   trap "rm -Rf $work" EXIT
     38 
     39   number_tests=0
     40   number_failures=0
     41   for dir in $(find "${@:-$testdir}" -type d | sed 's|^\./||' | sort); do
     42     cd $root/$dir;
     43     if [ ! -f cmd ]; then
     44       echo "$dir"
     45       continue
     46     elif [ -x enabled ] && ! ./enabled >/dev/null 2>&1; then
     47       printf "${yellow}$dir (disabled)${none}\n"
     48       continue
     49     fi
     50 
     51     env_vars=$(ls -1 kak_* 2>/dev/null)
     52     number_tests=$(($number_tests + 1))
     53     mkdir -p $work/$dir
     54     cp in cmd rc env $work/$dir/ 2>/dev/null
     55     cd $work/$dir;
     56 
     57     mkfifo ui-in ui-out
     58     touch in; cp in out
     59     rm -f "$session_path"
     60     (
     61       if [ -f env ]; then
     62         . ./env
     63       fi
     64       exec $DEBUGGER $kak out -n -s "$session" -ui json -e "$kak_commands" >ui-out <ui-in
     65     ) &
     66     kakpid=$!
     67 
     68     failed=0
     69     exec 4<ui-out 3>ui-in
     70 
     71     if [ -f "${root}/${dir}/script" ]; then
     72       . "${root}/${dir}/script"
     73     else
     74       # At least wait for kak to initialize so we don't deadlock
     75       ui_out '{ "jsonrpc": "2.0", "method": "set_ui_options", "params": [{}] }'
     76     fi
     77 
     78     finished_commands |$kak -p "$session" 2>/dev/null
     79     cat <&4 >/dev/null
     80 
     81     wait $kakpid
     82     retval=$?
     83 
     84     exec 3>&- 4<&-
     85 
     86     if [ ! -e $root/$dir/error ]; then # failure not expected
     87       if [ $retval -ne 0 ]; then
     88         printf "${red}%s${none}\n" "$dir"
     89         echo "  Kakoune returned error $retval"
     90         [ -f stderr ] && printf "  ${yellow}%s${none}\n" "$(cat stderr)"
     91         failed=1
     92       else
     93         for file in out $env_vars; do
     94           if [ -f $root/$dir/$file ] && ! cmp -s $root/$dir/$file $file; then
     95             fail_ifn
     96             show_diff $root/$dir/$file $file
     97           fi
     98         done
     99         if [ $failed -ne 0 ] && [ -f debug ]; then
    100           printf "\n${yellow}debug buffer:${none}\n"
    101           cat debug
    102         fi
    103       fi
    104     else # failure expected
    105       if [ -f stderr ]; then
    106         sed -i -e 's/^[0-9]*:[0-9]*: //g' stderr
    107         if [ -s $root/$dir/error ] && ! cmp -s $root/$dir/error stderr; then
    108           printf "${yellow}%s${none}\n" "$dir"
    109           show_diff $root/$dir/error stderr
    110           failed=1
    111         fi
    112       elif [ $retval -eq 0 ]; then
    113         printf "${red}%s${none}\n" "$dir"
    114         echo "  Expected failure, but Kakoune returned 0"
    115         failed=1
    116       fi
    117     fi
    118 
    119     if [ $failed -eq 0 ]; then
    120       printf "${green}%s${none}\n" "$dir"
    121     else
    122       number_failures=$(($number_failures + 1))
    123     fi
    124   done
    125 
    126   if [ $number_failures -gt 0 ]; then
    127     color=$red
    128   else
    129     color=$green
    130   fi
    131   printf "\n${color}Summary: %s tests, %s failures${none}\n" $number_tests $number_failures
    132   exit $number_failures
    133 }
    134 
    135 # Utility ├─────────────────────────────────────────────────────────────────────
    136 
    137 fail_ifn() {
    138   if [ $failed -eq 0 ]; then
    139     printf "${red}%s${none}\n" "$dir"
    140     failed=1
    141   fi
    142 }
    143 
    144 assert_eq() {
    145   if [ ! "$1" = "$2" ]; then
    146     fail_ifn
    147     if command -v git > /dev/null; then
    148         echo "$1" > expected
    149         echo "$2" > actual
    150         git --no-pager diff --color-words --no-index expected actual
    151     else
    152         printf "  ${red}- %s\n  ${green}+ %s${none}\n" "$1" "$2"
    153     fi
    154   fi
    155 }
    156 
    157 show_diff() {
    158   diff -u $1 $2 | while IFS='' read -r line; do
    159     first_character=$(printf '%s\n' "$line" | cut -b 1)
    160     case $first_character in
    161       +) color=$green ;;
    162       -) color=$red ;;
    163       @) color=$magenta ;;
    164       *) color=$none ;;
    165     esac
    166     printf "${color}%s${none}\n" "$line"
    167   done
    168 }
    169 
    170 finished_commands() {
    171   printf %s 'eval -client client0 %{
    172                eval -buffer *debug* write -force debug
    173             '
    174   for env_var in $env_vars; do
    175       case $env_var in
    176           kak_quoted_*) printf 'echo -to-file %s -end-of-line -quoting shell -- %s\n' "$env_var" "%val{${env_var##kak_quoted_}}" ;;
    177           kak_*) printf 'echo -to-file %s -end-of-line -- %s\n' "$env_var" "%val{${env_var##kak_}}" ;;
    178       esac
    179   done
    180   printf %s '
    181                write -force out
    182                quit!
    183              }
    184             '
    185 }
    186 
    187 # Script Assertions ├───────────────────────────────────────────────────────────
    188 
    189 ui_in() {
    190   printf '%s\n' "$1" >&3
    191 }
    192 
    193 ui_out() {
    194   arg=$1
    195   shift
    196   case "$arg" in
    197   -ignore)
    198     skip_count=$1
    199     shift
    200     while [ $skip_count -gt 0 ]; do
    201       read -r event <&4
    202       skip_count=$(( skip_count - 1 ))
    203     done
    204     ;;
    205   -until)
    206     expected=$1
    207     shift
    208     while read -r event <&4; do
    209       [ "$event" = "$expected" ] && break
    210     done
    211     ;;
    212   -until-grep)
    213     pattern=$1
    214     shift
    215     while read -r event <&4; do
    216       if printf %s "$event" | grep "$pattern" >/dev/null; then
    217         if [ $# -ne 0 ]; then
    218             assert_eq "$1" "$event"
    219             shift
    220         fi
    221         break
    222       fi
    223     done
    224     ;;
    225   *)
    226     read -r event <&4
    227     assert_eq "$arg" "$event"
    228     ;;
    229   esac
    230 }
    231 
    232 main "$@"