kevin/neovim
1
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2024-12-29 14:41:06 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #24748 from zeertzjq/vim-8.2.3818

Browse Source 
vim-patch:8.2.{3818,3822,3908,3982}: filter()/map() on a string
This commit is contained in:
zeertzjq 2023-08-17 13:38:41 +08:00 committed by GitHub
commit 7f51829cf7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 239 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
runtime/doc/builtin.txt generated
View File

@ -1623,10 +1623,11 @@ filewritable({file}) *filewritable()*
directory, and we can write to it, the result is 2.
filter({expr1}, {expr2}) *filter()*
{expr1} must be a |List|, |Blob|, or a |Dictionary|.
{expr1} must be a |List|, |String|, |Blob| or |Dictionary|.
For each item in {expr1} evaluate {expr2} and when the result
is zero remove the item from the |List| or |Dictionary|. For a
|Blob| each byte is removed.
is zero or false remove the item from the |List| or
|Dictionary|. Similarly for each byte in a |Blob| and each
character in a |String|.
{expr2} must be a |string| or |Funcref|.
@ -1662,14 +1663,16 @@ filter({expr1}, {expr2}) *filter()*
< If you do not use "val" you can leave it out: >vim
call filter(myList, {idx -> idx % 2 == 1})
<
The operation is done in-place. If you want a |List| or
|Dictionary| to remain unmodified make a copy first: >vim
For a |List| and a |Dictionary| the operation is done
in-place. If you want it to remain unmodified make a copy
first: >vim
let l = filter(copy(mylist), 'v:val =~ "KEEP"')
< Returns {expr1}, the |List|, |Blob| or |Dictionary| that was
filtered. When an error is encountered while evaluating
{expr2} no further items in {expr1} are processed. When
{expr2} is a Funcref errors inside a function are ignored,
< Returns {expr1}, the |List| or |Dictionary| that was filtered,
or a new |Blob| or |String|.
When an error is encountered while evaluating {expr2} no
further items in {expr1} are processed.
When {expr2} is a Funcref errors inside a function are ignored,
unless it was defined with the "abort" flag.
finddir({name} [, {path} [, {count}]]) *finddir()*
@ -4062,15 +4065,18 @@ luaeval({expr} [, {expr}]) *luaeval()*
to Vim data structures. See |lua-eval| for more details.
map({expr1}, {expr2}) *map()*
{expr1} must be a |List|, |Blob| or |Dictionary|.
Replace each item in {expr1} with the result of evaluating
{expr2}. For a |Blob| each byte is replaced.
{expr1} must be a |List|, |String|, |Blob| or |Dictionary|.
When {expr1} is a |List|| or |Dictionary|, replace each
item in {expr1} with the result of evaluating {expr2}.
For a |Blob| each byte is replaced.
For a |String|, each character, including composing
characters, is replaced.
If the item type changes you may want to use |mapnew()| to
create a new List or Dictionary.
{expr2} must be a |string| or |Funcref|.
{expr2} must be a |String| or |Funcref|.
If {expr2} is a |string|, inside {expr2} |v:val| has the value
If {expr2} is a |String|, inside {expr2} |v:val| has the value
of the current item. For a |Dictionary| |v:key| has the key
of the current item and for a |List| |v:key| has the index of
the current item. For a |Blob| |v:key| has the index of the
@ -4100,14 +4106,15 @@ map({expr1}, {expr2}) *map()*
< If you do not use "key" you can use a short name: >vim
call map(myDict, {_, val -> 'item: ' .. val})
<
The operation is done in-place. If you want a |List| or
|Dictionary| to remain unmodified make a copy first: >vim
The operation is done in-place for a |List| and |Dictionary|.
If you want it to remain unmodified make a copy first: >vim
let tlist = map(copy(mylist), ' v:val .. "\t"')
< Returns {expr1}, the |List|, |Blob| or |Dictionary| that was
filtered. When an error is encountered while evaluating
{expr2} no further items in {expr1} are processed. When
{expr2} is a Funcref errors inside a function are ignored,
< Returns {expr1}, the |List| or |Dictionary| that was filtered,
or a new |Blob| or |String|.
When an error is encountered while evaluating {expr2} no
further items in {expr1} are processed.
When {expr2} is a Funcref errors inside a function are ignored,
unless it was defined with the "abort" flag.
maparg({name} [, {mode} [, {abbr} [, {dict}]]]) *maparg()*

47
runtime/lua/vim/_meta/vimfn.lua generated
View File

@ -2005,10 +2005,11 @@ function vim.fn.filereadable(file) end
--- @return 0|1
function vim.fn.filewritable(file) end
--- {expr1} must be a |List|, |Blob|, or a |Dictionary|.
--- {expr1} must be a |List|, |String|, |Blob| or |Dictionary|.
--- For each item in {expr1} evaluate {expr2} and when the result
--- is zero remove the item from the |List| or |Dictionary|. For a
--- |Blob| each byte is removed.
--- is zero or false remove the item from the |List| or
--- |Dictionary|. Similarly for each byte in a |Blob| and each
--- character in a |String|.
---
--- {expr2} must be a |string| or |Funcref|.
---
@ -2044,14 +2045,16 @@ function vim.fn.filewritable(file) end
--- <If you do not use "val" you can leave it out: >vim
--- call filter(myList, {idx -> idx % 2 == 1})
--- <
--- The operation is done in-place. If you want a |List| or
--- |Dictionary| to remain unmodified make a copy first: >vim
--- For a |List| and a |Dictionary| the operation is done
--- in-place. If you want it to remain unmodified make a copy
--- first: >vim
--- let l = filter(copy(mylist), 'v:val =~ "KEEP"')
---
--- <Returns {expr1}, the |List|, |Blob| or |Dictionary| that was
--- filtered. When an error is encountered while evaluating
--- {expr2} no further items in {expr1} are processed. When
--- {expr2} is a Funcref errors inside a function are ignored,
--- <Returns {expr1}, the |List| or |Dictionary| that was filtered,
--- or a new |Blob| or |String|.
--- When an error is encountered while evaluating {expr2} no
--- further items in {expr1} are processed.
--- When {expr2} is a Funcref errors inside a function are ignored,
--- unless it was defined with the "abort" flag.
---
--- @param expr1 any
@ -4919,15 +4922,18 @@ function vim.fn.log(expr) end
--- @return any
function vim.fn.log10(expr) end
--- {expr1} must be a |List|, |Blob| or |Dictionary|.
--- Replace each item in {expr1} with the result of evaluating
--- {expr2}. For a |Blob| each byte is replaced.
--- {expr1} must be a |List|, |String|, |Blob| or |Dictionary|.
--- When {expr1} is a |List|| or |Dictionary|, replace each
--- item in {expr1} with the result of evaluating {expr2}.
--- For a |Blob| each byte is replaced.
--- For a |String|, each character, including composing
--- characters, is replaced.
--- If the item type changes you may want to use |mapnew()| to
--- create a new List or Dictionary.
---
--- {expr2} must be a |string| or |Funcref|.
--- {expr2} must be a |String| or |Funcref|.
---
--- If {expr2} is a |string|, inside {expr2} |v:val| has the value
--- If {expr2} is a |String|, inside {expr2} |v:val| has the value
--- of the current item. For a |Dictionary| |v:key| has the key
--- of the current item and for a |List| |v:key| has the index of
--- the current item. For a |Blob| |v:key| has the index of the
@ -4957,14 +4963,15 @@ function vim.fn.log10(expr) end
--- <If you do not use "key" you can use a short name: >vim
--- call map(myDict, {_, val -> 'item: ' .. val})
--- <
--- The operation is done in-place. If you want a |List| or
--- |Dictionary| to remain unmodified make a copy first: >vim
--- The operation is done in-place for a |List| and |Dictionary|.
--- If you want it to remain unmodified make a copy first: >vim
--- let tlist = map(copy(mylist), ' v:val .. "\t"')
---
--- <Returns {expr1}, the |List|, |Blob| or |Dictionary| that was
--- filtered. When an error is encountered while evaluating
--- {expr2} no further items in {expr1} are processed. When
--- {expr2} is a Funcref errors inside a function are ignored,
--- <Returns {expr1}, the |List| or |Dictionary| that was filtered,
--- or a new |Blob| or |String|.
--- When an error is encountered while evaluating {expr2} no
--- further items in {expr1} are processed.
--- When {expr2} is a Funcref errors inside a function are ignored,
--- unless it was defined with the "abort" flag.
---
--- @param expr1 any

51
src/nvim/eval.c
View File

@ -108,6 +108,8 @@ static const char e_dot_can_only_be_used_on_dictionary_str[]
= N_("E1203: Dot can only be used on a dictionary: %s");
static const char e_empty_function_name[]
= N_("E1192: Empty function name");
static char e_argument_of_str_must_be_list_string_dictionary_or_blob[]
= N_("E1250: Argument of %s must be a List, String, Dictionary or Blob");
static char * const namespace_char = "abglstvw";
@ -5040,7 +5042,7 @@ static void filter_map(typval_T *argvars, typval_T *rettv, filtermap_T filtermap
: N_("filter() argument")));
// map() and filter() return the first argument, also on failure.
if (filtermap != FILTERMAP_MAPNEW) {
if (filtermap != FILTERMAP_MAPNEW && argvars[0].v_type != VAR_STRING) {
tv_copy(&argvars[0], rettv);
}
@ -5072,8 +5074,11 @@ static void filter_map(typval_T *argvars, typval_T *rettv, filtermap_T filtermap
&& value_check_lock(d->dv_lock, arg_errmsg, TV_TRANSLATE))) {
return;
}
} else if (argvars[0].v_type == VAR_STRING) {
rettv->v_type = VAR_STRING;
rettv->vval.v_string = NULL;
} else {
semsg(_(e_listdictblobarg), ermsg);
semsg(_(e_argument_of_str_must_be_list_string_dictionary_or_blob), ermsg);
return;
}
@ -5193,6 +5198,48 @@ static void filter_map(typval_T *argvars, typval_T *rettv, filtermap_T filtermap
}
idx++;
}
} else if (argvars[0].v_type == VAR_STRING) {
vimvars[VV_KEY].vv_type = VAR_NUMBER;
garray_T ga;
ga_init(&ga, (int)sizeof(char), 80);
int len;
for (const char *p = tv_get_string(&argvars[0]); *p != NUL; p += len) {
len = utfc_ptr2len(p);
typval_T tv = {
.v_type = VAR_STRING,
.v_lock = VAR_UNLOCKED,
.vval.v_string = xstrnsave(p, (size_t)len),
};
vimvars[VV_KEY].vv_nr = idx;
typval_T newtv;
if (filter_map_one(&tv, expr, filtermap, &newtv, &rem) == FAIL
|| did_emsg) {
tv_clear(&newtv);
tv_clear(&tv);
break;
} else if (filtermap != FILTERMAP_FILTER) {
if (newtv.v_type != VAR_STRING) {
tv_clear(&newtv);
tv_clear(&tv);
emsg(_(e_stringreq));
break;
} else {
ga_concat(&ga, newtv.vval.v_string);
}
} else if (!rem) {
ga_concat(&ga, tv.vval.v_string);
}
tv_clear(&newtv);
tv_clear(&tv);
idx++;
}
ga_append(&ga, NUL);
rettv->vval.v_string = ga.ga_data;
} else {
assert(argvars[0].v_type == VAR_LIST);

47
src/nvim/eval.lua
View File

@ -2539,10 +2539,11 @@ M.funcs = {
args = 2,
base = 1,
desc = [=[
{expr1} must be a |List|, |Blob|, or a |Dictionary|.
{expr1} must be a |List|, |String|, |Blob| or |Dictionary|.
For each item in {expr1} evaluate {expr2} and when the result
is zero remove the item from the |List| or |Dictionary|. For a
|Blob| each byte is removed.
is zero or false remove the item from the |List| or
|Dictionary|. Similarly for each byte in a |Blob| and each
character in a |String|.
{expr2} must be a |string| or |Funcref|.
@ -2578,14 +2579,16 @@ M.funcs = {
<If you do not use "val" you can leave it out: >vim
call filter(myList, {idx -> idx % 2 == 1})
<
The operation is done in-place. If you want a |List| or
|Dictionary| to remain unmodified make a copy first: >vim
For a |List| and a |Dictionary| the operation is done
in-place. If you want it to remain unmodified make a copy
first: >vim
let l = filter(copy(mylist), 'v:val =~ "KEEP"')
<Returns {expr1}, the |List|, |Blob| or |Dictionary| that was
filtered. When an error is encountered while evaluating
{expr2} no further items in {expr1} are processed. When
{expr2} is a Funcref errors inside a function are ignored,
<Returns {expr1}, the |List| or |Dictionary| that was filtered,
or a new |Blob| or |String|.
When an error is encountered while evaluating {expr2} no
further items in {expr1} are processed.
When {expr2} is a Funcref errors inside a function are ignored,
unless it was defined with the "abort" flag.
]=],
@ -6050,15 +6053,18 @@ M.funcs = {
args = 2,
base = 1,
desc = [=[
{expr1} must be a |List|, |Blob| or |Dictionary|.
Replace each item in {expr1} with the result of evaluating
{expr2}. For a |Blob| each byte is replaced.
{expr1} must be a |List|, |String|, |Blob| or |Dictionary|.
When {expr1} is a |List|| or |Dictionary|, replace each
item in {expr1} with the result of evaluating {expr2}.
For a |Blob| each byte is replaced.
For a |String|, each character, including composing
characters, is replaced.
If the item type changes you may want to use |mapnew()| to
create a new List or Dictionary.
{expr2} must be a |string| or |Funcref|.
{expr2} must be a |String| or |Funcref|.
If {expr2} is a |string|, inside {expr2} |v:val| has the value
If {expr2} is a |String|, inside {expr2} |v:val| has the value
of the current item. For a |Dictionary| |v:key| has the key
of the current item and for a |List| |v:key| has the index of
the current item. For a |Blob| |v:key| has the index of the
@ -6088,14 +6094,15 @@ M.funcs = {
<If you do not use "key" you can use a short name: >vim
call map(myDict, {_, val -> 'item: ' .. val})
<
The operation is done in-place. If you want a |List| or
|Dictionary| to remain unmodified make a copy first: >vim
The operation is done in-place for a |List| and |Dictionary|.
If you want it to remain unmodified make a copy first: >vim
let tlist = map(copy(mylist), ' v:val .. "\t"')
<Returns {expr1}, the |List|, |Blob| or |Dictionary| that was
filtered. When an error is encountered while evaluating
{expr2} no further items in {expr1} are processed. When
{expr2} is a Funcref errors inside a function are ignored,
<Returns {expr1}, the |List| or |Dictionary| that was filtered,
or a new |Blob| or |String|.
When an error is encountered while evaluating {expr2} no
further items in {expr1} are processed.
When {expr2} is a Funcref errors inside a function are ignored,
unless it was defined with the "abort" flag.
]=],

14
test/old/testdir/test_blob.vim
View File

@ -38,6 +38,7 @@ func Test_blob_create()
call assert_fails('VAR b = 0z001122.')
call assert_fails('call get("", 1)', 'E896:')
call assert_equal(0, len(v:_null_blob))
call assert_equal(0z, copy(v:_null_blob))
END
call CheckLegacyAndVim9Success(lines)
endfunc
@ -370,6 +371,14 @@ func Test_blob_add()
add(v:_null_blob, 0x22)
END
call CheckDefExecAndScriptFailure(lines, 'E1131:')
let lines =<< trim END
let b = 0zDEADBEEF
lockvar b
call add(b, 0)
unlockvar b
END
call CheckScriptFailure(lines, 'E741:')
endfunc
func Test_blob_empty()
@ -464,6 +473,9 @@ func Test_blob_func_remove()
remove(b, 0)
END
call CheckScriptFailure(lines, 'E741:')
call assert_fails('echo remove(0z1020, [])', 'E745:')
call assert_fails('echo remove(0z1020, 0, [])', 'E745:')
endfunc
func Test_blob_read_write()
@ -524,6 +536,7 @@ func Test_blob_filter()
call assert_equal(0zADEF, filter(0zDEADBEEF, 'v:key % 2'))
END
call CheckLegacyAndVim9Success(lines)
call assert_fails('echo filter(0z10, "a10")', 'E121:')
endfunc
" map() item in blob
@ -539,6 +552,7 @@ func Test_blob_map()
call map(0z00, '[9]')
END
call CheckLegacyAndVim9Failure(lines, 'E978:')
call assert_fails('echo map(0z10, "a10")', 'E121:')
endfunc
func Test_blob_index()

1
test/old/testdir/test_expr.vim
View File

@ -421,6 +421,7 @@ func Test_printf_misc()
call assert_equal('[00000あiう]', printf('[%010.7S]', 'あiう'))
call assert_equal('1%', printf('%d%%', 1))
call assert_notequal('', printf('%p', "abc"))
END
call CheckLegacyAndVim9Success(lines)

90
test/old/testdir/test_filter_map.vim
View File

@ -1,5 +1,7 @@
" Test filter() and map()
source vim9.vim
" list with expression string
func Test_filter_map_list_expr_string()
" filter()
@ -84,8 +86,6 @@ endfunc
func Test_map_filter_fails()
call assert_fails('call map([1], "42 +")', 'E15:')
call assert_fails('call filter([1], "42 +")', 'E15:')
call assert_fails("let l = map('abc', '\"> \" . v:val')", 'E896:')
call assert_fails("let l = filter('abc', '\"> \" . v:val')", 'E896:')
call assert_fails("let l = filter([1, 2, 3], '{}')", 'E728:')
call assert_fails("let l = filter({'k' : 10}, '{}')", 'E728:')
call assert_fails("let l = filter([1, 2], {})", 'E731:')
@ -138,4 +138,90 @@ func Test_mapnew_blob()
call assert_equal(0z129956, bout)
endfunc
" Test for using map(), filter() and mapnew() with a string
func Test_filter_map_string()
" filter()
let lines =<< trim END
VAR s = "abc"
call filter(s, '"b" != v:val')
call assert_equal('abc', s)
call assert_equal('ac', filter('abc', '"b" != v:val'))
call assert_equal('あいうえお', filter('あxいxうxえxお', '"x" != v:val'))
call assert_equal('あa😊💕💕b💕', filter('あxax😊x💕💕b💕x', '"x" != v:val'))
call assert_equal('xxxx', filter('あxax😊x💕💕b💕x', '"x" == v:val'))
VAR t = "%),:;>?]}’”†‡…‰,‱‼⁇⁈⁉℃℉,、。〉》」,』】〕〗〙〛,！），．：,；？,］｝"
VAR u = "%):;>?]}’”†‡…‰‱‼⁇⁈⁉℃℉、。〉》」』】〕〗〙〛！），．：；？］｝"
call assert_equal(u, filter(t, '"," != v:val'))
call assert_equal('', filter('abc', '0'))
call assert_equal('ac', filter('abc', LSTART i, x LMIDDLE "b" != x LEND))
call assert_equal('あいうえお', filter('あxいxうxえxお', LSTART i, x LMIDDLE "x" != x LEND))
call assert_equal('', filter('abc', LSTART i, x LMIDDLE v:false LEND))
call assert_equal('', filter('', "v:val == 'a'"))
call assert_equal('', filter(v:_null_string, "v:val == 'a'"))
END
call CheckLegacyAndVim9Success(lines)
" map()
let lines =<< trim END
VAR s = "abc"
call map(s, 'nr2char(char2nr(v:val) + 2)')
call assert_equal('abc', s)
call assert_equal('cde', map('abc', 'nr2char(char2nr(v:val) + 2)'))
call assert_equal('[あ][i][う][え][お]', map('あiうえお', '"[" .. v:val .. "]"'))
call assert_equal('[あ][a][😊][,][‱][‼][⁇][⁈][⁉][💕][b][💕][c][💕]', map('あa😊,‱‼⁇⁈⁉💕b💕c💕', '"[" .. v:val .. "]"'))
call assert_equal('', map('abc', '""'))
call assert_equal('cde', map('abc', LSTART i, x LMIDDLE nr2char(char2nr(x) + 2) LEND))
call assert_equal('[あ][i][う][え][お]', map('あiうえお', LSTART i, x LMIDDLE '[' .. x .. ']' LEND))
call assert_equal('', map('abc', LSTART i, x LMIDDLE '' LEND))
call assert_equal('', map('', "v:val == 'a'"))
call assert_equal('', map(v:_null_string, "v:val == 'a'"))
call assert_fails('echo map("abc", "10")', 'E928:')
call assert_fails('echo map("abc", "a10")', 'E121:')
END
call CheckLegacyAndVim9Success(lines)
" mapnew()
let lines =<< trim END
VAR s = "abc"
call mapnew(s, 'nr2char(char2nr(v:val) + 2)')
call assert_equal('abc', s)
call assert_equal('cde', mapnew('abc', 'nr2char(char2nr(v:val) + 2)'))
call assert_equal('[あ][i][う][え][お]', mapnew('あiうえお', '"[" .. v:val .. "]"'))
call assert_equal('[あ][a][😊][,][‱][‼][⁇][⁈][⁉][💕][b][💕][c][💕]', mapnew('あa😊,‱‼⁇⁈⁉💕b💕c💕', '"[" .. v:val .. "]"'))
call assert_equal('', mapnew('abc', '""'))
call assert_equal('cde', mapnew('abc', LSTART i, x LMIDDLE nr2char(char2nr(x) + 2) LEND))
call assert_equal('[あ][i][う][え][お]', mapnew('あiうえお', LSTART i, x LMIDDLE '[' .. x .. ']' LEND))
call assert_equal('', mapnew('abc', LSTART i, x LMIDDLE '' LEND))
call assert_equal('', mapnew('', "v:val == 'a'"))
call assert_equal('', mapnew(v:_null_string, "v:val == 'a'"))
END
call CheckLegacyAndVim9Success(lines)
let lines =<< trim END
#" map() and filter()
call assert_equal('[あ][⁈][a][😊][⁉][💕][💕][b][💕]', map(filter('あx⁈ax😊x⁉💕💕b💕x', '"x" != v:val'), '"[" .. v:val .. "]"'))
#" patterns-composing(\Z)
call assert_equal('ॠॠ', filter('ऊॠॡ,ऊॠॡ', LSTART i, x LMIDDLE x =~ '\Z' .. nr2char(0x0960) LEND))
call assert_equal('àà', filter('càt,càt', LSTART i, x LMIDDLE x =~ '\Za' LEND))
call assert_equal('ÅÅ', filter('Åström,Åström', LSTART i, x LMIDDLE x =~ '\Z' .. nr2char(0xc5) LEND))
call assert_equal('öö', filter('Åström,Åström', LSTART i, x LMIDDLE x =~ '\Z' .. nr2char(0xf6) LEND))
call assert_equal('ऊ@ॡ', map('ऊॠॡ', LSTART i, x LMIDDLE x =~ '\Z' .. nr2char(0x0960) ? '@' : x LEND))
call assert_equal('c@t', map('càt', LSTART i, x LMIDDLE x =~ '\Za' ? '@' : x LEND))
call assert_equal('@ström', map('Åström', LSTART i, x LMIDDLE x =~ '\Z' .. nr2char(0xc5) ? '@' : x LEND))
call assert_equal('Åstr@m', map('Åström', LSTART i, x LMIDDLE x =~ '\Z' .. nr2char(0xf6) ? '@' : x LEND))
#" patterns-composing(\%C)
call assert_equal('ॠॠ', filter('ऊॠॡ,ऊॠॡ', LSTART i, x LMIDDLE x =~ nr2char(0x0960) .. '\%C' LEND))
call assert_equal('àà', filter('càt,càt', LSTART i, x LMIDDLE x =~ 'a' .. '\%C' LEND))
call assert_equal('ÅÅ', filter('Åström,Åström', LSTART i, x LMIDDLE x =~ nr2char(0xc5) .. '\%C' LEND))
call assert_equal('öö', filter('Åström,Åström', LSTART i, x LMIDDLE x =~ nr2char(0xf6) .. '\%C' LEND))
call assert_equal('ऊ@ॡ', map('ऊॠॡ', LSTART i, x LMIDDLE x =~ nr2char(0x0960) .. '\%C' ? '@' : x LEND))
call assert_equal('c@t', map('càt', LSTART i, x LMIDDLE x =~ 'a' .. '\%C' ? '@' : x LEND))
call assert_equal('@ström', map('Åström', LSTART i, x LMIDDLE x =~ nr2char(0xc5) .. '\%C' ? '@' : x LEND))
call assert_equal('Åstr@m', map('Åström', LSTART i, x LMIDDLE x =~ nr2char(0xf6) .. '\%C' ? '@' : x LEND))
END
call CheckLegacyAndVim9Success(lines)
endfunc
" vim: shiftwidth=2 sts=2 expandtab

3
test/old/testdir/test_highlight.vim
View File

@ -864,17 +864,20 @@ func Test_highlight_default_colorscheme_restores_links()
let hlTestHiPre = HighlightArgs('TestHi')
" Test colorscheme
call assert_equal("\ndefault", execute('colorscheme'))
hi clear
if exists('syntax_on')
syntax reset
endif
let g:colors_name = 'test'
call assert_equal("\ntest", execute('colorscheme'))
hi link TestLink ErrorMsg
hi TestHi ctermbg=green
" Restore default highlighting
colorscheme default
" 'default' should work no matter if highlight group was cleared
call assert_equal("\ndefault", execute('colorscheme'))
hi def link TestLink Identifier
hi def TestHi ctermbg=red
let hlTestLinkPost = HighlightArgs('TestLink')

1
test/old/testdir/test_listdict.vim
View File

@ -1079,6 +1079,7 @@ func Test_listdict_extend()
let d = {'a': 'A', 'b': 'B'}
call assert_fails("call extend(d, {'b': 0, 'c':'C'}, 'error')", 'E737:')
call assert_fails("call extend(d, {'b': 0}, [])", 'E730:')
call assert_fails("call extend(d, {'b': 0, 'c':'C'}, 'xxx')", 'E475:')
if has('float')
call assert_fails("call extend(d, {'b': 0, 'c':'C'}, 1.2)", 'E475:')

2
test/old/testdir/test_search.vim
View File

@ -1762,6 +1762,8 @@ func Test_invalid_regexp()
call assert_fails("call search('\\(')", 'E54:')
call assert_fails("call search('\\)')", 'E55:')
call assert_fails("call search('\\z\\(\\)')", 'E66:')
call assert_fails("call search('\\z2')", 'E67:')
call assert_fails("call search('\\zx')", 'E867:')
call assert_fails("call search('\\%[ab')", 'E69:')
call assert_fails("call search('\\%[]')", 'E70:')
call assert_fails("call search('\\%9999999999999999999999999999v')", 'E951:')