vim-patch:8.0.0311

Problem:    Linebreak tests are old style.
Solution:   Turn the tests into new style. Share utility functions. (Ozaki
            Kiichi, closes vim/vim#1444)

544d3bc9f0

src/nvim/testdir/test_breakindent.vim

@@ -2,171 +2,209 @@
 "
 " Note: if you get strange failures when adding new tests, it might be that
 " while the test is run, the breakindent cacheing gets in its way.
-" It helps to change the tabastop setting and force a redraw (e.g. see
+" It helps to change the tabstop setting and force a redraw (e.g. see
 " Test_breakindent08())
 if !exists('+breakindent')
   finish
 endif
 
+source view_util.vim
+
 let s:input ="\tabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOP"
 
-function s:screenline(lnum, width) abort
+function s:screen_lines(lnum, width) abort
-  " always get 4 screen lines
+  return ScreenLines([a:lnum, a:lnum + 2], a:width)
-  redraw!
-  let line = []
-  for j in range(3)
-    for c in range(1, a:width)
-  call add(line, nr2char(screenchar(a:lnum+j, c)))
-    endfor
-    call add(line, "\n")
-  endfor
-  return join(line, '')
 endfunction
 
-function s:testwindows(...)
+function! s:compare_lines(expect, actual)
-  10new
+  call assert_equal(join(a:expect, "\n"), join(a:actual, "\n"))
-  vsp
+endfunction
-  vert resize 20
+
-  setl ts=4 sw=4 sts=4 breakindent 
+function s:test_windows(...)
+  call NewWindow(10, 20)
+  setl ts=4 sw=4 sts=4 breakindent
   put =s:input
-  if a:0
+  exe get(a:000, 0, '')
-    exe a:1
-  endif
 endfunction
 
 function s:close_windows(...)
-  bw!
+  call CloseWindow()
-  if a:0
+  exe get(a:000, 0, '')
-    exe a:1
-  endif
-  unlet! g:line g:expect
 endfunction
 
 function Test_breakindent01()
   " simple breakindent test
-  call s:testwindows('setl briopt=min:0')
+  call s:test_windows('setl briopt=min:0')
-  let g:line=s:screenline(line('.'),8)
+  let lines=s:screen_lines(line('.'),8)
-  let g:expect="    abcd\n    qrst\n    GHIJ\n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "    abcd",
+\ "    qrst",
+\ "    GHIJ",
+\ ]
+  call s:compare_lines(expect, lines)
   call s:close_windows()
 endfunction
 
 function Test_breakindent02()
   " simple breakindent test with showbreak set
-  call s:testwindows('setl briopt=min:0 sbr=>>')
+  call s:test_windows('setl briopt=min:0 sbr=>>')
-  let g:line=s:screenline(line('.'),8)
+  let lines=s:screen_lines(line('.'),8)
-  let g:expect="    abcd\n    >>qr\n    >>EF\n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "    abcd",
+\ "    >>qr",
+\ "    >>EF",
+\ ]
+  call s:compare_lines(expect, lines)
   call s:close_windows('set sbr=')
 endfunction
 
 function Test_breakindent03()
   " simple breakindent test with showbreak set and briopt including sbr
-  call s:testwindows('setl briopt=sbr,min:0 sbr=++')
+  call s:test_windows('setl briopt=sbr,min:0 sbr=++')
-  let g:line=s:screenline(line('.'),8)
+  let lines=s:screen_lines(line('.'),8)
-  let g:expect="    abcd\n++  qrst\n++  GHIJ\n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "    abcd",
+\ "++  qrst",
+\ "++  GHIJ",
+\ ]
+  call s:compare_lines(expect, lines)
   " clean up
   call s:close_windows('set sbr=')
 endfunction
 
 function Test_breakindent04()
   " breakindent set with min width 18
-  call s:testwindows('setl sbr= briopt=min:18')
+  call s:test_windows('setl sbr= briopt=min:18')
-  let g:line=s:screenline(line('.'),8)
+  let lines=s:screen_lines(line('.'),8)
-  let g:expect="    abcd\n  qrstuv\n  IJKLMN\n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "    abcd",
+\ "  qrstuv",
+\ "  IJKLMN",
+\ ]
+  call s:compare_lines(expect, lines)
   " clean up
   call s:close_windows('set sbr=')
 endfunction
 
 function Test_breakindent05()
   " breakindent set and shift by 2
-  call s:testwindows('setl briopt=shift:2,min:0')
+  call s:test_windows('setl briopt=shift:2,min:0')
-  let g:line=s:screenline(line('.'),8)
+  let lines=s:screen_lines(line('.'),8)
-  let g:expect="    abcd\n      qr\n      EF\n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "    abcd",
+\ "      qr",
+\ "      EF",
+\ ]
+  call s:compare_lines(expect, lines)
   call s:close_windows()
 endfunction
 
 function Test_breakindent06()
   " breakindent set and shift by -1
-  call s:testwindows('setl briopt=shift:-1,min:0')
+  call s:test_windows('setl briopt=shift:-1,min:0')
-  let g:line=s:screenline(line('.'),8)
+  let lines=s:screen_lines(line('.'),8)
-  let g:expect="    abcd\n   qrstu\n   HIJKL\n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "    abcd",
+\ "   qrstu",
+\ "   HIJKL",
+\ ]
+  call s:compare_lines(expect, lines)
   call s:close_windows()
 endfunction
 
 function Test_breakindent07()
   " breakindent set and shift by 1, Number  set sbr=? and briopt:sbr
-  call s:testwindows('setl briopt=shift:1,sbr,min:0 nu sbr=? nuw=4 cpo+=n')
+  call s:test_windows('setl briopt=shift:1,sbr,min:0 nu sbr=? nuw=4 cpo+=n')
-  let g:line=s:screenline(line('.'),10)
+  let lines=s:screen_lines(line('.'),10)
-  let g:expect="  2     ab\n?        m\n?        x\n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "  2     ab",
+\ "?        m",
+\ "?        x",
+\ ]
+  call s:compare_lines(expect, lines)
   " clean up
   call s:close_windows('set sbr= cpo-=n')
 endfunction
 
 function Test_breakindent07a()
   " breakindent set and shift by 1, Number  set sbr=? and briopt:sbr
-  call s:testwindows('setl briopt=shift:1,sbr,min:0 nu sbr=? nuw=4')
+  call s:test_windows('setl briopt=shift:1,sbr,min:0 nu sbr=? nuw=4')
-  let g:line=s:screenline(line('.'),10)
+  let lines=s:screen_lines(line('.'),10)
-  let g:expect="  2     ab\n    ?    m\n    ?    x\n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "  2     ab",
+\ "    ?    m",
+\ "    ?    x",
+\ ]
+  call s:compare_lines(expect, lines)
   " clean up
   call s:close_windows('set sbr=')
 endfunction
 
 function Test_breakindent08()
   " breakindent set and shift by 1, Number and list set sbr=# and briopt:sbr
-  call s:testwindows('setl briopt=shift:1,sbr,min:0 nu nuw=4 sbr=# list cpo+=n ts=4')
+  call s:test_windows('setl briopt=shift:1,sbr,min:0 nu nuw=4 sbr=# list cpo+=n ts=4')
   " make sure, cache is invalidated!
   set ts=8
   redraw!
   set ts=4
   redraw!
-  let g:line=s:screenline(line('.'),10)
+  let lines=s:screen_lines(line('.'),10)
-  let g:expect="  2 ^Iabcd\n#      opq\n#      BCD\n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "  2 ^Iabcd",
+\ "#      opq",
+\ "#      BCD",
+\ ]
+  call s:compare_lines(expect, lines)
   call s:close_windows('set sbr= cpo-=n')
 endfunction
 
 function Test_breakindent08a()
   " breakindent set and shift by 1, Number and list set sbr=# and briopt:sbr
-  call s:testwindows('setl briopt=shift:1,sbr,min:0 nu nuw=4 sbr=# list')
+  call s:test_windows('setl briopt=shift:1,sbr,min:0 nu nuw=4 sbr=# list')
-  let g:line=s:screenline(line('.'),10)
+  let lines=s:screen_lines(line('.'),10)
-  let g:expect="  2 ^Iabcd\n    #  opq\n    #  BCD\n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "  2 ^Iabcd",
+\ "    #  opq",
+\ "    #  BCD",
+\ ]
+  call s:compare_lines(expect, lines)
   call s:close_windows('set sbr=')
 endfunction
 
 function Test_breakindent09()
   " breakindent set and shift by 1, Number and list set sbr=#
-  call s:testwindows('setl briopt=shift:1,min:0 nu nuw=4 sbr=# list')
+  call s:test_windows('setl briopt=shift:1,min:0 nu nuw=4 sbr=# list')
-  let g:line=s:screenline(line('.'),10)
+  let lines=s:screen_lines(line('.'),10)
-  let g:expect="  2 ^Iabcd\n       #op\n       #AB\n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "  2 ^Iabcd",
+\ "       #op",
+\ "       #AB",
+\ ]
+  call s:compare_lines(expect, lines)
   call s:close_windows('set sbr=')
 endfunction
 
 function Test_breakindent10()
   " breakindent set, Number set sbr=~
-  call s:testwindows('setl cpo+=n sbr=~ nu nuw=4 nolist briopt=sbr,min:0')
+  call s:test_windows('setl cpo+=n sbr=~ nu nuw=4 nolist briopt=sbr,min:0')
   " make sure, cache is invalidated!
   set ts=8
   redraw!
   set ts=4
   redraw!
-  let g:line=s:screenline(line('.'),10)
+  let lines=s:screen_lines(line('.'),10)
-  let g:expect="  2     ab\n~       mn\n~       yz\n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "  2     ab",
+\ "~       mn",
+\ "~       yz",
+\ ]
+  call s:compare_lines(expect, lines)
   call s:close_windows('set sbr= cpo-=n')
 endfunction
 
 function Test_breakindent11()
   " test strdisplaywidth()
-  call s:testwindows('setl cpo-=n sbr=>> nu nuw=4 nolist briopt= ts=4')
+  call s:test_windows('setl cpo-=n sbr=>> nu nuw=4 nolist briopt= ts=4')
   let text=getline(2)
   let width = strlen(text[1:])+indent(2)+strlen(&sbr)*3 " text wraps 3 times
   call assert_equal(width, strdisplaywidth(text))
@@ -176,16 +214,20 @@ endfunction
 function Test_breakindent12()
   " test breakindent with long indent
   let s:input="\t\t\t\t\t{"
-  call s:testwindows('setl breakindent linebreak briopt=min:10 nu numberwidth=3 ts=4 list listchars=tab:>-')
+  call s:test_windows('setl breakindent linebreak briopt=min:10 nu numberwidth=3 ts=4 list listchars=tab:>-')
-  let g:line=s:screenline(2,16)
+  let lines=s:screen_lines(2,16)
-  let g:expect=" 2 >--->--->--->\n          ---{  \n~               \n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ " 2 >--->--->--->",
+\ "          ---{  ",
+\ "~               ",
+\ ]
+  call s:compare_lines(expect, lines)
   call s:close_windows('set nuw=4 listchars=')
 endfunction
 
 function Test_breakindent13()
   let s:input=""
-  call s:testwindows('setl breakindent briopt=min:10 ts=8')
+  call s:test_windows('setl breakindent briopt=min:10 ts=8')
   vert resize 20
   call setline(1, ["    a\tb\tc\td\te", "    z   y       x       w       v"])
   1
@@ -199,26 +241,34 @@ endfunction
 
 function Test_breakindent14()
   let s:input=""
-  call s:testwindows('setl breakindent briopt= ts=8')
+  call s:test_windows('setl breakindent briopt= ts=8')
   vert resize 30
   norm! 3a1234567890
   norm! a    abcde
   exec "norm! 0\<C-V>tex"
-  let g:line=s:screenline(line('.'),8)
+  let lines=s:screen_lines(line('.'),8)
-  let g:expect="e       \n~       \n~       \n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "e       ",
+\ "~       ",
+\ "~       ",
+\ ]
+  call s:compare_lines(expect, lines)
   call s:close_windows()
 endfunction
 
 function Test_breakindent15()
   let s:input=""
-  call s:testwindows('setl breakindent briopt= ts=8 sw=8')
+  call s:test_windows('setl breakindent briopt= ts=8 sw=8')
   vert resize 30
   norm! 4a1234567890
   exe "normal! >>\<C-V>3f0x"
-  let g:line=s:screenline(line('.'),20)
+  let lines=s:screen_lines(line('.'),20)
-  let g:expect="        1234567890  \n~                   \n~                   \n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "        1234567890  ",
+\ "~                   ",
+\ "~                   ",
+\ ]
+  call s:compare_lines(expect, lines)
   call s:close_windows()
 endfunction
 
@@ -226,16 +276,24 @@ function Test_breakindent16()
   " Check that overlong lines are indented correctly.
   " TODO: currently it does not fail even when the bug is not fixed.
   let s:input=""
-  call s:testwindows('setl breakindent briopt=min:0 ts=4')
+  call s:test_windows('setl breakindent briopt=min:0 ts=4')
   call setline(1, "\t".repeat("1234567890", 10))
   resize 6
   norm! 1gg$
   redraw!
-  let g:line=s:screenline(1,10)
+  let lines=s:screen_lines(1,10)
-  let g:expect="    123456\n    789012\n    345678\n"
+  let expect=[
-  call assert_equal(g:expect, g:line)
+\ "    123456",
-  let g:line=s:screenline(4,10)
+\ "    789012",
-  let g:expect="    901234\n    567890\n    123456\n"
+\ "    345678",
-  call assert_equal(g:expect, g:line)
+\ ]
+  call s:compare_lines(expect, lines)
+  let lines=s:screen_lines(4,10)
+  let expect=[
+\ "    901234",
+\ "    567890",
+\ "    123456",
+\ ]
+  call s:compare_lines(expect, lines)
   call s:close_windows()
 endfunction

src/nvim/testdir/test_listlbr.vim

@@ -0,0 +1,219 @@
+" Test for linebreak and list option (non-utf8)
+
+set encoding=latin1
+scriptencoding latin1
+
+if !exists("+linebreak") || !has("conceal")
+  finish
+endif
+
+source view_util.vim
+
+function s:screen_lines(lnum, width) abort
+  return ScreenLines(a:lnum, a:width)
+endfunction
+
+function! s:compare_lines(expect, actual)
+  call assert_equal(join(a:expect, "\n"), join(a:actual, "\n"))
+endfunction
+
+function s:test_windows(...)
+  call NewWindow(10, 20)
+  setl ts=8 sw=4 sts=4 linebreak sbr= wrap
+  exe get(a:000, 0, '')
+endfunction
+
+function s:close_windows(...)
+  call CloseWindow()
+  exe get(a:000, 0, '')
+endfunction
+
+func Test_set_linebreak()
+  call s:test_windows('setl ts=4 sbr=+')
+  call setline(1, "\tabcdef hijklmn\tpqrstuvwxyz_1060ABCDEFGHIJKLMNOP ")
+  let lines = s:screen_lines([1, 4], winwidth(0))
+  let expect = [
+\ "    abcdef          ",
+\ "+hijklmn            ",
+\ "+pqrstuvwxyz_1060ABC",
+\ "+DEFGHIJKLMNOP      ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_linebreak_with_list()
+  call s:test_windows('setl ts=4 sbr=+ list listchars=')
+  call setline(1, "\tabcdef hijklmn\tpqrstuvwxyz_1060ABCDEFGHIJKLMNOP ")
+  let lines = s:screen_lines([1, 4], winwidth(0))
+  let expect = [
+\ "^Iabcdef hijklmn^I  ",
+\ "+pqrstuvwxyz_1060ABC",
+\ "+DEFGHIJKLMNOP      ",
+\ "~                   ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_linebreak_with_nolist()
+  call s:test_windows('setl ts=4 sbr=+ nolist')
+  call setline(1, "\tabcdef hijklmn\tpqrstuvwxyz_1060ABCDEFGHIJKLMNOP ")
+  let lines = s:screen_lines([1, 4], winwidth(0))
+  let expect = [
+\ "    abcdef          ",
+\ "+hijklmn            ",
+\ "+pqrstuvwxyz_1060ABC",
+\ "+DEFGHIJKLMNOP      ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_should_break()
+  call s:test_windows('setl sbr=+ nolist')
+  call setline(1, "1\t" . repeat('a', winwidth(0)-2))
+  let lines = s:screen_lines([1, 4], winwidth(0))
+  let expect = [
+\ "1                   ",
+\ "+aaaaaaaaaaaaaaaaaa ",
+\ "~                   ",
+\ "~                   ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_linebreak_with_conceal()
+  call s:test_windows('setl cpo&vim sbr=+ list conceallevel=2 concealcursor=nv listchars=tab:ab')
+  call setline(1, "_S_\t bla")
+  syn match ConcealVar contained /_/ conceal
+  syn match All /.*/ contains=ConcealVar
+  let lines = s:screen_lines([1, 4], winwidth(0))
+  let expect = [
+\ "Sabbbbbb bla        ",
+\ "~                   ",
+\ "~                   ",
+\ "~                   ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_virtual_block()
+  call s:test_windows('setl sbr=+')
+  call setline(1, [
+\ "REMOVE: this not",
+\ "REMOVE: aaaaaaaaaaaaa",
+\ ])
+  exe "norm! 1/^REMOVE:"
+  exe "norm! 0\<C-V>jf x"
+  $put
+  let lines = s:screen_lines([1, 4], winwidth(0))
+  let expect = [
+\ "this not            ",
+\ "aaaaaaaaaaaaa       ",
+\ "REMOVE:             ",
+\ "REMOVE:             ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_virtual_block_and_vbA()
+  call s:test_windows()
+  call setline(1, "long line: " . repeat("foobar ", 40) . "TARGET at end")
+  exe "norm! $3B\<C-v>eAx\<Esc>"
+  let lines = s:screen_lines([1, 10], winwidth(0))
+  let expect = [
+\ "foobar foobar       ",
+\ "foobar foobar       ",
+\ "foobar foobar       ",
+\ "foobar foobar       ",
+\ "foobar foobar       ",
+\ "foobar foobar       ",
+\ "foobar foobar       ",
+\ "foobar foobar       ",
+\ "foobar foobar       ",
+\ "foobar TARGETx at   ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_virtual_char_and_block()
+  call s:test_windows()
+  call setline(1, "1111-1111-1111-11-1111-1111-1111")
+  exe "norm! 0f-lv3lc2222\<Esc>bgj."
+  let lines = s:screen_lines([1, 2], winwidth(0))
+  let expect = [
+\ "1111-2222-1111-11-  ",
+\ "1111-2222-1111      ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_undo_after_block_visual()
+  call s:test_windows()
+  call setline(1, ["aaa", "aaa", "a"])
+  exe "norm! gg\<C-V>2j~e."
+  let lines = s:screen_lines([1, 3], winwidth(0))
+  let expect = [
+\ "AaA                 ",
+\ "AaA                 ",
+\ "A                   ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_norm_after_block_visual()
+  call s:test_windows()
+  call setline(1, ["abcd{ef", "ghijklm", "no}pgrs"])
+  exe "norm! ggf{\<C-V>\<C-V>c%"
+  let lines = s:screen_lines([1, 3], winwidth(0))
+  let expect = [
+\ "abcdpgrs            ",
+\ "~                   ",
+\ "~                   ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_block_replace_after_wrapping()
+  call s:test_windows()
+  call setline(1, repeat("a", 150))
+  exe "norm! 0yypk147|\<C-V>jr0"
+  call assert_equal(repeat("a", 146) . "0aaa", getline(1))
+  call assert_equal(repeat("a", 146) . "0aaa", getline(2))
+  let lines = s:screen_lines([1, 10], winwidth(0))
+  let expect = [
+\ "aaaaaaaaaaaaaaaaaaaa",
+\ "aaaaaaaaaaaaaaaaaaaa",
+\ "aaaaaaaaaaaaaaaaaaaa",
+\ "aaaaaaaaaaaaaaaaaaaa",
+\ "aaaaaaaaaaaaaaaaaaaa",
+\ "aaaaaaaaaaaaaaaaaaaa",
+\ "aaaaaaaaaaaaaaaaaaaa",
+\ "aaaaaa0aaa          ",
+\ "@                   ",
+\ "@                   ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_list_with_listchars()
+  call s:test_windows('setl list listchars=space:_,trail:-,tab:>-,eol:$')
+  call setline(1, "a aaaaaaaaaaaaaaaaaaaaaa\ta ")
+  let lines = s:screen_lines([1, 3], winwidth(0))
+  let expect = [
+\ "a_                  ",
+\ "aaaaaaaaaaaaaaaaaaaa",
+\ "aa>-----a-$         ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc

src/nvim/testdir/test_listlbr_utf8.vim

@@ -0,0 +1,195 @@
+" Test for linebreak and list option in utf-8 mode
+
+set encoding=utf-8
+scriptencoding utf-8
+
+if !exists("+linebreak") || !has("conceal") || !has("signs")
+  finish
+endif
+
+source view_util.vim
+
+function s:screen_lines(lnum, width) abort
+  return ScreenLines(a:lnum, a:width)
+endfunction
+
+function! s:compare_lines(expect, actual)
+  call assert_equal(a:expect, a:actual)
+endfunction
+
+function s:screen_attr(lnum, chars, ...) abort
+  let line = getline(a:lnum)
+  let attr = []
+  let prefix = get(a:000, 0, 0)
+  for i in range(a:chars[0], a:chars[1])
+    let scol = strdisplaywidth(strcharpart(line, 0, i-1)) + 1
+    let attr += [screenattr(a:lnum, scol + prefix)]
+  endfor
+  return attr
+endfunction
+
+function s:test_windows(...)
+  call NewWindow(10, 20)
+  setl ts=4 sw=4 sts=4 linebreak sbr=+ wrap
+  exe get(a:000, 0, '')
+endfunction
+
+function s:close_windows(...)
+  call CloseWindow()
+  exe get(a:000, 0, '')
+endfunction
+
+func Test_linebreak_with_fancy_listchars()
+  call s:test_windows("setl list listchars=nbsp:\u2423,tab:\u2595\u2014,trail:\u02d1,eol:\ub6")
+  call setline(1, "\tabcdef hijklmn\tpqrstuvwxyz\u00a01060ABCDEFGHIJKLMNOP ")
+  redraw!
+  let lines = s:screen_lines([1, 4], winwidth(0))
+  let expect = [
+\ "▕———abcdef          ",
+\ "+hijklmn▕———        ",
+\ "+pqrstuvwxyz␣1060ABC",
+\ "+DEFGHIJKLMNOPˑ¶    ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_nolinebreak_with_list()
+  call s:test_windows("setl nolinebreak list listchars=nbsp:\u2423,tab:\u2595\u2014,trail:\u02d1,eol:\ub6")
+  call setline(1, "\tabcdef hijklmn\tpqrstuvwxyz\u00a01060ABCDEFGHIJKLMNOP ")
+  redraw!
+  let lines = s:screen_lines([1, 4], winwidth(0))
+  let expect = [
+\ "▕———abcdef hijklmn▕—",
+\ "+pqrstuvwxyz␣1060ABC",
+\ "+DEFGHIJKLMNOPˑ¶    ",
+\ "~                   ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_linebreak_with_nolist()
+  call s:test_windows('setl nolist')
+  call setline(1, "\t*mask = nil;")
+  redraw!
+  let lines = s:screen_lines([1, 4], winwidth(0))
+  let expect = [
+\ "    *mask = nil;    ",
+\ "~                   ",
+\ "~                   ",
+\ "~                   ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_list_and_concealing1()
+  call s:test_windows('setl list listchars=tab:>- cole=1')
+  call setline(1, [
+\ "#define ABCDE\t\t1",
+\ "#define ABCDEF\t\t1",
+\ "#define ABCDEFG\t\t1",
+\ "#define ABCDEFGH\t1",
+\ "#define MSG_MODE_FILE\t\t\t1",
+\ "#define MSG_MODE_CONSOLE\t\t2",
+\ "#define MSG_MODE_FILE_AND_CONSOLE\t3",
+\ "#define MSG_MODE_FILE_THEN_CONSOLE\t4",
+\ ])
+  vert resize 40
+  syn match Conceal conceal cchar=>'AB\|MSG_MODE'
+  redraw!
+  let lines = s:screen_lines([1, 7], winwidth(0))
+  let expect = [
+\ "#define ABCDE>-->---1                   ",
+\ "#define >CDEF>-->---1                   ",
+\ "#define >CDEFG>->---1                   ",
+\ "#define >CDEFGH>----1                   ",
+\ "#define >_FILE>--------->--->---1       ",
+\ "#define >_CONSOLE>---------->---2       ",
+\ "#define >_FILE_AND_CONSOLE>---------3   ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_list_and_concealing2()
+  call s:test_windows('setl nowrap ts=2 list listchars=tab:>- cole=2 concealcursor=n')
+  call setline(1, "bbeeeeee\t\t;\tsome text")
+  vert resize 40
+  syn clear
+  syn match meaning    /;\s*\zs.*/
+  syn match hasword    /^\x\{8}/    contains=word
+  syn match word       /\<\x\{8}\>/ contains=beginword,endword contained
+  syn match beginword  /\<\x\x/     contained conceal
+  syn match endword    /\x\{6}\>/   contained
+  hi meaning   guibg=blue
+  hi beginword guibg=green
+  hi endword   guibg=red
+  redraw!
+  let lines = s:screen_lines([1, 1], winwidth(0))
+  let expect = [
+\ "eeeeee>--->-;>some text                 ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_screenattr_for_comment()
+  call s:test_windows("setl ft=c ts=7 list listchars=nbsp:\u2423,tab:\u2595\u2014,trail:\u02d1,eol:\ub6")
+  call setline(1, " /*\t\t and some more */")
+  norm! gg0
+  syntax on
+  hi SpecialKey term=underline ctermfg=red guifg=red
+  redraw!
+  let line = getline(1)
+  let attr = s:screen_attr(1, [1, 6])
+  call assert_notequal(attr[0], attr[1])
+  call assert_notequal(attr[1], attr[3])
+  call assert_notequal(attr[3], attr[5])
+  call s:close_windows()
+endfunc
+
+func Test_visual_block_and_selection_exclusive()
+  call s:test_windows('setl selection=exclusive')
+  call setline(1, "long line: " . repeat("foobar ", 40) . "TARGETÃ' at end")
+  exe "norm! $3B\<C-v>eAx\<Esc>"
+  let lines = s:screen_lines([1, 10], winwidth(0))
+  let expect = [
+\ "+foobar foobar      ",
+\ "+foobar foobar      ",
+\ "+foobar foobar      ",
+\ "+foobar foobar      ",
+\ "+foobar foobar      ",
+\ "+foobar foobar      ",
+\ "+foobar foobar      ",
+\ "+foobar foobar      ",
+\ "+foobar foobar      ",
+\ "+foobar TARGETÃx'   ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc
+
+func Test_multibyte_sign_and_colorcolumn()
+  call s:test_windows("setl nolinebreak cc=3 list listchars=nbsp:\u2423,tab:\u2595\u2014,trail:\u02d1,eol:\ub6")
+  call setline(1, ["", "a b c", "a b c"])
+  exe "sign define foo text=\uff0b"
+  exe "sign place 1 name=foo line=2 buffer=" . bufnr('%')
+  redraw!
+  norm! ggj0
+  let signwidth = strdisplaywidth("\uff0b")
+  let attr1 = s:screen_attr(2, [1, 3], signwidth)
+  let attr2 = s:screen_attr(3, [1, 3], signwidth)
+  call assert_equal(attr1[0], attr2[0])
+  call assert_equal(attr1[1], attr2[1])
+  call assert_equal(attr1[2], attr2[2])
+  let lines = s:screen_lines([1, 3], winwidth(0))
+  let expect = [
+\ "  ¶                 ",
+\ "＋a b c¶            ",
+\ "  a b c¶            ",
+\ ]
+  call s:compare_lines(expect, lines)
+  call s:close_windows()
+endfunc

src/nvim/testdir/view_util.vim

@@ -0,0 +1,30 @@
+" Functions about view shared by several tests
+
+" ScreenLines(lnum, width) or
+" ScreenLines([start, end], width)
+function! ScreenLines(lnum, width) abort
+  redraw!
+  if type(a:lnum) == v:t_list
+    let start = a:lnum[0]
+    let end = a:lnum[1]
+  else
+    let start = a:lnum
+    let end = a:lnum
+  endif
+  let lines = []
+  for l in range(start, end)
+    let lines += [join(map(range(1, a:width), 'nr2char(screenchar(l, v:val))'), '')]
+  endfor
+  return lines
+endfunction
+
+function! NewWindow(height, width) abort
+  exe a:height . 'new'
+  exe a:width . 'vsp'
+  redraw!
+endfunction
+
+function! CloseWindow() abort
+  bw!
+  redraw!
+endfunction

src/nvim/version.c

@@ -641,7 +641,7 @@ static const int included_patches[] = {
   // 314,
   // 313,
   // 312,
-  // 311,
+  311,
   // 310,
   // 309,
   // 308,