Mirrors/fish-shell
2
0
Fork 0
mirror of https://github.com/fish-shell/fish-shell synced 2024-12-27 05:13:10 +00:00
Code Issues Projects Releases Packages Wiki Activity

Remove expect

Browse source 
This should remove the last bits of expect from the codebase.
This commit is contained in:
Fabian Homborg 2020-06-13 19:28:42 +02:00
parent c6dffa226f
commit 87a1e4f8b9
2 changed files with 1 additions and 339 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

274
tests/interactive.expect.rc
View file

@ -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"
}
}

66
tests/interactive.fish
View file

@ -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"