mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2026-05-24 22:00:10 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
6bb3e1b239e4decd75475d386c1f4e6989eeb898
neovim/test/functional/legacy/scroll_opt_spec.lua
zeertzjq 8f1e14ffa2 vim-patch:9.2.0356: Cannot apply 'scrolloff' context lines at end of file 
Problem:  Cannot apply 'scrolloff' context lines at end of file
Solution: Add the 'scrolloffpad' option to keep 'scrolloff' context even
          when at the end of the file (McAuley Penney).

closes: vim/vim#19040

a414630393

Co-authored-by: McAuley Penney <jacobmpenney@gmail.com>
2026-04-22 10:14:52 +08:00

1602 lines
66 KiB
Lua
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

local n = require('test.functional.testnvim')()
local Screen = require('test.functional.ui.screen')
local clear = n.clear
local exec = n.exec
local feed = n.feed
local assert_alive = n.assert_alive
before_each(clear)
describe('smoothscroll', function()
local screen
before_each(function()
screen = Screen.new(40, 12)
end)
-- oldtest: Test_CtrlE_CtrlY_stop_at_end()
it('disabled does not break <C-E> and <C-Y> stop at end', function()
exec([[
enew
call setline(1, ['one', 'two'])
set number
]])
feed('<C-Y>')
screen:expect({ any = '{8: 1 }^one' })
feed('<C-E><C-E><C-E>')
screen:expect({ any = '{8: 2 }^two' })
end)
-- oldtest: Test_smoothscroll_CtrlE_CtrlY()
it('works with <C-E> and <C-E>', function()
exec([[
call setline(1, [ 'line one', 'word '->repeat(20), 'line three', 'long word '->repeat(7), 'line', 'line', 'line', ])
set smoothscroll scrolloff=5
:5
]])
local s1 = [[
word word word word word word word word |*2
word word word word |
line three |
long word long word long word long word |
long word long word long word |
^line |
line |*2
{1:~ }|*2
|
]]
local s2 = [[
{1:<<<}d word word word word word word word |
word word word word |
line three |
long word long word long word long word |
long word long word long word |
^line |
line |*2
{1:~ }|*3
|
]]
local s3 = [[
{1:<<<}d word word word |
line three |
long word long word long word long word |
long word long word long word |
^line |
line |*2
{1:~ }|*4
|
]]
local s4 = [[
line three |
long word long word long word long word |
long word long word long word |
line |*2
^line |
{1:~ }|*5
|
]]
local s5 = [[
{1:<<<}d word word word |
line three |
long word long word long word long word |
long word long word long word |
line |*2
^line |
{1:~ }|*4
|
]]
local s6 = [[
{1:<<<}d word word word word word word word |
word word word word |
line three |
long word long word long word long word |
long word long word long word |
line |*2
^line |
{1:~ }|*3
|
]]
local s7 = [[
word word word word word word word word |*2
word word word word |
line three |
long word long word long word long word |
long word long word long word |
line |*2
^line |
{1:~ }|*2
|
]]
local s8 = [[
line one |
word word word word word word word word |*2
word word word word |
line three |
long word long word long word long word |
long word long word long word |
line |*2
^line |
{1:~ }|
|
]]
feed('<C-E>')
screen:expect(s1)
feed('<C-E>')
screen:expect(s2)
feed('<C-E>')
screen:expect(s3)
feed('<C-E>')
screen:expect(s4)
feed('<C-Y>')
screen:expect(s5)
feed('<C-Y>')
screen:expect(s6)
feed('<C-Y>')
screen:expect(s7)
feed('<C-Y>')
screen:expect(s8)
exec('set foldmethod=indent')
-- move the cursor so we can reuse the same dumps
feed('5G<C-E>')
screen:expect(s1)
feed('<C-E>')
screen:expect(s2)
feed('7G<C-Y>')
screen:expect(s7)
feed('<C-Y>')
screen:expect(s8)
end)
-- oldtest: Test_smoothscroll_multibyte()
it('works with multibyte characters', function()
screen:try_resize(40, 6)
exec([[
set scrolloff=0 smoothscroll
call setline(1, [repeat('ϛ', 45), repeat('2', 36)])
exe "normal G35l\<C-E>k"
]])
screen:expect([[
ϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛϛ^ϛϛϛϛϛ|
ϛϛϛϛϛ |
222222222222222222222222222222222222 |
{1:~ }|*2
|
]])
end)
-- oldtest: Test_smoothscroll_number()
it("works 'number' and 'cpo'+=n", function()
exec([[
call setline(1, [ 'one ' .. 'word '->repeat(20), 'two ' .. 'long word '->repeat(7), 'line', 'line', 'line', ])
set smoothscroll scrolloff=5
set splitkeep=topline
set number cpo+=n
:3
func g:DoRel()
set number relativenumber scrolloff=0
:%del
call setline(1, [ 'one', 'very long text '->repeat(12), 'three', ])
exe "normal 2Gzt\<C-E>"
endfunc
]])
screen:expect([[
{8: 1 }one word word word word word word wo|
rd word word word word word word word wo|
rd word word word word word |
{8: 2 }two long word long word long word lo|
ng word long word long word long word |
{8: 3 }^line |
{8: 4 }line |
{8: 5 }line |
{1:~ }|*3
|
]])
feed('<C-E>')
screen:expect([[
{1:<<<}word word word word word word word wo|
rd word word word word word |
{8: 2 }two long word long word long word lo|
ng word long word long word long word |
{8: 3 }^line |
{8: 4 }line |
{8: 5 }line |
{1:~ }|*4
|
]])
feed('<C-E>')
screen:expect([[
{1:<<<}word word word word word |
{8: 2 }two long word long word long word lo|
ng word long word long word long word |
{8: 3 }^line |
{8: 4 }line |
{8: 5 }line |
{1:~ }|*5
|
]])
exec('set cpo-=n')
screen:expect([[
{1:<<<}{8: }d word word word word word word |
{8: 2 }two long word long word long word lo|
{8: }ng word long word long word long wor|
{8: }d |
{8: 3 }^line |
{8: 4 }line |
{8: 5 }line |
{1:~ }|*4
|
]])
feed('<C-Y>')
screen:expect([[
{1:<<<}{8: }rd word word word word word word wor|
{8: }d word word word word word word |
{8: 2 }two long word long word long word lo|
{8: }ng word long word long word long wor|
{8: }d |
{8: 3 }^line |
{8: 4 }line |
{8: 5 }line |
{1:~ }|*3
|
]])
feed('<C-Y>')
screen:expect([[
{8: 1 }one word word word word word word wo|
{8: }rd word word word word word word wor|
{8: }d word word word word word word |
{8: 2 }two long word long word long word lo|
{8: }ng word long word long word long wor|
{8: }d |
{8: 3 }^line |
{8: 4 }line |
{8: 5 }line |
{1:~ }|*2
|
]])
exec('botright split')
feed('gg')
screen:expect([[
{8: 1 }one word word word word word word wo|
{8: }rd word word word word word word wor|
{8: }d word word word word word word |
{8: 2 }two long word long word long word{1:@@@}|
{2:[No Name] [+] }|
{8: 1 }^one word word word word word word wo|
{8: }rd word word word word word word wor|
{8: }d word word word word word word |
{8: 2 }two long word long word long word lo|
{8: }ng word long word long word long {1:@@@}|
{3:[No Name] [+] }|
|
]])
feed('<C-E>')
screen:expect([[
{8: 1 }one word word word word word word wo|
{8: }rd word word word word word word wor|
{8: }d word word word word word word |
{8: 2 }two long word long word long word{1:@@@}|
{2:[No Name] [+] }|
{1:<<<}{8: }rd word word word word word word wor|
{8: }d word word word word word word^ |
{8: 2 }two long word long word long word lo|
{8: }ng word long word long word long wor|
{8: }d |
{3:[No Name] [+] }|
|
]])
feed('<C-E>')
screen:expect([[
{8: 1 }one word word word word word word wo|
{8: }rd word word word word word word wor|
{8: }d word word word word word word |
{8: 2 }two long word long word long word{1:@@@}|
{2:[No Name] [+] }|
{1:<<<}{8: }d word word word word word word^ |
{8: 2 }two long word long word long word lo|
{8: }ng word long word long word long wor|
{8: }d |
{8: 3 }line |
{3:[No Name] [+] }|
|
]])
exec('close')
exec('call DoRel()')
screen:expect([[
{8:2}{1:<<<}^ong text very long text very long te|
{8: }xt very long text very long text ver|
{8: }y long text very long text very long|
{8: } text very long text very long text |
{8: 1 }three |
{1:~ }|*6
--No lines in buffer-- |
]])
end)
-- oldtest: Test_smoothscroll_list()
it('works with list mode', function()
screen:try_resize(40, 8)
exec([[
set smoothscroll scrolloff=0
set list
call setline(1, [ 'one', 'very long text '->repeat(12), 'three', ])
exe "normal 2Gzt\<C-E>"
]])
screen:expect([[
{1:<<<}t very long text very long text very |
^long text very long text very long text |
very long text very long text very long |
text very long text{1:-} |
three |
{1:~ }|*2
|
]])
exec('set listchars+=precedes:#')
screen:expect([[
{1:#}ext very long text very long text very |
^long text very long text very long text |
very long text very long text very long |
text very long text{1:-} |
three |
{1:~ }|*2
|
]])
end)
-- oldtest: Test_smoothscroll_diff_mode()
it('works with diff mode', function()
screen:try_resize(40, 8)
exec([[
let text = 'just some text here'
call setline(1, text)
set smoothscroll
diffthis
new
call setline(1, text)
set smoothscroll
diffthis
]])
screen:expect([[
{7:- }^just some text here |
{1:~ }|*2
{3:[No Name] [+] }|
{7:- }just some text here |
{1:~ }|
{2:[No Name] [+] }|
|
]])
feed('<C-Y>')
screen:expect_unchanged()
feed('<C-E>')
screen:expect_unchanged()
end)
-- oldtest: Test_smoothscroll_diff_change_line()
it('works in diff mode when changing line', function()
screen:try_resize(55, 20)
exec([[
set diffopt+=followwrap smoothscroll
call setline(1, repeat(' abc', &columns))
call setline(2, 'bar')
call setline(3, repeat(' abc', &columns))
vnew
call setline(1, repeat(' abc', &columns))
call setline(2, 'foo')
call setline(3, 'bar')
call setline(4, repeat(' abc', &columns))
windo exe "normal! 2gg5\<C-E>"
windo diffthis
]])
screen:expect([[
{1:<<<}bc abc abc abc abc abc a│{1:<<<}bc abc abc abc abc abc a|
{7: }bc abc abc abc abc abc ab│{7: }bc abc abc abc abc abc ab|
{7: }c abc abc abc abc abc abc│{7: }c abc abc abc abc abc abc|
{7: } abc abc abc abc abc │{7: } abc abc abc abc abc |
{7: }{22:foo }│{7: }{23:-------------------------}|
{7: }bar │{7: }^bar |
{7: } abc abc abc abc abc abc │{7: } abc abc abc abc abc abc |
{7: }abc abc abc abc abc abc a│{7: }abc abc abc abc abc abc a|
{7: }bc abc abc abc abc abc ab│{7: }bc abc abc abc abc abc ab|
{7: }c abc abc abc abc abc abc│{7: }c abc abc abc abc abc abc|
{7: } abc abc abc abc abc abc │{7: } abc abc abc abc abc abc |
{7: }abc abc abc abc abc abc a│{7: }abc abc abc abc abc abc a|
{7: }bc abc abc abc abc abc ab│{7: }bc abc abc abc abc abc ab|
{7: }c abc abc abc abc abc abc│{7: }c abc abc abc abc abc abc|
{7: } abc abc abc abc abc │{7: } abc abc abc abc abc |
{1:~ }│{1:~ }|*3
{2:[No Name] [+] }{3:[No Name] [+] }|
|
]])
feed('Abar')
screen:expect([[
{1:<<<}bc abc abc abc abc abc a│{1:<<<}bc abc abc abc abc abc a|
{7: }bc abc abc abc abc abc ab│{7: }bc abc abc abc abc abc ab|
{7: }c abc abc abc abc abc abc│{7: }c abc abc abc abc abc abc|
{7: } abc abc abc abc abc │{7: } abc abc abc abc abc |
{7: }{22:foo }│{7: }{23:-------------------------}|
{7: }bar │{7: }barbar^ |
{7: } abc abc abc abc abc abc │{7: } abc abc abc abc abc abc |
{7: }abc abc abc abc abc abc a│{7: }abc abc abc abc abc abc a|
{7: }bc abc abc abc abc abc ab│{7: }bc abc abc abc abc abc ab|
{7: }c abc abc abc abc abc abc│{7: }c abc abc abc abc abc abc|
{7: } abc abc abc abc abc abc │{7: } abc abc abc abc abc abc |
{7: }abc abc abc abc abc abc a│{7: }abc abc abc abc abc abc a|
{7: }bc abc abc abc abc abc ab│{7: }bc abc abc abc abc abc ab|
{7: }c abc abc abc abc abc abc│{7: }c abc abc abc abc abc abc|
{7: } abc abc abc abc abc │{7: } abc abc abc abc abc |
{1:~ }│{1:~ }|*3
{2:[No Name] [+] }{3:[No Name] [+] }|
{5:-- INSERT --} |
]])
feed('<Esc>')
screen:expect([[
{1:<<<}bc abc abc abc abc abc a│{1:<<<}bc abc abc abc abc abc a|
{7: }bc abc abc abc abc abc ab│{7: }bc abc abc abc abc abc ab|
{7: }c abc abc abc abc abc abc│{7: }c abc abc abc abc abc abc|
{7: } abc abc abc abc abc │{7: } abc abc abc abc abc |
{7: }{22:foo }│{7: }{23:-------------------------}|
{7: }{4:bar }│{7: }{4:bar}{27:ba^r}{4: }|
{7: } abc abc abc abc abc abc │{7: } abc abc abc abc abc abc |
{7: }abc abc abc abc abc abc a│{7: }abc abc abc abc abc abc a|
{7: }bc abc abc abc abc abc ab│{7: }bc abc abc abc abc abc ab|
{7: }c abc abc abc abc abc abc│{7: }c abc abc abc abc abc abc|
{7: } abc abc abc abc abc abc │{7: } abc abc abc abc abc abc |
{7: }abc abc abc abc abc abc a│{7: }abc abc abc abc abc abc a|
{7: }bc abc abc abc abc abc ab│{7: }bc abc abc abc abc abc ab|
{7: }c abc abc abc abc abc abc│{7: }c abc abc abc abc abc abc|
{7: } abc abc abc abc abc │{7: } abc abc abc abc abc |
{1:~ }│{1:~ }|*3
{2:[No Name] [+] }{3:[No Name] [+] }|
|
]])
feed('yyp')
screen:expect([[
{1:<<<}bc abc abc abc abc abc a│{1:<<<}bc abc abc abc abc abc a|
{7: }bc abc abc abc abc abc ab│{7: }bc abc abc abc abc abc ab|
{7: }c abc abc abc abc abc abc│{7: }c abc abc abc abc abc abc|
{7: } abc abc abc abc abc │{7: } abc abc abc abc abc |
{7: }{27:foo}{4: }│{7: }{27:barbar}{4: }|
{7: }{4:bar }│{7: }{4:^bar}{27:bar}{4: }|
{7: } abc abc abc abc abc abc │{7: } abc abc abc abc abc abc |
{7: }abc abc abc abc abc abc a│{7: }abc abc abc abc abc abc a|
{7: }bc abc abc abc abc abc ab│{7: }bc abc abc abc abc abc ab|
{7: }c abc abc abc abc abc abc│{7: }c abc abc abc abc abc abc|
{7: } abc abc abc abc abc abc │{7: } abc abc abc abc abc abc |
{7: }abc abc abc abc abc abc a│{7: }abc abc abc abc abc abc a|
{7: }bc abc abc abc abc abc ab│{7: }bc abc abc abc abc abc ab|
{7: }c abc abc abc abc abc abc│{7: }c abc abc abc abc abc abc|
{7: } abc abc abc abc abc │{7: } abc abc abc abc abc |
{1:~ }│{1:~ }|*3
{2:[No Name] [+] }{3:[No Name] [+] }|
|
]])
end)
-- oldtest: Test_smoothscroll_wrap_scrolloff_zero()
it("works with zero 'scrolloff'", function()
screen:try_resize(40, 8)
exec([[
call setline(1, ['Line' .. (' with some text'->repeat(7))]->repeat(7))
set smoothscroll scrolloff=0 display=
:3
]])
screen:expect([[
{1:<<<}h some text with some text |
Line with some text with some text with |
some text with some text with some text |
with some text with some text |
^Line with some text with some text with |
some text with some text with some text |
with some text with some text |
|
]])
feed('j')
screen:expect_unchanged()
-- moving cursor down - whole bottom line shows
feed('<C-E>j')
screen:expect_unchanged()
feed('G')
screen:expect_unchanged()
feed('4<C-Y>G')
screen:expect_unchanged()
-- moving cursor up right after the <<< marker - no need to show whole line
feed('2gj3l2k')
screen:expect([[
{1:<<<}^h some text with some text |
Line with some text with some text with |
some text with some text with some text |
with some text with some text |
Line with some text with some text with |
some text with some text with some text |
with some text with some text |
|
]])
-- moving cursor up where the <<< marker is - whole top line shows
feed('2j02k')
screen:expect([[
^Line with some text with some text with |
some text with some text with some text |
with some text with some text |
Line with some text with some text with |
some text with some text with some text |
with some text with some text |
{1:@ }|
|
]])
end)
-- oldtest: Test_smoothscroll_wrap_long_line()
it('adjusts the cursor position in a long line', function()
screen:try_resize(40, 6)
exec([[
call setline(1, ['one', 'two', 'Line' .. (' with lots of text'->repeat(30)) .. ' end', 'four'])
set smoothscroll scrolloff=0
normal 3G10|zt
]])
-- scrolling up, cursor moves screen line down
screen:expect([[
Line with^ lots of text with lots of text|
with lots of text with lots of text wit|
h lots of text with lots of text with lo|
ts of text with lots of text with lots o|
f text with lots of text with lots of te|
|
]])
feed('<C-E>')
screen:expect([[
{1:<<<}th lot^s of text with lots of text wit|
h lots of text with lots of text with lo|
ts of text with lots of text with lots o|
f text with lots of text with lots of te|
xt with lots of text with lots of text w|
|
]])
feed('5<C-E>')
screen:expect([[
{1:<<<} lots ^of text with lots of text with |
lots of text with lots of text with lots|
of text with lots of text with lots of |
text with lots of text with lots of text|
with lots of text with lots of text wit|
|
]])
-- scrolling down, cursor moves screen line up
feed('5<C-Y>')
screen:expect([[
{1:<<<}th lots of text with lots of text wit|
h lots of text with lots of text with lo|
ts of text with lots of text with lots o|
f text with lots of text with lots of te|
xt with l^ots of text with lots of text w|
|
]])
feed('<C-Y>')
screen:expect([[
Line with lots of text with lots of text|
with lots of text with lots of text wit|
h lots of text with lots of text with lo|
ts of text with lots of text with lots o|
f text wi^th lots of text with lots of te|
|
]])
-- 'scrolloff' set to 1, scrolling up, cursor moves screen line down
exec('set scrolloff=1')
feed('10|<C-E>')
screen:expect([[
{1:<<<}th lots of text with lots of text wit|
h lots of^ text with lots of text with lo|
ts of text with lots of text with lots o|
f text with lots of text with lots of te|
xt with lots of text with lots of text w|
|
]])
-- 'scrolloff' set to 1, scrolling down, cursor moves screen line up
feed('<C-E>gjgj<C-Y>')
screen:expect([[
{1:<<<}th lots of text with lots of text wit|
h lots of text with lots of text with lo|
ts of text with lots of text with lots o|
f text wi^th lots of text with lots of te|
xt with lots of text with lots of text w|
|
]])
-- 'scrolloff' set to 2, scrolling up, cursor moves screen line down
exec('set scrolloff=2')
feed('10|<C-E>')
screen:expect([[
{1:<<<}th lots of text with lots of text wit|
h lots of text with lots of text with lo|
ts of tex^t with lots of text with lots o|
f text with lots of text with lots of te|
xt with lots of text with lots of text w|
|
]])
-- 'scrolloff' set to 2, scrolling down, cursor moves screen line up
feed('<C-E>gj<C-Y>')
screen:expect_unchanged()
-- 'scrolloff' set to 0, move cursor down one line. Cursor should move properly,
-- and since this is a really long line, it will be put on top of the screen.
exec('set scrolloff=0')
feed('0j')
screen:expect([[
{1:<<<}th lots of text with lots of text wit|
h lots of text with lots of text with lo|
ts of text with lots of text with lots o|
f text with lots of text end |
^four |
|
]])
-- Test zt/zz/zb that they work properly when a long line is above it
feed('zt')
screen:expect([[
^four |
{1:~ }|*4
|
]])
feed('zz')
screen:expect([[
{1:<<<}of text with lots of text with lots o|
f text with lots of text end |
^four |
{1:~ }|*2
|
]])
feed('zb')
screen:expect([[
{1:<<<}th lots of text with lots of text wit|
h lots of text with lots of text with lo|
ts of text with lots of text with lots o|
f text with lots of text end |
^four |
|
]])
-- Repeat the step and move the cursor down again.
-- This time, use a shorter long line that is barely long enough to span more
-- than one window. Note that the cursor is at the bottom this time because
-- Vim prefers to do so if we are scrolling a few lines only.
exec(
"call setline(1, ['one', 'two', 'Line' .. (' with lots of text'->repeat(10)) .. ' end', 'four'])"
)
-- Currently visible lines were replaced, test that the lines and cursor
-- are correctly displayed.
screen:expect_unchanged()
feed('3Gztj')
screen:expect_unchanged()
-- Repeat the step but this time start it when the line is smooth-scrolled by
-- one line. This tests that the offset calculation is still correct and
-- still end up scrolling down to the next line with cursor at bottom of
-- screen.
feed('3Gzt<C-E>j')
screen:expect([[
{1:<<<}th lots of text with lots of text wit|
h lots of text with lots of text with lo|
ts of text with lots of text with lots o|
f text with lots of text end |
fou^r |
|
]])
end)
-- oldtest: Test_smoothscroll_one_long_line()
it('scrolls correctly when moving the cursor', function()
screen:try_resize(40, 6)
exec([[
call setline(1, 'with lots of text '->repeat(7))
set smoothscroll scrolloff=0
]])
local s1 = [[
^with lots of text with lots of text with|
lots of text with lots of text with lot|
s of text with lots of text with lots of|
text |
{1:~ }|
|
]]
screen:expect(s1)
feed('<C-E>')
screen:expect([[
{1:<<<}ts of text with lots of text with lot|
^s of text with lots of text with lots of|
text |
{1:~ }|*2
|
]])
feed('0')
screen:expect(s1)
end)
-- oldtest: Test_smoothscroll_long_line_showbreak()
it('cursor is not one screen line too far down', function()
screen:try_resize(40, 6)
-- a line that spans four screen lines
exec("call setline(1, 'with lots of text in one line '->repeat(6))")
exec('set smoothscroll scrolloff=0 showbreak=+++\\ ')
local s1 = [[
^with lots of text in one line with lots |
{1:+++ }of text in one line with lots of tex|
{1:+++ }t in one line with lots of text in o|
{1:+++ }ne line with lots of text in one lin|
{1:+++ }e with lots of text in one line |
|
]]
screen:expect(s1)
feed('<C-E>')
screen:expect([[
{1:+++ }^of text in one line with lots of tex|
{1:+++ }t in one line with lots of text in o|
{1:+++ }ne line with lots of text in one lin|
{1:+++ }e with lots of text in one line |
{1:~ }|
|
]])
feed('0')
screen:expect(s1)
end)
-- oldtest: Test_smoothscroll_marker_over_double_width_dump()
it('marker is drawn over double-width char correctly', function()
screen:try_resize(40, 6)
exec([[
call setline(1, 'a'->repeat(&columns) .. '口'->repeat(10))
setlocal smoothscroll
]])
screen:expect([[
^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa|
口口口口口口口口口口 |
{1:~ }|*3
|
]])
feed('<C-E>')
screen:expect([[
{1:<<<} 口口口口口口口^口 |
{1:~ }|*4
|
]])
end)
-- oldtest: Test_smoothscroll_zero_width()
it('does not divide by zero with a narrow window', function()
screen:try_resize(12, 2)
exec([[
call setline(1, ['a'->repeat(100)])
set wrap smoothscroll number laststatus=0
wincmd v
wincmd v
wincmd v
wincmd v
]])
screen:expect([[
{8: 1^ }│{8: }│{8: }│{8: }│{8: }|
|
]])
feed('llllllllll<C-W>o')
screen:expect([[
{1:<<<}{8: }aa^aaaaaa|
|
]])
end)
-- oldtest: Test_smoothscroll_ins_lines()
it('does not unnecessarily insert lines', function()
screen:try_resize(40, 6)
exec([=[
set wrap smoothscroll scrolloff=0 conceallevel=2 concealcursor=nc
call setline(1, [
\'line one' .. 'with lots of text in one line '->repeat(2),
\'line two',
\'line three',
\'line four',
\'line five'
\])
]=])
feed('<C-E>gjgk')
screen:expect([[
{1:<<<}lots of text in one line^ |
line two |
line three |
line four |
line five |
|
]])
end)
-- oldtest: Test_smoothscroll_cursormoved_line()
it('does not place the cursor in the command line', function()
screen:try_resize(40, 6)
exec([=[
set smoothscroll
call setline(1, [
\'',
\'_'->repeat(&lines * &columns),
\(('_')->repeat(&columns - 2) .. 'xxx')->repeat(2)
\])
autocmd CursorMoved * eval [line('w0'), line('w$')]
call search('xxx')
]=])
screen:expect([[
{1:<<<}_____________________________________|
________________________________________|
______________________________________^xx|
x______________________________________x|
xx |
|
]])
end)
-- oldtest: Test_smoothscroll_eob()
it('does not scroll halfway at end of buffer', function()
screen:try_resize(40, 10)
exec([[
set smoothscroll
call setline(1, ['']->repeat(100))
norm G
]])
-- does not scroll halfway when scrolling to end of buffer
screen:expect([[
|*8
^ |
|
]])
exec("call setline(92, 'a'->repeat(100))")
feed('<C-L><C-B>G')
-- cursor is not placed below window
screen:expect([[
{1:<<<}aaaaaaaaaaaaaaaaa |
|*7
^ |
|
]])
end)
-- oldtest: Test_smoothscroll_incsearch()
it('does not reset skipcol when doing incremental search on the same word', function()
screen:try_resize(40, 8)
exec([[
set smoothscroll number scrolloff=0 incsearch
call setline(1, repeat([''], 20))
call setline(11, repeat('a', 100))
call setline(14, 'bbbb')
]])
feed('/b')
screen:expect([[
{1:<<<}{8: }aaaaaaaaaaaaaaaaaaaaaaaaaaaa |
{8: 12 } |
{8: 13 } |
{8: 14 }{2:b}{10:bbb} |
{8: 15 } |
{8: 16 } |
{8: 17 } |
/b^ |
]])
feed('b')
screen:expect([[
{1:<<<}{8: }aaaaaaaaaaaaaaaaaaaaaaaaaaaa |
{8: 12 } |
{8: 13 } |
{8: 14 }{2:bb}{10:bb} |
{8: 15 } |
{8: 16 } |
{8: 17 } |
/bb^ |
]])
feed('b')
screen:expect([[
{1:<<<}{8: }aaaaaaaaaaaaaaaaaaaaaaaaaaaa |
{8: 12 } |
{8: 13 } |
{8: 14 }{2:bbb}b |
{8: 15 } |
{8: 16 } |
{8: 17 } |
/bbb^ |
]])
feed('b')
screen:expect([[
{1:<<<}{8: }aaaaaaaaaaaaaaaaaaaaaaaaaaaa |
{8: 12 } |
{8: 13 } |
{8: 14 }{2:bbbb} |
{8: 15 } |
{8: 16 } |
{8: 17 } |
/bbbb^ |
]])
end)
-- oldtest: Test_smoothscroll_multi_skipcol()
it('scrolling multiple lines and stopping at non-zero skipcol', function()
screen:try_resize(40, 10)
exec([[
setlocal cursorline scrolloff=0 smoothscroll
call setline(1, repeat([''], 8))
call setline(3, repeat('a', 50))
call setline(4, repeat('a', 50))
call setline(7, 'bbb')
call setline(8, 'ccc')
redraw
]])
screen:expect([[
{21:^ }|
|
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa|
aaaaaaaaaa |
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa|
aaaaaaaaaa |
|*2
bbb |
|
]])
feed('3<C-E>')
screen:expect([[
{1:<<<}{21:aaaaaa^a }|
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa|
aaaaaaaaaa |
|*2
bbb |
ccc |
{1:~ }|*2
|
]])
feed('2<C-E>')
screen:expect([[
{1:<<<}{21:aaaaaa^a }|
|*2
bbb |
ccc |
{1:~ }|*4
|
]])
end)
-- oldtest: Test_smoothscroll_zero_width_scroll_cursor_bot()
it('does not divide by zero in zero-width window', function()
screen:try_resize(40, 19)
exec([[
silent normal yy
silent normal 19p
set cpoptions+=n
vsplit
vertical resize 0
set foldcolumn=1
set number
set smoothscroll
silent normal 20G
]])
screen:expect([[
{8: }│ |
{1:@}│ |*15
{1:^@}│ |
{3:< }{2:[No Name] [+] }|
|
]])
end)
-- oldtest: Test_smoothscroll_cursor_top()
it('resets skipcol when scrolling cursor to top', function()
screen:try_resize(40, 12)
exec([[
set smoothscroll scrolloff=2
new | 11resize | wincmd j
call setline(1, ['line1', 'line2', 'line3'->repeat(20), 'line4'])
exe "norm G3\<C-E>k"
]])
screen:expect([[
|
{2:[No Name] }|
line1 |
line2 |
^line3line3line3line3line3line3line3line3|
line3line3line3line3line3line3line3line3|
line3line3line3line3 |
line4 |
{1:~ }|*2
{3:[No Name] [+] }|
|
]])
end)
-- oldtest: Test_smoothscroll_crash()
it('does not crash with small window and cpo+=n', function()
screen:try_resize(40, 12)
exec([[
20 new
vsp
put =repeat('aaaa', 20)
set nu fdc=1 smoothscroll cpo+=n
vert resize 0
exe "norm! 0\<c-e>"
]])
feed('2<C-E>')
assert_alive()
end)
-- oldtest: Test_smoothscroll_insert_bottom()
it('works in Insert mode at bottom of window', function()
screen:try_resize(40, 9)
exec([[
call setline(1, repeat([repeat('A very long line ...', 10)], 5))
set wrap smoothscroll scrolloff=0
]])
feed('Go123456789<CR>')
screen:expect([[
{1:<<<}ery long line ...A very long line ...|
A very long line ...A very long line ...|*5
123456789 |
^ |
{5:-- INSERT --} |
]])
end)
-- oldtest: Test_smoothscroll_in_qf_window()
it('works in quickfix window when changing quickfix list', function()
screen:try_resize(60, 20)
exec([[
set nocompatible display=lastline
copen 5
setlocal number smoothscroll
let g:l = [{'text': 'foo'}] + repeat([{'text': join(range(30))}], 10)
call setqflist(g:l, 'r')
normal! G
wincmd t
let g:l1 = [{'text': join(range(1000))}]
]])
screen:expect([[
^ |
{1:~ }|*11
{3:[No Name] }|
{1:<<<}{8: }21 22 23 24 25 26 27 28 29 |
{8: 10 }|| 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
{8: }21 22 23 24 25 26 27 28 29 |
{8: 11 }|| 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
{8: }21 22 23 24 25 26 27 28 29 |
{2:[Quickfix List] [-] }|
|
]])
feed([[:call setqflist([], 'r')<CR>]])
local screen_empty = [[
^ |
{1:~ }|*11
{3:[No Name] }|
{8: 1 } |
{1:~ }|*4
{2:[Quickfix List] [-] }|
:call setqflist([], 'r') |
]]
screen:expect(screen_empty)
feed([[:call setqflist(g:l, 'r')<CR>]])
local screen_l_top = [[
^ |
{1:~ }|*11
{3:[No Name] }|
{8: 1 }{10:|| foo }|
{8: 2 }|| 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
{8: }21 22 23 24 25 26 27 28 29 |
{8: 3 }|| 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
{8: }21 22 23 24 25 26 27 28 29 |
{2:[Quickfix List] [-] }|
:call setqflist(g:l, 'r') |
]]
screen:expect(screen_l_top)
feed([[:call setqflist(g:l1, 'r')<CR>]])
local screen_l1_top = [[
^ |
{1:~ }|*11
{3:[No Name] }|
{8: 1 }{10:|| 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 }|
{8: }{10:21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39}|
{8: }{10: 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 5}|
{8: }{10:8 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 }|
{8: }{10:77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95}|
{2:[Quickfix List] [-] }|
:call setqflist(g:l1, 'r') |
]]
screen:expect(screen_l1_top)
feed('<C-W>b$<C-W>t')
local screen_l1_bot = [[
^ |
{1:~ }|*11
{3:[No Name] }|
{1:<<<}{8: }{10: 937 938 939 940 941 942 943 944 945 946 947 948 949 950}|
{8: }{10: 951 952 953 954 955 956 957 958 959 960 961 962 963 964}|
{8: }{10: 965 966 967 968 969 970 971 972 973 974 975 976 977 978}|
{8: }{10: 979 980 981 982 983 984 985 986 987 988 989 990 991 992}|
{8: }{10: 993 994 995 996 997 998 999 }|
{2:[Quickfix List] [-] }|
:call setqflist(g:l1, 'r') |
]]
screen:expect(screen_l1_bot)
feed([[:call setqflist([], 'r')<CR>]])
screen:expect(screen_empty)
feed([[:call setqflist(g:l1, 'r')<CR>]])
screen:expect(screen_l1_top)
feed('<C-W>b$<C-W>t')
screen:expect(screen_l1_bot)
feed([[:call setqflist(g:l, 'r')<CR>]])
screen:expect(screen_l_top)
end)
-- oldtest: Test_smoothscroll_textoff_showbreak()
it('does not crash when resizing to textoff with showbreak', function()
exec([[
set noswapfile scrolloff=0
call setline(1, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
set number wrap smoothscroll showbreak=>
vsplit
let textoff = getwininfo(win_getid())[0].textoff
execute "normal! 0\<C-E>"
redraw
execute 'vertical resize' textoff
redraw
]])
assert_alive()
end)
it('works with virt_lines above and below', function()
screen:try_resize(55, 7)
exec([=[
call setline(1, ['Line' .. (' with some text'->repeat(7))]->repeat(3))
set smoothscroll
let ns = nvim_create_namespace('')
call nvim_buf_set_extmark(0, ns, 0, 0, {'virt_lines':[[['virt_below1']]]})
call nvim_buf_set_extmark(0, ns, 1, 0, {'virt_lines':[[['virt_above1']]],'virt_lines_above':1})
call nvim_buf_set_extmark(0, ns, 1, 0, {'virt_lines':[[['virt_below2']]]})
call nvim_buf_set_extmark(0, ns, 2, 0, {'virt_lines':[[['virt_above2']]],'virt_lines_above':1})
norm ggL
]=])
screen:expect([[
Line with some text with some text with some text with |
some text with some text with some text with some text |
virt_below1 |
virt_above1 |
^Line with some text with some text with some text with |
some text with some text with some text with some text |
|
]])
feed('<C-E>')
screen:expect([[
{1:<<<}e text with some text with some text with some text |
virt_below1 |
virt_above1 |
^Line with some text with some text with some text with |
some text with some text with some text with some text |
virt_below2 |
|
]])
feed('<C-E>')
screen:expect([[
virt_below1 |
virt_above1 |
^Line with some text with some text with some text with |
some text with some text with some text with some text |
virt_below2 |
virt_above2 |
|
]])
feed('<C-E>')
screen:expect([[
virt_above1 |
^Line with some text with some text with some text with |
some text with some text with some text with some text |
virt_below2 |
virt_above2 |
Line with some text with some text with some text wi{1:@@@}|
|
]])
feed('<C-E>')
screen:expect([[
^Line with some text with some text with some text with |
some text with some text with some text with some text |
virt_below2 |
virt_above2 |
Line with some text with some text with some text with |
some text with some text with some text with some text |
|
]])
feed('<C-E>')
screen:expect([[
{1:<<<}e text with some text with some text with some tex^t |
virt_below2 |
virt_above2 |
Line with some text with some text with some text with |
some text with some text with some text with some text |
{1:~ }|
|
]])
end)
it('<<< marker shows with tabline, winbar and splits', function()
screen:try_resize(40, 12)
screen:add_extra_attr_ids {
[100] = { foreground = Screen.colors.Magenta1, bold = true },
}
exec([[
call setline(1, ['Line' .. (' with some text'->repeat(7))]->repeat(7))
set smoothscroll scrolloff=0
norm sj
]])
screen:expect([[
{1:<<<}e text with some text with some text |
with some text with some text |
Line with some text with some text with |
some text with some text with some text |
with some text with some text |
{2:[No Name] [+] }|
{1:<<<}e text with some text with some text |
^with some text with some text |
Line with some text with some text with |
some text with some text with some te{1:@@@}|
{3:[No Name] [+] }|
|
]])
exec('set showtabline=2')
feed('<C-E>')
screen:expect([[
{5: }{100:2}{5:+ [No Name] }{2: }|
{1:<<<}e text with some text with some text |
with some text with some text |
Line with some text with some text with |
some text with some text with some text |
with some text with some text |
{2:[No Name] [+] }|
{1:<<<}e text with some text with some text |
^with some text with some text |
Line with some text with some text wi{1:@@@}|
{3:[No Name] [+] }|
|
]])
exec('set winbar=winbar')
feed('<C-w>k<C-E>')
screen:expect([[
{5: }{100:2}{5:+ [No Name] }{2: }|
{5:winbar }|
{1:<<<}e text with some text with some text |
^with some text with some text |
Line with some text with some text with |
some text with some text with some te{1:@@@}|
{3:[No Name] [+] }|
{5:winbar }|
{1:<<<}e text with some text with some text |
with some text with some text |
{2:[No Name] [+] }|
|
]])
end)
it('works with very long line', function()
exec([[
edit test/functional/fixtures/bigfile_oneline.txt
setlocal smoothscroll number
]])
screen:expect([[
{8: 1 }^0000;<control>;Cc;0;BN;;;;;N;NULL;;;|
{8: }; 0001;<control>;Cc;0;BN;;;;;N;START|
{8: } OF HEADING;;;; 0002;<control>;Cc;0;|
{8: }BN;;;;;N;START OF TEXT;;;; 0003;<con|
{8: }trol>;Cc;0;BN;;;;;N;END OF TEXT;;;; |
{8: }0004;<control>;Cc;0;BN;;;;;N;END OF |
{8: }TRANSMISSION;;;; 0005;<control>;Cc;0|
{8: };BN;;;;;N;ENQUIRY;;;; 0006;<control>|
{8: };Cc;0;BN;;;;;N;ACKNOWLEDGE;;;; 0007;|
{8: }<control>;Cc;0;BN;;;;;N;BELL;;;; 000|
{8: }8;<control>;Cc;0;BN;;;;;N;BACKSPACE;|
|
]])
feed('j')
screen:expect([[
{1:<<<}{8: }CJK COMPATIBILITY IDEOGRAPH-2F91F;Lo|
{8: };0;L;243AB;;;;N;;;;; 2F920;CJK COMPA|
{8: }TIBILITY IDEOGRAPH-2F920;Lo;0;L;7228|
{8: };;;;N;;;;; 2F921;CJK COMPATIBILITY I|
{8: }DEOGRAPH-2F921;Lo;0;L;7235;;;;N;;;;;|
{8: } 2F922;CJK COMPATIBILITY IDEOGRAPH-2|
{8: }F922;Lo;0;L;7250;;;;N;;;;; |
{8: 2 }^2F923;CJK COMPATIBILITY IDEOGRAPH-2F|
{8: }923;Lo;0;L;24608;;;;N;;;;; |
{8: 3 }2F924;CJK COMPATIBILITY IDEOGRAPH-2F|
{8: }924;Lo;0;L;7280;;;;N;;;;; |
|
]])
end)
it('works with very long line and scrolloff', function()
screen:try_resize(40, 8)
exec([[
set smoothscroll scrolloff=3
call setline(1, ['one', 'two long '->repeat(100), 'three', 'four', 'five', 'six'])
]])
feed(':norm j721|<CR>')
screen:expect([[
{1:<<<}two long two long two long two long t|
wo long two long two long two long two l|
ong two long two long two long two long |
^two long two long two long two long two |
long two long two long two long two long|
two long two long two long two long two|
long two long two long two long two lon|
:norm j721| |
]])
feed('gj')
screen:expect([[
{1:<<<}two long two long two long two long t|
wo long two long two long two long two l|
ong two long two long two long two long |
two long two long two long two long two |
^long two long two long two long two long|
two long two long two long two long two|
long two long two long two long two lon|
:norm j721| |
]])
feed('gj')
screen:expect([[
{1:<<<}long two long two long two long two l|
ong two long two long two long two long |
two long two long two long two long two |
long two long two long two long two long|
^ two long two long two long two long two|
long two long two long two long two lon|
g two long two long |
:norm j721| |
]])
feed('gj')
screen:expect([[
{1:<<<}long two long two long two long two l|
ong two long two long two long two long |
two long two long two long two long two |
long two long two long two long two long|
two long two long two long two long two|
^ long two long two long two long two lon|
g two long two long |
:norm j721| |
]])
feed('gj')
screen:expect([[
{1:<<<}long two long two long two long two l|
ong two long two long two long two long |
two long two long two long two long two |
long two long two long two long two long|
two long two long two long two long two|
long two long two long two long two lon|
^g two long two long |
:norm j721| |
]])
feed('gj')
screen:expect([[
{1:<<<} long two long two long two long two |
long two long two long two long two long|
two long two long two long two long two|
long two long two long two long two lon|
g two long two long |
^three |
four |
:norm j721| |
]])
feed('gk')
screen:expect([[
{1:<<<}long two long two long two long two l|
ong two long two long two long two long |
two long two long two long two long two |
long two long two long two long two long|
two long two long two long two long two|
long two long two long two long two lon|
^g two long two long |
:norm j721| |
]])
end)
end)
describe('scrolloffpad', function()
local screen
before_each(function()
screen = Screen.new(78, 20)
end)
-- oldtest: Test_scrolloffpad_basic()
it('works', function()
exec([[
set scrolloff=10
set scrolloffpad=5
enew!
call setline(1, map(range(1, 100), 'printf("line %d", v:val)'))
normal! gg
]])
-- Enabled: scrolloffpad > 0, expect EOF centering/padding
exec('normal! G')
screen:expect([[
line 91 |
line 92 |
line 93 |
line 94 |
line 95 |
line 96 |
line 97 |
line 98 |
line 99 |
^line 100 |
{1:~ }|*9
|
]])
-- Beginning-of-file is unchanged (Top)
exec('normal! gg')
screen:expect([[
^line 1 |
line 2 |
line 3 |
line 4 |
line 5 |
line 6 |
line 7 |
line 8 |
line 9 |
line 10 |
line 11 |
line 12 |
line 13 |
line 14 |
line 15 |
line 16 |
line 17 |
line 18 |
line 19 |
|
]])
-- Gating: disable scrolloffpad, then go to EOF again
-- Expect normal EOF behavior (no extra centering/padding)
exec('set scrolloffpad=0')
exec('normal! G')
screen:expect([[
line 82 |
line 83 |
line 84 |
line 85 |
line 86 |
line 87 |
line 88 |
line 89 |
line 90 |
line 91 |
line 92 |
line 93 |
line 94 |
line 95 |
line 96 |
line 97 |
line 98 |
line 99 |
^line 100 |
|
]])
end)
-- oldtest: Test_scrolloffpad_smoothscroll()
it('works with smoothscroll', function()
exec([[
set smoothscroll scrolloff=10 scrolloffpad=1
enew!
call setline(1, map(range(1, 100), 'printf("line %d", v:val)'))
normal! gg
]])
exec('normal! G')
screen:expect([[
line 91 |
line 92 |
line 93 |
line 94 |
line 95 |
line 96 |
line 97 |
line 98 |
line 99 |
^line 100 |
{1:~ }|*9
|
]])
exec([[call setline(line('$'), repeat('LONG ', 30))]])
exec('normal! 41|')
screen:expect([[
line 92 |
line 93 |
line 94 |
line 95 |
line 96 |
line 97 |
line 98 |
line 99 |
LONG LONG LONG LONG LONG LONG LONG LONG ^LONG LONG LONG LONG LONG LONG LONG LON|
G LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG LONG |
{1:~ }|*9
|
]])
end)
-- oldtest: Test_scrolloffpad_with_folds()
it('works with folds', function()
exec([[
set scrolloff=10
set scrolloffpad=1
enew
call setline(1, map(range(1, 120), {_, v -> 'line ' . v}))
" Create a large fold near the end of the file.
" Fold lines 60-110, leaving 111-120 visible after the fold.
set foldmethod=manual
set foldenable
normal! gg
normal! 60G
normal! zf50j
normal! gg
]])
-- Case 1: Jump to end-of-file
-- With folds present, scrolloffpad should still
-- keep the cursor positioned with padding below EOF
exec('normal! G')
local s1 = [[
line 111 |
line 112 |
line 113 |
line 114 |
line 115 |
line 116 |
line 117 |
line 118 |
line 119 |
^line 120 |
{1:~ }|*9
|
]]
screen:expect(s1)
-- Case 2: Move to the folded line to ensure the fold is actually in view
exec('normal! 60G')
screen:expect([[
line 51 |
line 52 |
line 53 |
line 54 |
line 55 |
line 56 |
line 57 |
line 58 |
line 59 |
{13:^+-- 51 lines: line 60·························································}|
line 111 |
line 112 |
line 113 |
line 114 |
line 115 |
line 116 |
line 117 |
line 118 |
line 119 |
|
]])
-- Case 3: Close the fold explicitly and go to EOF again
-- Behavior should remain stable with closed folds
exec('normal! zc')
exec('normal! G')
screen:expect(s1)
end)
end)
Reference in New Issue View Git Blame Copy Permalink