csonto/bash-completion
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
bash-completion/test/unit/_get_comp_words_by_ref.exp
Freddy Vulto b529cee550 Added _get_comp_words_by_ref() 
This solves the following problems:
- now one function call suffices instead of two (_get_cword; _get_pword) if
  subsequent words need to be retrieved.  Also more than two words can be
  retrieved at once, e.g.: _get_comp_words_by_ref cur prev prev2 prev3
  Also this prevents passing of `wordbreakchars' to differ in calls to
  `_get_cword' and `_get_pword', e.g.: _get_comp_words_by_ref -n : cur prev
- passing by reference, no subshell call necessary anymore
- _get_pword now also takes into account the cursor position

Added testsuite proc `assert_no_output()'

Word of caution:

The passing-arguments-by-ref system in bash doesn't work if the new variable is
also declared local.  For example:

    t() {
        local a
        # ...
        eval $1=b
    }
    a=c; t a; echo $a  # Outputs "c", should be "b"
                       # Variable "a" is 'forbidden'

To make name collissions like this less likely to happen, but make the real
function still use readable variables, I've wrapped the `*_by_ref'
functions within an additional layer using variables prefixed with double
underscores (__).  For example:

    _t() {
        # Readable variables can still be used here
        local a
        # ...
        eval $1=b
    }
    t() {
        local __a
        _t __a
        eval $1=\$__a
    }
    a=c; t a; echo $a  # Outputs "b"
                       # Variable "__a" is 'forbidden'

Now only more obfuscated variables (starting with double prefix (__)) are
forbidden to use.
2010-02-07 15:18:58 +01:00

340 lines
8.9 KiB
Plaintext
Raw Blame History

proc setup {} {
assert_bash_exec {unset COMP_CWORD COMP_LINE COMP_POINT COMP_WORDS}
save_env
}; # setup()
proc teardown {} {
assert_bash_exec {unset COMP_CWORD COMP_LINE COMP_POINT COMP_WORDS cur prev prev2}
# Delete 'COMP_WORDBREAKS' occupying two lines
assert_env_unmodified {
/COMP_WORDBREAKS=/{N
d
}
}
}; # teardown()
setup
set test "_get_comp_words_by_ref should run without errors"
assert_bash_exec {_get_comp_words_by_ref cur > /dev/null} $test
sync_after_int
# See also ./lib/completions/alias.exp. Here `_get_cword' is actually tested
# by moving the cursor left into the current word.
set test "a b|"; # | = cursor position
set cmd {COMP_WORDS=(a b); COMP_CWORD=1; COMP_LINE='a b'; COMP_POINT=3; _get_comp_words_by_ref cur prev; echo "$cur $prev"}
assert_bash_list {"b a"} $cmd $test
sync_after_int
set test "a |"; # | = cursor position
set cmd {COMP_WORDS=(a); COMP_CWORD=1; COMP_LINE='a '; COMP_POINT=2; _get_comp_words_by_ref cur prev; echo "$cur $prev"}
assert_bash_list {" a"} $cmd $test
sync_after_int
set test "a b |"; # | = cursor position
set cmd {COMP_WORDS=(a b ''); COMP_CWORD=2; COMP_LINE='a b '; COMP_POINT=4; _get_comp_words_by_ref cur prev prev2; echo "$cur $prev $prev2"}
assert_bash_list {" b a"} $cmd $test
sync_after_int
set test "a b | with WORDBREAKS -= :"; # | = cursor position
set cmd {COMP_WORDS=(a b ''); COMP_CWORD=2; COMP_LINE='a b '; COMP_POINT=4; _get_comp_words_by_ref -n : cur; printf %s "$cur"}
assert_bash_list {} $cmd $test
sync_after_int
set test "a b|c"; # | = cursor position
set cmd {COMP_WORDS=(a bc); COMP_CWORD=1; COMP_LINE='a bc'; COMP_POINT=3; _get_comp_words_by_ref cur prev; echo "$cur $prev"}
assert_bash_list {"b a"} $cmd $test
sync_after_int
set test {a b\ c| should return b\ c}; # | = cursor position
set cmd {COMP_WORDS=(a 'b\ c'); COMP_CWORD=1; COMP_LINE='a b\ c'; COMP_POINT=6; _get_comp_words_by_ref cur prev; echo "$cur $prev"}
assert_bash_list {"b\\ c a"} $cmd $test
sync_after_int
set test {a b\| c should return b\ }; # | = cursor position
set cmd {COMP_WORDS=(a 'b\ c'); COMP_CWORD=1; COMP_LINE='a b\ c'; COMP_POINT=4; _get_comp_words_by_ref cur prev; echo "$cur $prev"}
assert_bash_list {"b\\ a"} $cmd $test
sync_after_int
set test {a "b\|}; #"# | = cursor position
set cmd {COMP_WORDS=(a '"b\'); COMP_CWORD=1; COMP_LINE='a "b\'; COMP_POINT=5; _get_comp_words_by_ref cur prev; echo "$cur $prev"}
assert_bash_list {"\"b\\ a"} $cmd $test
sync_after_int
set test {a 'b c|}; # | = cursor position
if {
[lindex $::BASH_VERSINFO 0] == 4 &&
[lindex $::BASH_VERSINFO 1] == 0 &&
[lindex $::BASH_VERSINFO 2] < 35
} {
set cmd {COMP_WORDS=(a "'" b c); COMP_CWORD=3}
} else {
set cmd {COMP_WORDS=(a "'b c"); COMP_CWORD=1}
}; # if
append cmd {; COMP_LINE="a 'b c"; COMP_POINT=6; _get_comp_words_by_ref cur prev; echo "$cur $prev"}
send "$cmd\r"
expect -ex "$cmd\r\n"
expect {
-ex "'b c a\r\n/@" { pass "$test" }
-ex "c b\r\n/@" {
if {
[lindex $::BASH_VERSINFO 0] == 4 &&
[lindex $::BASH_VERSINFO 1] == 0 &&
[lindex $::BASH_VERSINFO 2] < 35
} {xfail "$test"} {fail "$test"}
}
}; # expect
sync_after_int
set test {a "b c|}; #"# | = cursor position
if {
[lindex $::BASH_VERSINFO 0] == 4 &&
[lindex $::BASH_VERSINFO 1] == 0 &&
[lindex $::BASH_VERSINFO 2] < 35
} {
set cmd {COMP_WORDS=(a "\"" b c); COMP_CWORD=3}
} else {
set cmd {COMP_WORDS=(a "\"b c"); COMP_CWORD=1}
}; # if
append cmd {; COMP_LINE="a \"b c"; COMP_POINT=6}
assert_bash_exec $cmd
set cmd {_get_comp_words_by_ref cur prev; echo "$cur $prev"};
send "$cmd\r"
expect -ex "$cmd\r\n"
expect {
-ex "\"b c a\r\n/@" { pass "$test" }
-ex "c b\r\n/@" {
if {
[lindex $::BASH_VERSINFO 0] == 4 &&
[lindex $::BASH_VERSINFO 1] == 0 &&
[lindex $::BASH_VERSINFO 2] < 35
} {xfail "$test"} {fail "$test"}
}
}; # expect
sync_after_int
set test {a b:c| with WORDBREAKS += :}; # | = cursor position
if {[lindex $::BASH_VERSINFO 0] <= 3} {
set cmd {COMP_WORDS=(a "b:c"); COMP_CWORD=1}
set expected {"b:c a"}
} else {
set cmd {add_comp_wordbreak_char :; COMP_WORDS=(a b : c); COMP_CWORD=3}
set expected {"c :"}
}; # if
append cmd {; COMP_LINE='a b:c'; COMP_POINT=5}
# NOTE: Split-send cmd to prevent backspaces (\008) in output
assert_bash_exec $cmd $test
set cmd {_get_comp_words_by_ref cur prev; echo "$cur $prev"}
assert_bash_list $expected $cmd $test
sync_after_int
set test {a b:c| with WORDBREAKS -= :}; # | = cursor position
if {[lindex $::BASH_VERSINFO 0] <= 3} {
set cmd {COMP_WORDS=(a "b:c"); COMP_CWORD=1}
} else {
set cmd {COMP_WORDS=(a b : c); COMP_CWORD=3}
}; # if
append cmd {; COMP_LINE='a b:c'; COMP_POINT=5}
assert_bash_exec $cmd $test
set cmd {_get_comp_words_by_ref -n : cur prev; echo "$cur $prev"}
assert_bash_list {"b:c a"} $cmd $test
sync_after_int
set test {a b c:| with WORDBREAKS -= :}; # | = cursor position
if {[lindex $::BASH_VERSINFO 0] <= 3} {
set cmd {COMP_WORDS=(a b c:); COMP_CWORD=2}
} else {
set cmd {COMP_WORDS=(a b c :); COMP_CWORD=3}
}; # if
append cmd {; COMP_LINE='a b c:'; COMP_POINT=6}
assert_bash_exec $cmd $test
set cmd {_get_comp_words_by_ref -n : cur prev; echo "$cur $prev $prev2"}
assert_bash_list {"c: b a"} $cmd $test
sync_after_int
set test {a :| with WORDBREAKS -= : should return :}; # | = cursor position
set cmd {COMP_WORDS=(a :); COMP_CWORD=1; COMP_LINE='a :'; COMP_POINT=3}
assert_bash_exec $cmd
set cmd {_get_comp_words_by_ref -n : cur prev; echo "$cur $prev"}
assert_bash_list {": a"} $cmd $test
sync_after_int
set test {a b::| with WORDBREAKS -= : should return b::}; # | = cursor position
if {[lindex $::BASH_VERSINFO 0] <= 3} {
set cmd {COMP_WORDS=(a "b::"); COMP_CWORD=1}
} else {
set cmd {COMP_WORDS=(a b ::); COMP_CWORD=2}
}; # if
append cmd {; COMP_LINE='a b::'; COMP_POINT=5}
assert_bash_exec $cmd
set cmd {_get_comp_words_by_ref -n : cur prev; echo "$cur $prev"}
assert_bash_list {"b:: a"} $cmd $test
sync_after_int
# This test makes sure `_get_cword' doesn't use `echo' to return it's value,
# because -n might be interpreted by `echo' and thus will not be returned.
set test "a -n| should return -n"; # | = cursor position
set cmd {COMP_WORDS=(a -n); COMP_CWORD=1; COMP_LINE='a -n'; COMP_POINT=4}
assert_bash_exec $cmd
set cmd {_get_comp_words_by_ref cur; printf %s $cur}
assert_bash_list -n $cmd $test
sync_after_int
set test {a b>c| should return c}; # | = cursor position
set cmd {COMP_WORDS=(a b \> c); COMP_CWORD=3; COMP_LINE='a b>c'; COMP_POINT=5}
assert_bash_exec $cmd
set cmd {_get_comp_words_by_ref cur prev; echo "$cur"}
assert_bash_list c $cmd $test
sync_after_int
set test {a b=c| should return b=c (bash-3) or c (bash-4)}; # | = cursor position
if {[lindex $::BASH_VERSINFO] <= 3} {
set cmd {COMP_WORDS=(a "b=c"); COMP_CWORD=1}
set expected b=c
} else {
set cmd {COMP_WORDS=(a b = c); COMP_CWORD=3}
set expected c
}; # if
append cmd {; COMP_LINE='a b=c'; COMP_POINT=5}
assert_bash_exec $cmd
set cmd {_get_comp_words_by_ref cur prev; echo "$cur"}
assert_bash_list $expected $cmd $test
sync_after_int
set test {a *| should return *}; # | = cursor position
set cmd {COMP_WORDS=(a \*); COMP_CWORD=1; COMP_LINE='a *'; COMP_POINT=4}
assert_bash_exec $cmd
set cmd {_get_comp_words_by_ref cur; echo "$cur"}
assert_bash_list * $cmd $test
sync_after_int
set test {a $(b c| should return $(b c}; # | = cursor position
set cmd {COMP_WORDS=(a '$(b c'); COMP_CWORD=1; COMP_LINE='a $(b c'; COMP_POINT=7}
assert_bash_exec $cmd
set cmd {_get_comp_words_by_ref cur; printf %s "$cur"}
send "$cmd\r"
expect -ex "$cmd\r\n"
expect {
-ex "\$(b c/@" { pass "$test" }
# Expected failure on bash-4
-ex "c/@" { xfail "$test" }
}; # expect
sync_after_int
set test {a $(b c\ d| should return $(b c\ d}; # | = cursor position
set cmd {COMP_WORDS=(a '$(b c\ d'); COMP_CWORD=1; COMP_LINE='a $(b c\ d'; COMP_POINT=10}
assert_bash_exec $cmd
set cmd {_get_comp_words_by_ref cur; printf %s "$cur"}
#assert_bash_list {{$(b\ c\\\ d}} $cmd $test
send "$cmd\r"
expect -ex "$cmd\r\n"
expect {
-ex "\$(b c\\ d/@" { pass "$test" }
# Expected failure on bash-4
-ex "c\\ d/@" { xfail "$test" }
}; # expect
sync_after_int
set test {a 'b&c| should return 'b&c}; # | = cursor position
if {
[lindex $::BASH_VERSINFO 0] == 4 &&
[lindex $::BASH_VERSINFO 1] == 0 &&
[lindex $::BASH_VERSINFO 2] < 35
} {
set cmd {COMP_WORDS=(a "'" b "&" c); COMP_CWORD=4}
} else {
set cmd {COMP_WORDS=(a "'b&c"); COMP_CWORD=1}
}; # if
append cmd {; COMP_LINE="a 'b&c"; COMP_POINT=6}
assert_bash_exec $cmd
set cmd {_get_comp_words_by_ref cur prev; printf %s "$cur"}
send "$cmd\r"
expect -ex "$cmd\r\n"
expect {
-ex "'b&c/@" { pass "$test" }
-ex "c/@" {
if {
[lindex $::BASH_VERSINFO 0] == 4 &&
[lindex $::BASH_VERSINFO 1] == 0 &&
[lindex $::BASH_VERSINFO 2] < 35
} {xfail "$test"} {fail "$test"}
}
}; # expect
sync_after_int
teardown
Reference in New Issue View Git Blame Copy Permalink