From 87a1e4f8b9d05efc3eca7ca88b4f215606e55da7 Mon Sep 17 00:00:00 2001
From: Fabian Homborg <FHomborg@gmail.com>
Date: Sat, 13 Jun 2020 19:28:42 +0200
Subject: [PATCH] Remove expect

This should remove the last bits of expect from the codebase.
---
 tests/interactive.expect.rc | 274 ------------------------------------
 tests/interactive.fish      |  66 +--------
 2 files changed, 1 insertion(+), 339 deletions(-)
 delete mode 100644 tests/interactive.expect.rc

diff --git a/tests/interactive.expect.rc b/tests/interactive.expect.rc
deleted file mode 100644
index 1dbf1405d..000000000
--- a/tests/interactive.expect.rc
+++ /dev/null
@@ -1,274 +0,0 @@
-# vim: set filetype=expect sw=4 ts=4 et:
-
-log_user 0
-log_file -noappend interactive.tmp.log
-
-set fish ../test/root/bin/fish
-set fish_key_reader ../test/root/bin/fish_key_reader
-set fish_test_helper ../test/root/bin/fish_test_helper
-
-set timeout 5
-
-set send_human {.05 .1 5 .02 .2}
-
-proc abort {{msg "aborting"}} {
-    error $msg
-    exit 1
-}
-
-# # Debug logging
-
-set loglevel debug ;# none, info, debug
-
-proc log_info string {
-    global loglevel
-    switch $loglevel {
-        info -
-        debug {
-            send_log "\[INFO] $string\n"
-        }
-    }
-}
-
-proc log_debug string {
-    global loglevel
-    switch $loglevel {
-        debug {
-            send_log "\[DEBUG] $string\n"
-        }
-    }
-}
-
-# Utilities
-
-set prompt_counter 1
-# expect_prompt takes an argument list like `expect` does.
-# It supports a special pattern "unmatched" that is run if no
-# other provided patterns match, and a special flag "-nounmatched"
-# that marks the following pattern as not being tracked for
-# "unmatched" handling.
-# If multiple patterns are provided, they may all match. Each pattern
-# is matched at most once. The matching only ends once the prompt is
-# found.
-proc expect_prompt {args} {
-    global prompt_counter
-    upvar expect_out expect_out
-    set prompt_pat [list -re "(?:\\r\\n?|^)(?:\\\[.\\\] )?prompt $prompt_counter>(?:$|\\r)"]
-    if {[llength $args] == 1 && [string match "\n*" $args]} {
-        set args [join $args]
-    }
-    set prompt_action ""
-    set expargs {}
-    set debugpats {}
-    set nounmatched no
-    set matchidx 0
-    set matched(any) no
-    set state "firstarg"
-    foreach arg $args {
-        switch $state {
-            "pat" {
-                lappend expargs $arg
-                set state "action"
-            }
-            "action" {
-                lappend debugpats [lindex $expargs end]
-                lappend expargs [subst -nocommands {
-                    log_debug "matched extra pattern to expect_prompt: [quote \$expect_out(0,string)]"
-                    if {!\$matched($matchidx)} {
-                        set matched($matchidx) yes
-                        if {!$nounmatched} { set matched(any) yes }
-                        uplevel 1 {$arg}
-                    }
-                    exp_continue
-                }]
-                set matched($matchidx) no
-                incr matchidx
-                set state "firstarg"
-                set nounmatched no
-            }
-            "firstarg" -
-            "arg" {
-                if {$arg eq "unmatched" && $state eq "firstarg"} {
-                    set state "unmatched"
-                    continue
-                }
-                set keep yes
-                switch -glob -- $arg {
-                    -gl -
-                    -re -
-                    -ex {
-                        lappend debugpats $arg
-                        set state "pat"
-                    }
-                    -i -
-                    -timeout {
-                        set state "flagarg"
-                    }
-                    -nounmatched {
-                        set keep no
-                        set nounmatched yes
-                        set state "arg"
-                    }
-                    -* {
-                        error "BUG: unknown expect flag in expect_prompt"
-                    }
-                    default {
-                        set state "action"
-                    }
-                }
-                if {$keep} {
-                    lappend expargs $arg
-                }
-            }
-            "flagarg" {
-                lappend expargs $arg
-                set state "arg"
-            }
-            "unmatched" {
-                set state "firstarg"
-                if {$prompt_action ne ""} continue
-                set prompt_action [subst -nocommands {
-                    if {!\$matched(any)} {
-                        log_debug "triggered unmatched action in expect_prompt"
-                        log_debug "expect buffer: [quote \$expect_out(buffer)]"
-                        uplevel 1 {$arg}
-                    }
-                }]
-            }
-            default {
-                error "BUG: non-exhaustive switch in expect_prompt"
-            }
-        }
-    }
-    if {[llength $debugpats] > 0} {
-        log_info "expecting prompt $prompt_counter + \[$debugpats]"
-    } else {
-        log_info "expecting prompt $prompt_counter"
-    }
-    set expargs [concat $expargs $prompt_pat [list $prompt_action]]
-    expect {*}$expargs
-    incr prompt_counter
-}
-
-trace add execution expect {enter leave} trace_expect
-proc trace_expect {cmd args} {
-    if {[lindex $cmd 1] eq "*" && [llength $cmd] == 3} {
-        # it's an `expect "*" {..}` command, don't log it
-        return
-    }
-    switch [lindex $args end] {
-        enter {
-            log_debug "entering expect"
-            uplevel {set expect_out(buffer) {}}
-        }
-        leave {
-            set code [lindex $args 0]
-            if {$code == 0} {
-                log_debug "expect finished: [quote [uplevel set expect_out(buffer)]]"
-            } else {
-                log_debug "expect returned code $code"
-            }
-        }
-    }
-}
-
-trace add execution exp_continue enter trace_exp_continue
-proc trace_exp_continue {cmd op} {
-    log_debug "exp_continue after consuming: [quote [uplevel set expect_out(buffer)]]"
-}
-
-
-trace add execution send enter trace_send
-proc trace_send {cmd op} {
-    log_info "[quote $cmd]"
-}
-
-trace add execution spawn {enter leave} trace_spawn
-proc trace_spawn {cmd args} {
-    switch [lindex $args end] {
-        enter {
-            log_info "[quote $cmd]"
-        }
-        leave {
-            log_debug "[quote $cmd]: code [lindex $args 0], result [lindex $args 1]"
-            expect_after {
-                timeout {
-                    expect "*" {
-                        log_debug "timeout; buffer=[quote $expect_out(buffer)]"
-                    }
-                    abort "timeout"
-                }
-                eof {
-                    log_debug "eof; buffer=[quote $expect_out(buffer)]"
-                    # even though we're about to abort, we want to wait so we can get the status
-                    # note: it's possible that fish could have closed its end and then hung, and
-                    # expect doesn't provide any way to set a timeout for wait. But I think that's
-                    # an acceptable risk.
-                    puts stderr "eof; waiting on child process to exit"
-                    set status [wait]
-                    if {[lindex $status 2] == -1} {
-                        # operating system error
-                        puts stderr "error: OS error code [lindex $status 3]"
-                    } else {
-                        set msg "process [lindex $status 0] exited with status [lindex $status 3]"
-                        if {[llength $status] > 4} {
-                            append msg " ([lrange $status 4 end])"
-                        }
-                        puts stderr $msg
-                    }
-                    abort "eof"
-                }
-            }
-        }
-    }
-}
-
-proc quote string {
-    set map {
-        \\      \\\\
-        \r      \\r
-        \n      \\n
-        \t      \\t
-        \a      \\a
-        \v      \\v
-        \x1b    \\e
-        \x7f    \\x7f
-    }
-    for {set x 0} {$x<32} {incr x} {
-        lappend map [format %c $x] [format \\x%02x $x]
-    }
-    string map $map $string
-}
-
-proc send_line args {
-    if {[llength $args] > 0} {
-        lset args end [lindex $args end]\r
-    }
-    send {*}$args
-}
-
-proc rand_int {low hi} {
-    expr {entier(rand() * ($hi-$low))+$low}
-}
-
-# prints the output of `_echo_var $name` (defined in interactive.config)
-proc print_var_contents name {
-    # generate a random "guard" so we know where to stop matching
-    # the randomness is to defend against the variable value containing the guard
-    set guard [rand_int 1000000000 9999999999]
-
-    # print the variable
-    log_info "get_var_contents: $$name"
-    send_line "_echo_var $name $guard"
-
-    # match on the results
-    set pat {\r\n@GUARD:$guard@\r\n(.*)\r\n@/GUARD:$guard@\r\n}
-    expect_prompt -re [subst -nocommands -nobackslashes $pat] {
-        log_info "get_var_contents: result: [quote $expect_out(1,string)]"
-        puts $expect_out(1,string)
-        exp_continue
-    } unmatched {
-        log_debug "unmatched: [quote $expect_out(buffer)]"
-        abort "Didn't match output for variable $$name"
-    }
-}
diff --git a/tests/interactive.fish b/tests/interactive.fish
index 85129c84c..207651863 100644
--- a/tests/interactive.fish
+++ b/tests/interactive.fish
@@ -22,12 +22,10 @@ cd (dirname (status -f))
 set -gx TERM xterm
 set -e ITERM_PROFILE
 
-# Test files specified on commandline, or all *.expect files.
+# Test files specified on commandline, or all pexpect files.
 if set -q argv[1]
-    set expect_files_to_test $argv.expect
     set pexpect_files_to_test pexpects/$argv.py
 else
-    set expect_files_to_test *.expect
     set pexpect_files_to_test pexpects/*.py
 end
 
@@ -36,54 +34,6 @@ or exit
 cat interactive.config >>$XDG_CONFIG_HOME/fish/config.fish
 
 say -o cyan "Testing interactive functionality"
-function test_expect_file
-    return
-    set -l file $argv[1]
-    echo -n "Testing file $file ... "
-    set starttime (timestamp)
-    begin
-        set -lx TERM dumb
-        expect -n -c 'source interactive.expect.rc' -f $file >$file.tmp.out 2>$file.tmp.err
-    end
-    set -l exit_status $status
-    set -l res ok
-    set test_duration (delta $starttime)
-    mv -f interactive.tmp.log $file.tmp.log
-
-    diff $file.tmp.out $file.out >/dev/null
-    set -l out_status $status
-    diff $file.tmp.err $file.err >/dev/null
-    set -l err_status $status
-
-    if test $out_status -eq 0 -a $err_status -eq 0 -a $exit_status -eq 0
-        printf '%s\n' (set_color green)ok(set_color normal)" ($test_duration $unit)"
-        # clean up tmp files
-        rm -f $file.tmp.{err,out,log}
-        return 0
-    else
-        say red fail
-        if test $out_status -ne 0
-            say yellow "Output differs for file $file. Diff follows:"
-            colordiff -u $file.out $file.tmp.out
-        end
-        if test $err_status -ne 0
-            say yellow "Error output differs for file $file. Diff follows:"
-            colordiff -u $file.err $file.tmp.err
-        end
-        if test $exit_status -ne 0
-            say yellow "Exit status differs for file $file."
-            echo "Unexpected test exit status $exit_status."
-        end
-        if set -q SHOW_INTERACTIVE_LOG
-            # dump the interactive log
-            # primarily for use in travis where we can't check it manually
-            say yellow "Log for file $file:"
-            cat $file.tmp.log
-        end
-        return 1
-    end
-end
-
 function test_pexpect_file
     set -l file $argv[1]
     echo -n "Testing file $file ... "
@@ -122,20 +72,6 @@ for i in $pexpect_files_to_test
     end
 end
 
-if not type -q expect
-    say red "expect tests disabled: `expect` not found"
-    set expect_files_to_test
-end
-for i in $expect_files_to_test
-    if not test_expect_file $i
-        say -o cyan "Rerunning test $i"
-        rm -f $i.tmp.*
-        if not test_expect_file $i
-            set failed $failed $i
-        end
-    end
-end
-
 set failed (count $failed)
 if test $failed -eq 0
     say green "All interactive tests completed successfully"