mirror of
https://github.com/neovim/neovim.git
synced 2024-12-27 14:21:31 -07:00
fd2ece278b
scroll_delta contains how much the top line of a window moved since the last time win_viewport was emitted. It is expected to be used to implement smooth scrolling. For this purpose it only counts "virtual" or "displayed" so folds should count as one line. Because of this it adds extra information that cannot be computed from the topline parameter. Fixes #19227
685 lines
26 KiB
Lua
685 lines
26 KiB
Lua
local helpers = require('test.functional.helpers')(after_each)
|
|
local Screen = require('test.functional.ui.screen')
|
|
local clear, feed, insert = helpers.clear, helpers.feed, helpers.insert
|
|
local command = helpers.command
|
|
local feed_command = helpers.feed_command
|
|
local eq = helpers.eq
|
|
local eval = helpers.eval
|
|
local funcs = helpers.funcs
|
|
local testprg = helpers.testprg
|
|
|
|
describe('search highlighting', function()
|
|
local screen
|
|
|
|
before_each(function()
|
|
clear()
|
|
screen = Screen.new(40, 7)
|
|
screen:attach()
|
|
screen:set_default_attr_ids( {
|
|
[1] = {bold=true, foreground=Screen.colors.Blue},
|
|
[2] = {background = Screen.colors.Yellow}, -- Search
|
|
[3] = {reverse = true},
|
|
[4] = {foreground = Screen.colors.Red}, -- Message
|
|
[6] = {foreground = Screen.colors.Blue4, background = Screen.colors.LightGrey}, -- Folded
|
|
})
|
|
end)
|
|
|
|
it('is disabled by ":set nohlsearch"', function()
|
|
feed_command('set nohlsearch')
|
|
insert("some text\nmore text")
|
|
feed("gg/text<cr>")
|
|
screen:expect([[
|
|
some ^text |
|
|
more text |
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
/text |
|
|
]])
|
|
end)
|
|
|
|
it('is disabled in folded text', function()
|
|
insert("some text\nmore text")
|
|
feed_command('1,2fold')
|
|
feed("gg/text")
|
|
screen:expect{grid=[[
|
|
{6:+-- 2 lines: some text·················}|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
/text^ |
|
|
]], win_viewport={
|
|
[2] = {win = {id = 1000}, topline = 0, botline = 3, curline = 0, curcol = 9, linecount = 2, sum_scroll_delta = 0};
|
|
}}
|
|
end)
|
|
|
|
it('works', function()
|
|
insert([[
|
|
some text
|
|
more textstuff
|
|
stupidtexttextstuff
|
|
a text word
|
|
]])
|
|
|
|
-- 'hlsearch' is enabled by default. #2859
|
|
feed("gg/text<cr>")
|
|
screen:expect([[
|
|
some {2:^text} |
|
|
more {2:text}stuff |
|
|
stupid{2:texttext}stuff |
|
|
a {2:text} word |
|
|
|
|
|
{1:~ }|
|
|
/text |
|
|
]])
|
|
|
|
-- overlapping matches not allowed
|
|
feed("3nx")
|
|
screen:expect([[
|
|
some {2:text} |
|
|
more {2:text}stuff |
|
|
stupid{2:text}^extstuff |
|
|
a {2:text} word |
|
|
|
|
|
{1:~ }|
|
|
/text |
|
|
]])
|
|
|
|
feed("ggn*") -- search for entire word
|
|
screen:expect([[
|
|
some {2:text} |
|
|
more textstuff |
|
|
stupidtextextstuff |
|
|
a {2:^text} word |
|
|
|
|
|
{1:~ }|
|
|
/\<text\> |
|
|
]])
|
|
|
|
feed_command("nohlsearch")
|
|
screen:expect([[
|
|
some text |
|
|
more textstuff |
|
|
stupidtextextstuff |
|
|
a ^text word |
|
|
|
|
|
{1:~ }|
|
|
:nohlsearch |
|
|
]])
|
|
end)
|
|
|
|
describe('CurSearch highlight', function()
|
|
before_each(function()
|
|
screen:set_default_attr_ids({
|
|
[1] = {background = Screen.colors.Yellow}, -- Search
|
|
[2] = {foreground = Screen.colors.White, background = Screen.colors.Black}, -- CurSearch
|
|
[3] = {foreground = Screen.colors.Red}, -- WarningMsg
|
|
})
|
|
command('highlight CurSearch guibg=Black guifg=White')
|
|
end)
|
|
|
|
it('works for match under cursor', function()
|
|
insert([[
|
|
There is no way that a bee should be
|
|
able to fly. Its wings are too small
|
|
to get its fat little body off the
|
|
ground. The bee, of course, flies
|
|
anyway because bees don't care what
|
|
humans think is impossible.]])
|
|
|
|
feed('/bee<CR>')
|
|
screen:expect{grid=[[
|
|
There is no way that a {2:^bee} should be |
|
|
able to fly. Its wings are too small |
|
|
to get its fat little body off the |
|
|
ground. The {1:bee}, of course, flies |
|
|
anyway because {1:bee}s don't care what |
|
|
humans think is impossible. |
|
|
{3:search hit BOTTOM, continuing at TOP} |
|
|
]]}
|
|
|
|
feed('nn')
|
|
screen:expect{grid=[[
|
|
There is no way that a {1:bee} should be |
|
|
able to fly. Its wings are too small |
|
|
to get its fat little body off the |
|
|
ground. The {1:bee}, of course, flies |
|
|
anyway because {2:^bee}s don't care what |
|
|
humans think is impossible. |
|
|
/bee |
|
|
]]}
|
|
|
|
feed('N')
|
|
screen:expect{grid=[[
|
|
There is no way that a {1:bee} should be |
|
|
able to fly. Its wings are too small |
|
|
to get its fat little body off the |
|
|
ground. The {2:^bee}, of course, flies |
|
|
anyway because {1:bee}s don't care what |
|
|
humans think is impossible. |
|
|
?bee |
|
|
]]}
|
|
end)
|
|
|
|
it('works for multiline match', function()
|
|
command([[call setline(1, ['one', 'foo', 'bar', 'baz', 'foo the foo and foo', 'bar'])]])
|
|
feed('gg/foo<CR>')
|
|
screen:expect([[
|
|
one |
|
|
{2:^foo} |
|
|
bar |
|
|
baz |
|
|
{1:foo} the {1:foo} and {1:foo} |
|
|
bar |
|
|
/foo |
|
|
]])
|
|
feed('n')
|
|
screen:expect([[
|
|
one |
|
|
{1:foo} |
|
|
bar |
|
|
baz |
|
|
{2:^foo} the {1:foo} and {1:foo} |
|
|
bar |
|
|
/foo |
|
|
]])
|
|
feed('n')
|
|
screen:expect([[
|
|
one |
|
|
{1:foo} |
|
|
bar |
|
|
baz |
|
|
{1:foo} the {2:^foo} and {1:foo} |
|
|
bar |
|
|
/foo |
|
|
]])
|
|
feed('n')
|
|
screen:expect([[
|
|
one |
|
|
{1:foo} |
|
|
bar |
|
|
baz |
|
|
{1:foo} the {1:foo} and {2:^foo} |
|
|
bar |
|
|
/foo |
|
|
]])
|
|
command([[call setline(5, 'foo')]])
|
|
feed('0?<CR>')
|
|
screen:expect([[
|
|
one |
|
|
{2:^foo} |
|
|
bar |
|
|
baz |
|
|
{1:foo} |
|
|
bar |
|
|
?foo |
|
|
]])
|
|
feed('gg/foo\\nbar<CR>')
|
|
screen:expect([[
|
|
one |
|
|
{2:^foo } |
|
|
{2:bar} |
|
|
baz |
|
|
{1:foo } |
|
|
{1:bar} |
|
|
/foo\nbar |
|
|
]])
|
|
command([[call setline(1, ['---', 'abcdefg', 'hijkl', '---', 'abcdefg', 'hijkl'])]])
|
|
feed('gg/efg\\nhij<CR>')
|
|
screen:expect([[
|
|
--- |
|
|
abcd{2:^efg } |
|
|
{2:hij}kl |
|
|
--- |
|
|
abcd{1:efg } |
|
|
{1:hij}kl |
|
|
/efg\nhij |
|
|
]])
|
|
feed('n')
|
|
screen:expect([[
|
|
--- |
|
|
abcd{1:efg } |
|
|
{1:hij}kl |
|
|
--- |
|
|
abcd{2:^efg } |
|
|
{2:hij}kl |
|
|
/efg\nhij |
|
|
]])
|
|
end)
|
|
end)
|
|
|
|
it('highlights after EOL', function()
|
|
insert("\n\n\n\n\n\n")
|
|
|
|
feed("gg/^<cr>")
|
|
screen:expect([[
|
|
{2: } |
|
|
{2:^ } |
|
|
{2: } |
|
|
{2: } |
|
|
{2: } |
|
|
{2: } |
|
|
/^ |
|
|
]])
|
|
|
|
-- Test that highlights are preserved after moving the cursor.
|
|
feed("j")
|
|
screen:expect([[
|
|
{2: } |
|
|
{2: } |
|
|
{2:^ } |
|
|
{2: } |
|
|
{2: } |
|
|
{2: } |
|
|
/^ |
|
|
]])
|
|
|
|
-- Repeat the test in rightleft mode.
|
|
command("nohlsearch")
|
|
command("set rightleft")
|
|
feed("gg/^<cr>")
|
|
|
|
screen:expect([[
|
|
{2: }|
|
|
{2:^ }|
|
|
{2: }|
|
|
{2: }|
|
|
{2: }|
|
|
{2: }|
|
|
^/ |
|
|
]])
|
|
|
|
feed("j")
|
|
screen:expect([[
|
|
{2: }|
|
|
{2: }|
|
|
{2:^ }|
|
|
{2: }|
|
|
{2: }|
|
|
{2: }|
|
|
^/ |
|
|
]])
|
|
end)
|
|
|
|
it('is preserved during :terminal activity', function()
|
|
feed((':terminal "%s" REP 5000 foo<cr>'):format(testprg('shell-test')))
|
|
|
|
feed(':file term<CR>')
|
|
feed('G') -- Follow :terminal output.
|
|
feed(':vnew<CR>')
|
|
insert([[
|
|
foo bar baz
|
|
bar baz foo
|
|
bar foo baz
|
|
]])
|
|
feed('/foo')
|
|
helpers.poke_eventloop()
|
|
screen:sleep(0)
|
|
screen:expect_unchanged()
|
|
end)
|
|
|
|
it('works with incsearch', function()
|
|
command('set hlsearch')
|
|
command('set incsearch')
|
|
command('set laststatus=0')
|
|
insert([[
|
|
the first line
|
|
in a little file]])
|
|
command('vsplit')
|
|
feed("gg/li")
|
|
screen:expect([[
|
|
the first {3:li}ne │the first {2:li}ne |
|
|
in a {2:li}ttle file │in a {2:li}ttle file |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
/li^ |
|
|
]])
|
|
|
|
-- check that consecutive matches are caught by C-g/C-t
|
|
feed("<C-g>")
|
|
screen:expect([[
|
|
the first {2:li}ne │the first {2:li}ne |
|
|
in a {3:li}ttle file │in a {2:li}ttle file |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
/li^ |
|
|
]])
|
|
|
|
feed("<C-t>")
|
|
screen:expect([[
|
|
the first {3:li}ne │the first {2:li}ne |
|
|
in a {2:li}ttle file │in a {2:li}ttle file |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
/li^ |
|
|
]])
|
|
|
|
feed("t")
|
|
screen:expect([[
|
|
the first line │the first line |
|
|
in a {3:lit}tle file │in a {2:lit}tle file |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
/lit^ |
|
|
]])
|
|
|
|
feed("<cr>")
|
|
screen:expect([[
|
|
the first line │the first line |
|
|
in a {2:^lit}tle file │in a {2:lit}tle file |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
/lit |
|
|
]])
|
|
|
|
feed("/fir")
|
|
screen:expect([[
|
|
the {3:fir}st line │the {2:fir}st line |
|
|
in a little file │in a little file |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
/fir^ |
|
|
]])
|
|
|
|
-- incsearch have priority over hlsearch
|
|
feed("<esc>/ttle")
|
|
screen:expect([[
|
|
the first line │the first line |
|
|
in a li{3:ttle} file │in a li{2:ttle} file |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
/ttle^ |
|
|
]])
|
|
|
|
-- cancelling search resets to the old search term
|
|
feed('<esc>')
|
|
screen:expect([[
|
|
the first line │the first line |
|
|
in a {2:^lit}tle file │in a {2:lit}tle file |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
|
|
|
]])
|
|
eq('lit', eval('@/'))
|
|
|
|
-- cancelling inc search restores the hl state
|
|
feed(':noh<cr>')
|
|
screen:expect([[
|
|
the first line │the first line |
|
|
in a ^little file │in a little file |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
:noh |
|
|
]])
|
|
|
|
feed('/first')
|
|
screen:expect([[
|
|
the {3:first} line │the {2:first} line |
|
|
in a little file │in a little file |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
/first^ |
|
|
]])
|
|
feed('<esc>')
|
|
screen:expect([[
|
|
the first line │the first line |
|
|
in a ^little file │in a little file |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
|
|
|
]])
|
|
|
|
-- test that pressing C-g in an empty command line does not move the cursor
|
|
feed('gg0')
|
|
command([[let @/ = 'i']])
|
|
-- moves to next match of previous search pattern, just like /<cr>
|
|
feed('/<c-g><cr>')
|
|
eq({0, 1, 6, 0}, funcs.getpos('.'))
|
|
-- moves to next match of previous search pattern, just like /<cr>
|
|
feed('/<cr>')
|
|
eq({0, 1, 12, 0}, funcs.getpos('.'))
|
|
-- moves to next match of previous search pattern, just like /<cr>
|
|
feed('/<c-t><cr>')
|
|
eq({0, 2, 1, 0}, funcs.getpos('.'))
|
|
|
|
-- 8.0.1304, test that C-g and C-t works with incsearch and empty pattern
|
|
feed('<esc>/fi<CR>')
|
|
screen:expect([[
|
|
the {2:fi}rst line │the {2:fi}rst line |
|
|
in a little {2:^fi}le │in a little {2:fi}le |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
/fi |
|
|
]])
|
|
feed('//')
|
|
screen:expect([[
|
|
the {3:fi}rst line │the {2:fi}rst line |
|
|
in a little {2:fi}le │in a little {2:fi}le |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
//^ |
|
|
]])
|
|
feed('<C-g>')
|
|
screen:expect([[
|
|
the {2:fi}rst line │the {2:fi}rst line |
|
|
in a little {3:fi}le │in a little {2:fi}le |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
//^ |
|
|
]])
|
|
feed('<Esc>')
|
|
|
|
-- incsearch works after c_CTRL-R_CTRL-R
|
|
command('let @" = "file"')
|
|
feed('/<C-R><C-R>"')
|
|
screen:expect([[
|
|
the first line │the first line |
|
|
in a little {3:file} │in a little {2:file} |
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
{1:~ }│{1:~ }|
|
|
/file^ |
|
|
]])
|
|
end)
|
|
|
|
it('works with incsearch and offset', function()
|
|
feed_command('set hlsearch')
|
|
feed_command('set incsearch')
|
|
insert([[
|
|
not the match you're looking for
|
|
the match is here]])
|
|
|
|
feed("gg/mat/e")
|
|
screen:expect([[
|
|
not the {3:mat}ch you're looking for |
|
|
the {2:mat}ch is here |
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
/mat/e^ |
|
|
]])
|
|
|
|
-- Search with count and /e offset fixed in Vim patch 7.4.532.
|
|
feed("<esc>2/mat/e")
|
|
screen:expect([[
|
|
not the {2:mat}ch you're looking for |
|
|
the {3:mat}ch is here |
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
/mat/e^ |
|
|
]])
|
|
|
|
feed("<cr>")
|
|
screen:expect([[
|
|
not the {2:mat}ch you're looking for |
|
|
the {2:ma^t}ch is here |
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
/mat/e |
|
|
]])
|
|
end)
|
|
|
|
it('works with multiline regexps', function()
|
|
feed_command('set hlsearch')
|
|
feed('4oa repeated line<esc>')
|
|
feed('/line\\na<cr>')
|
|
screen:expect([[
|
|
|
|
|
a repeated {2:^line } |
|
|
{2:a} repeated {2:line } |
|
|
{2:a} repeated {2:line } |
|
|
{2:a} repeated line |
|
|
{1:~ }|
|
|
{4:search hit BOTTOM, continuing at TOP} |
|
|
]])
|
|
|
|
-- it redraws rows above the changed one
|
|
feed('4Grb')
|
|
screen:expect([[
|
|
|
|
|
a repeated {2:line } |
|
|
{2:a} repeated line |
|
|
^b repeated {2:line } |
|
|
{2:a} repeated line |
|
|
{1:~ }|
|
|
{4:search hit BOTTOM, continuing at TOP} |
|
|
]])
|
|
end)
|
|
|
|
it('works with matchadd and syntax', function()
|
|
screen:set_default_attr_ids {
|
|
[1] = {bold=true, foreground=Screen.colors.Blue};
|
|
[2] = {background = Screen.colors.Yellow};
|
|
[3] = {reverse = true};
|
|
[4] = {foreground = Screen.colors.Red};
|
|
[5] = {bold = true, background = Screen.colors.Green};
|
|
[6] = {italic = true, background = Screen.colors.Magenta};
|
|
[7] = {bold = true, background = Screen.colors.Yellow};
|
|
[8] = {foreground = Screen.colors.Blue4, background = Screen.colors.LightGray};
|
|
}
|
|
feed_command('set hlsearch')
|
|
insert [[
|
|
very special text
|
|
]]
|
|
feed_command("syntax on")
|
|
feed_command("highlight MyGroup guibg=Green gui=bold")
|
|
feed_command("highlight MyGroup2 guibg=Magenta gui=italic")
|
|
feed_command("call matchadd('MyGroup', 'special')")
|
|
feed_command("call matchadd('MyGroup2', 'text', 0)")
|
|
|
|
-- searchhl and matchadd matches are exclusive, only the highest priority
|
|
-- is used (and matches with lower priorities are not combined)
|
|
feed_command("/ial te")
|
|
screen:expect{grid=[[
|
|
very {5:spec^ial}{2: te}{6:xt} |
|
|
|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{4:search hit BOTTOM, continuing at TOP} |
|
|
]], win_viewport={
|
|
[2] = {win = {id = 1000}, topline = 0, botline = 3, curline = 0, curcol = 11, linecount = 2, sum_scroll_delta = 0};
|
|
}}
|
|
|
|
-- check highlights work also in folds
|
|
feed("zf4j")
|
|
screen:expect{grid=[[
|
|
{8:^+-- 2 lines: very special text·········}|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{4:search hit BOTTOM, continuing at TOP} |
|
|
]]}
|
|
command("%foldopen")
|
|
screen:expect([[
|
|
very {5:spec^ial}{2: te}{6:xt} |
|
|
|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{4:search hit BOTTOM, continuing at TOP} |
|
|
]])
|
|
|
|
feed_command("call clearmatches()")
|
|
screen:expect([[
|
|
very spec{2:^ial te}xt |
|
|
|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
:call clearmatches() |
|
|
]])
|
|
|
|
-- searchhl has priority over syntax, but in this case
|
|
-- nonconflicting attributes are combined
|
|
feed_command("syntax keyword MyGroup special")
|
|
screen:expect([[
|
|
very {5:spec}{7:^ial}{2: te}xt |
|
|
|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
:syntax keyword MyGroup special |
|
|
]])
|
|
end)
|
|
|
|
it('highlights entire pattern on :%g@a/b', function()
|
|
command('set inccommand=nosplit')
|
|
feed('ia/b/c<Esc>')
|
|
feed(':%g@a/b')
|
|
screen:expect([[
|
|
{3:a/b}/c |
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
{1:~ }|
|
|
:%g@a/b^ |
|
|
]])
|
|
end)
|
|
end)
|
|
|