Add test case for fold on multigrid

1 files changed, 944 insertions, 357 deletions

diff --git a/test/functional/ui/fold_spec.lua b/test/functional/ui/fold_spec.lua
index 9877f30206..669ec5d3ed 100644
--- a/test/functional/ui/fold_spec.lua
+++ b/test/functional/ui/fold_spec.lua
@@ -10,375 +10,962 @@ local source = helpers.source
 local assert_alive = helpers.assert_alive
 
 describe("folded lines", function()
-  local screen
   before_each(function()
     clear()
-    screen = Screen.new(45, 8)
-    screen:attach({rgb=true})
-    screen:set_default_attr_ids({
-      [1] = {bold = true, foreground = Screen.colors.Blue1},
-      [2] = {reverse = true},
-      [3] = {bold = true, reverse = true},
-      [4] = {foreground = Screen.colors.Grey100, background = Screen.colors.Red},
-      [5] = {foreground = Screen.colors.DarkBlue, background = Screen.colors.LightGrey},
-      [6] = {background = Screen.colors.Yellow},
-      [7] = {foreground = Screen.colors.DarkBlue, background = Screen.colors.WebGray},
-      [8] = {foreground = Screen.colors.Brown },
-      [9] = {bold = true, foreground = Screen.colors.Brown}
-    })
   end)
 
-  it("work with more than one signcolumn", function()
-    command("set signcolumn=yes:9")
-    feed("i<cr><esc>")
-    feed("vkzf")
-    screen:expect([[
-        {7:                  }{5:^+--  2 lines: ·············}|
-        {1:~                                            }|
-        {1:~                                            }|
-        {1:~                                            }|
-        {1:~                                            }|
-        {1:~                                            }|
-        {1:~                                            }|
-                                                     |
-    ]])
-  end)
+  local function with_ext_multigrid(multigrid)
+    local screen
+    before_each(function()
+      clear()
+      screen = Screen.new(45, 8)
+      screen:attach({rgb=true, ext_multigrid=multigrid})
+      screen:set_default_attr_ids({
+        [1] = {bold = true, foreground = Screen.colors.Blue1},
+        [2] = {reverse = true},
+        [3] = {bold = true, reverse = true},
+        [4] = {foreground = Screen.colors.Grey100, background = Screen.colors.Red},
+        [5] = {foreground = Screen.colors.DarkBlue, background = Screen.colors.LightGrey},
+        [6] = {background = Screen.colors.Yellow},
+        [7] = {foreground = Screen.colors.DarkBlue, background = Screen.colors.WebGray},
+        [8] = {foreground = Screen.colors.Brown },
+        [9] = {bold = true, foreground = Screen.colors.Brown}
+      })
+    end)
 
-  it("highlighting with relative line numbers", function()
-    command("set relativenumber foldmethod=marker")
-    feed_command("set foldcolumn=2")
-    funcs.setline(1, '{{{1')
-    funcs.setline(2, 'line 1')
-    funcs.setline(3, '{{{1')
-    funcs.setline(4, 'line 2')
-    feed("j")
-    screen:expect([[
-      {7:+ }{8:  1 }{5:+--  2 lines: ·························}|
-      {7:+ }{9:  0 }{5:^+--  2 lines: ·························}|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      :set foldcolumn=2                            |
-    ]])
-  end)
+    it("work with more than one signcolumn", function()
+      command("set signcolumn=yes:9")
+      feed("i<cr><esc>")
+      feed("vkzf")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {7:                  }{5:^+--  2 lines: ·············}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+        ## grid 3
+                                                       |
+        ]])
+      else
+        screen:expect([[
+          {7:                  }{5:^+--  2 lines: ·············}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+                                                       |
+        ]])
+      end
+    end)
 
-  it("works with multibyte fillchars", function()
-    insert([[
-      aa
-      bb
-      cc
-      dd
-      ee
-      ff]])
-    command("set fillchars+=foldopen:▾,foldsep:│,foldclose:▸")
-    feed_command('1')
-    command("set foldcolumn=2")
-    feed('zf4j')
-    feed('zf2j')
-    feed('zO')
-    screen:expect{grid=[[
-      {7:▾▾}^aa                                         |
-      {7:││}bb                                         |
-      {7:││}cc                                         |
-      {7:││}dd                                         |
-      {7:││}ee                                         |
-      {7:│ }ff                                         |
-      {1:~                                            }|
-      :1                                           |
-    ]]}
-
-    feed_command("set rightleft")
-    screen:expect{grid=[[
-                                               a^a{7:▾▾}|
-                                               bb{7:││}|
-                                               cc{7:││}|
-                                               dd{7:││}|
-                                               ee{7:││}|
-                                               ff{7: │}|
-      {1:                                            ~}|
-      :set rightleft                               |
-    ]]}
-
-    feed_command("set norightleft")
-    meths.input_mouse('left', 'press', '', 0, 0, 1)
-    screen:expect{grid=[[
-    {7:▾▸}{5:^+---  5 lines: aa··························}|
-    {7:│ }ff                                         |
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-    :set norightleft                             |
-    ]]}
-  end)
+    it("highlighting with relative line numbers", function()
+      command("set relativenumber foldmethod=marker")
+      feed_command("set foldcolumn=2")
+      funcs.setline(1, '{{{1')
+      funcs.setline(2, 'line 1')
+      funcs.setline(3, '{{{1')
+      funcs.setline(4, 'line 2')
+      feed("j")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {7:+ }{8:  1 }{5:+--  2 lines: ·························}|
+          {7:+ }{9:  0 }{5:^+--  2 lines: ·························}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+        ## grid 3
+          :set foldcolumn=2                            |
+        ]])
+      else
+        screen:expect([[
+          {7:+ }{8:  1 }{5:+--  2 lines: ·························}|
+          {7:+ }{9:  0 }{5:^+--  2 lines: ·························}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          :set foldcolumn=2                            |
+        ]])
+      end
+    end)
 
-  it("works with multibyte text", function()
-    -- Currently the only allowed value of 'maxcombine'
-    eq(6, meths.get_option('maxcombine'))
-    eq(true, meths.get_option('arabicshape'))
-    insert([[
-      å 语 x̨̣̘̫̲͚͎̎͂̀̂͛͛̾͢͟ العَرَبِيَّة
-      möre text]])
-    screen:expect([[
-      å 语 x̎͂̀̂͛͛ ﺎﻠﻋَﺮَﺒِﻳَّﺓ                               |
-      möre tex^t                                    |
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-                                                   |
-    ]])
-
-    feed('vkzf')
-    screen:expect{grid=[[
-      {5:^+--  2 lines: å 语 x̎͂̀̂͛͛ العَرَبِيَّة·················}|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-                                                   |
-    ]]}
-
-    feed_command("set noarabicshape")
-    screen:expect([[
-      {5:^+--  2 lines: å 语 x̎͂̀̂͛͛ العَرَبِيَّة·················}|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      :set noarabicshape                           |
-    ]])
-
-    feed_command("set number foldcolumn=2")
-    screen:expect([[
-      {7:+ }{8:  1 }{5:^+--  2 lines: å 语 x̎͂̀̂͛͛ العَرَبِيَّة···········}|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      :set number foldcolumn=2                     |
-    ]])
-
-    -- Note: too much of the folded line gets cut off.This is a vim bug.
-    feed_command("set rightleft")
-    screen:expect([[
-      {5:···········ةيَّبِرَعَلا x̎͂̀̂͛͛ 语 å :senil 2  --^+}{8: 1  }{7: +}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      :set rightleft                               |
-    ]])
-
-    feed_command("set nonumber foldcolumn=0")
-    screen:expect([[
-      {5:·················ةيَّبِرَعَلا x̎͂̀̂͛͛ 语 å :senil 2  --^+}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      :set nonumber foldcolumn=0                   |
-    ]])
-
-    feed_command("set arabicshape")
-    screen:expect([[
-      {5:·················ةيَّبِرَعَلا x̎͂̀̂͛͛ 语 å :senil 2  --^+}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      :set arabicshape                             |
-    ]])
-
-    feed('zo')
-    screen:expect([[
-                                     ﺔﻴَّﺑِﺮَﻌَ^ﻟﺍ x̎͂̀̂͛͛ 语 å|
-                                          txet eröm|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      :set arabicshape                             |
-    ]])
-
-    feed_command('set noarabicshape')
-    screen:expect([[
-                                     ةيَّبِرَعَ^لا x̎͂̀̂͛͛ 语 å|
-                                          txet eröm|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      {1:                                            ~}|
-      :set noarabicshape                           |
-    ]])
+    it("works with multibyte fillchars", function()
+      insert([[
+        aa
+        bb
+        cc
+        dd
+        ee
+        ff]])
+      command("set fillchars+=foldopen:▾,foldsep:│,foldclose:▸")
+      feed_command('1')
+      command("set foldcolumn=2")
+      feed('zf4j')
+      feed('zf2j')
+      feed('zO')
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {7:▾▾}^aa                                         |
+          {7:││}bb                                         |
+          {7:││}cc                                         |
+          {7:││}dd                                         |
+          {7:││}ee                                         |
+          {7:│ }ff                                         |
+          {1:~                                            }|
+        ## grid 3
+          :1                                           |
+        ]])
+      else
+        screen:expect([[
+          {7:▾▾}^aa                                         |
+          {7:││}bb                                         |
+          {7:││}cc                                         |
+          {7:││}dd                                         |
+          {7:││}ee                                         |
+          {7:│ }ff                                         |
+          {1:~                                            }|
+          :1                                           |
+        ]])
+      end
 
-  end)
+      feed_command("set rightleft")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+                                                   a^a{7:▾▾}|
+                                                   bb{7:││}|
+                                                   cc{7:││}|
+                                                   dd{7:││}|
+                                                   ee{7:││}|
+                                                   ff{7: │}|
+          {1:                                            ~}|
+        ## grid 3
+          :set rightleft                               |
+        ]])
+      else
+        screen:expect([[
+                                                   a^a{7:▾▾}|
+                                                   bb{7:││}|
+                                                   cc{7:││}|
+                                                   dd{7:││}|
+                                                   ee{7:││}|
+                                                   ff{7: │}|
+          {1:                                            ~}|
+          :set rightleft                               |
+        ]])
+      end
 
-  it("work in cmdline window", function()
-    feed_command("set foldmethod=manual")
-    feed_command("let x = 1")
-    feed_command("/alpha")
-    feed_command("/omega")
-
-    feed("<cr>q:")
-    screen:expect([[
-                                                   |
-      {2:[No Name]                                    }|
-      {1::}set foldmethod=manual                       |
-      {1::}let x = 1                                   |
-      {1::}^                                            |
-      {1:~                                            }|
-      {3:[Command Line]                               }|
-      :                                            |
-    ]])
-
-    feed("kzfk")
-    screen:expect([[
-                                                   |
-      {2:[No Name]                                    }|
-      {1::}{5:^+--  2 lines: set foldmethod=manual·········}|
-      {1::}                                            |
-      {1:~                                            }|
-      {1:~                                            }|
-      {3:[Command Line]                               }|
-      :                                            |
-    ]])
-
-    feed("<cr>")
-    screen:expect([[
-      ^                                             |
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      :                                            |
-    ]])
-
-    feed("/<c-f>")
-    screen:expect([[
-                                                   |
-      {2:[No Name]                                    }|
-      {1:/}alpha                                       |
-      {1:/}{6:omega}                                       |
-      {1:/}^                                            |
-      {1:~                                            }|
-      {3:[Command Line]                               }|
-      /                                            |
-    ]])
-
-    feed("ggzfG")
-    screen:expect([[
-                                                   |
-      {2:[No Name]                                    }|
-      {1:/}{5:^+--  3 lines: alpha·························}|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {3:[Command Line]                               }|
-      /                                            |
-    ]])
+      feed_command("set norightleft")
+      if multigrid then
+        meths.input_mouse('left', 'press', '', 2, 0, 1)
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {7:▾▸}{5:^+---  5 lines: aa··························}|
+          {7:│ }ff                                         |
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+        ## grid 3
+          :set norightleft                             |
+        ]])
+      else
+        meths.input_mouse('left', 'press', '', 0, 0, 1)
+        screen:expect([[
+          {7:▾▸}{5:^+---  5 lines: aa··························}|
+          {7:│ }ff                                         |
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          :set norightleft                             |
+        ]])
+      end
+    end)
 
-  end)
+    it("works with multibyte text", function()
+      -- Currently the only allowed value of 'maxcombine'
+      eq(6, meths.get_option('maxcombine'))
+      eq(true, meths.get_option('arabicshape'))
+      insert([[
+        å 语 x̨̣̘̫̲͚͎̎͂̀̂͛͛̾͢͟ العَرَبِيَّة
+        möre text]])
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          å 语 x̎͂̀̂͛͛ ﺎﻠﻋَﺮَﺒِﻳَّﺓ                               |
+          möre tex^t                                    |
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+        ## grid 3
+                                                       |
+        ]])
+      else
+        screen:expect([[
+          å 语 x̎͂̀̂͛͛ ﺎﻠﻋَﺮَﺒِﻳَّﺓ                               |
+          möre tex^t                                    |
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+                                                       |
+        ]])
+      end
+
+      feed('vkzf')
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {5:^+--  2 lines: å 语 x̎͂̀̂͛͛ العَرَبِيَّة·················}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+        ## grid 3
+                                                       |
+        ]])
+      else
+        screen:expect([[
+          {5:^+--  2 lines: å 语 x̎͂̀̂͛͛ العَرَبِيَّة·················}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+                                                       |
+        ]])
+      end
+
+      feed_command("set noarabicshape")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {5:^+--  2 lines: å 语 x̎͂̀̂͛͛ العَرَبِيَّة·················}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+        ## grid 3
+          :set noarabicshape                           |
+        ]])
+      else
+        screen:expect([[
+          {5:^+--  2 lines: å 语 x̎͂̀̂͛͛ العَرَبِيَّة·················}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          :set noarabicshape                           |
+        ]])
+      end
+
+      feed_command("set number foldcolumn=2")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {7:+ }{8:  1 }{5:^+--  2 lines: å 语 x̎͂̀̂͛͛ العَرَبِيَّة···········}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+        ## grid 3
+          :set number foldcolumn=2                     |
+        ]])
+      else
+        screen:expect([[
+          {7:+ }{8:  1 }{5:^+--  2 lines: å 语 x̎͂̀̂͛͛ العَرَبِيَّة···········}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          :set number foldcolumn=2                     |
+        ]])
+      end
+
+      -- Note: too much of the folded line gets cut off.This is a vim bug.
+      feed_command("set rightleft")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {5:···········ةيَّبِرَعَلا x̎͂̀̂͛͛ 语 å :senil 2  --^+}{8: 1  }{7: +}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+        ## grid 3
+          :set rightleft                               |
+        ]])
+      else
+        screen:expect([[
+          {5:···········ةيَّبِرَعَلا x̎͂̀̂͛͛ 语 å :senil 2  --^+}{8: 1  }{7: +}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          :set rightleft                               |
+        ]])
+      end
+
+      feed_command("set nonumber foldcolumn=0")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {5:·················ةيَّبِرَعَلا x̎͂̀̂͛͛ 语 å :senil 2  --^+}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+        ## grid 3
+          :set nonumber foldcolumn=0                   |
+        ]])
+      else
+        screen:expect([[
+          {5:·················ةيَّبِرَعَلا x̎͂̀̂͛͛ 语 å :senil 2  --^+}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          :set nonumber foldcolumn=0                   |
+        ]])
+      end
+
+      feed_command("set arabicshape")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {5:·················ةيَّبِرَعَلا x̎͂̀̂͛͛ 语 å :senil 2  --^+}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+        ## grid 3
+          :set arabicshape                             |
+        ]])
+      else
+        screen:expect([[
+          {5:·················ةيَّبِرَعَلا x̎͂̀̂͛͛ 语 å :senil 2  --^+}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          :set arabicshape                             |
+        ]])
+      end
+
+      feed('zo')
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+                                         ﺔﻴَّﺑِﺮَﻌَ^ﻟﺍ x̎͂̀̂͛͛ 语 å|
+                                              txet eröm|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+        ## grid 3
+          :set arabicshape                             |
+        ]])
+      else
+        screen:expect([[
+                                         ﺔﻴَّﺑِﺮَﻌَ^ﻟﺍ x̎͂̀̂͛͛ 语 å|
+                                              txet eröm|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          :set arabicshape                             |
+        ]])
+      end
+
+      feed_command('set noarabicshape')
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+                                         ةيَّبِرَعَ^لا x̎͂̀̂͛͛ 语 å|
+                                              txet eröm|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+        ## grid 3
+          :set noarabicshape                           |
+        ]])
+      else
+        screen:expect([[
+                                         ةيَّبِرَعَ^لا x̎͂̀̂͛͛ 语 å|
+                                              txet eröm|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          {1:                                            ~}|
+          :set noarabicshape                           |
+        ]])
+      end
+
+    end)
+
+    it("work in cmdline window", function()
+      feed_command("set foldmethod=manual")
+      feed_command("let x = 1")
+      feed_command("/alpha")
+      feed_command("/omega")
+
+      feed("<cr>q:")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          {2:[No Name]                                    }|
+          [4:---------------------------------------------]|
+          [4:---------------------------------------------]|
+          [4:---------------------------------------------]|
+          [4:---------------------------------------------]|
+          {3:[Command Line]                               }|
+          [3:---------------------------------------------]|
+        ## grid 2
+                                                       |
+        ## grid 3
+          :                                            |
+        ## grid 4
+          {1::}set foldmethod=manual                       |
+          {1::}let x = 1                                   |
+          {1::}^                                            |
+          {1:~                                            }|
+        ]])
+      else
+        screen:expect([[
+                                                       |
+          {2:[No Name]                                    }|
+          {1::}set foldmethod=manual                       |
+          {1::}let x = 1                                   |
+          {1::}^                                            |
+          {1:~                                            }|
+          {3:[Command Line]                               }|
+          :                                            |
+        ]])
+      end
+
+      feed("kzfk")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          {2:[No Name]                                    }|
+          [4:---------------------------------------------]|
+          [4:---------------------------------------------]|
+          [4:---------------------------------------------]|
+          [4:---------------------------------------------]|
+          {3:[Command Line]                               }|
+          [3:---------------------------------------------]|
+        ## grid 2
+                                                       |
+        ## grid 3
+          :                                            |
+        ## grid 4
+          {1::}{5:^+--  2 lines: set foldmethod=manual·········}|
+          {1::}                                            |
+          {1:~                                            }|
+          {1:~                                            }|
+        ]])
+      else
+        screen:expect([[
+                                                       |
+          {2:[No Name]                                    }|
+          {1::}{5:^+--  2 lines: set foldmethod=manual·········}|
+          {1::}                                            |
+          {1:~                                            }|
+          {1:~                                            }|
+          {3:[Command Line]                               }|
+          :                                            |
+        ]])
+      end
+
+      feed("<cr>")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          ^                                             |
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+        ## grid 3
+          :                                            |
+        ]])
+      else
+        screen:expect([[
+          ^                                             |
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          :                                            |
+        ]])
+      end
+
+      feed("/<c-f>")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          {2:[No Name]                                    }|
+          [5:---------------------------------------------]|
+          [5:---------------------------------------------]|
+          [5:---------------------------------------------]|
+          [5:---------------------------------------------]|
+          {3:[Command Line]                               }|
+          [3:---------------------------------------------]|
+        ## grid 2
+                                                       |
+        ## grid 3
+          /                                            |
+        ## grid 5
+          {1:/}alpha                                       |
+          {1:/}{6:omega}                                       |
+          {1:/}^                                            |
+          {1:~                                            }|
+        ]])
+      else
+        screen:expect([[
+                                                       |
+          {2:[No Name]                                    }|
+          {1:/}alpha                                       |
+          {1:/}{6:omega}                                       |
+          {1:/}^                                            |
+          {1:~                                            }|
+          {3:[Command Line]                               }|
+          /                                            |
+        ]])
+      end
+
+      feed("ggzfG")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          {2:[No Name]                                    }|
+          [5:---------------------------------------------]|
+          [5:---------------------------------------------]|
+          [5:---------------------------------------------]|
+          [5:---------------------------------------------]|
+          {3:[Command Line]                               }|
+          [3:---------------------------------------------]|
+        ## grid 2
+                                                       |
+        ## grid 3
+          /                                            |
+        ## grid 5
+          {1:/}{5:^+--  3 lines: alpha·························}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+        ]])
+      else
+        screen:expect([[
+                                                       |
+          {2:[No Name]                                    }|
+          {1:/}{5:^+--  3 lines: alpha·························}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {3:[Command Line]                               }|
+          /                                            |
+        ]])
+      end
+
+    end)
+
+    it("work with autoresize", function()
+
+      funcs.setline(1, 'line 1')
+      funcs.setline(2, 'line 2')
+      funcs.setline(3, 'line 3')
+      funcs.setline(4, 'line 4')
+
+      feed("zfj")
+      command("set foldcolumn=0")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {5:^+--  2 lines: line 1·························}|
+          line 3                                       |
+          line 4                                       |
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+        ## grid 3
+                                                       |
+        ]])
+      else
+        screen:expect([[
+          {5:^+--  2 lines: line 1·························}|
+          line 3                                       |
+          line 4                                       |
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+                                                       |
+        ]])
+      end
+      -- should adapt to the current nesting of folds (e.g., 1)
+      command("set foldcolumn=auto:1")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {7:+}{5:^+--  2 lines: line 1························}|
+          {7: }line 3                                      |
+          {7: }line 4                                      |
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+        ## grid 3
+                                                       |
+        ]])
+      else
+        screen:expect([[
+          {7:+}{5:^+--  2 lines: line 1························}|
+          {7: }line 3                                      |
+          {7: }line 4                                      |
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+                                                       |
+        ]])
+      end
+      -- fdc should not change with a new fold as the maximum is 1
+      feed("zf3j")
+
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {7:+}{5:^+--  4 lines: line 1························}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+        ## grid 3
+                                                       |
+        ]])
+      else
+        screen:expect([[
+          {7:+}{5:^+--  4 lines: line 1························}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+                                                       |
+        ]])
+      end
+
+      -- relax the maximum fdc thus fdc should expand to
+      -- accomodate the current number of folds
+      command("set foldcolumn=auto:4")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {7:+ }{5:^+--  4 lines: line 1·······················}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+        ## grid 3
+                                                       |
+        ]])
+      else
+        screen:expect([[
+          {7:+ }{5:^+--  4 lines: line 1·······················}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+                                                       |
+        ]])
+      end
+    end)
+
+    it('does not crash when foldtext is longer than columns #12988', function()
+      source([[
+        function! MyFoldText() abort
+          return repeat('-', &columns + 100)
+        endfunction
+      ]])
+      command('set foldtext=MyFoldText()')
+      feed("i<cr><esc>")
+      feed("vkzf")
+      if multigrid then
+        screen:expect([[
+        ## grid 1
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [2:---------------------------------------------]|
+          [3:---------------------------------------------]|
+        ## grid 2
+          {5:^---------------------------------------------}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+        ## grid 3
+                                                       |
+        ]])
+      else
+        screen:expect([[
+          {5:^---------------------------------------------}|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+          {1:~                                            }|
+                                                       |
+        ]])
+      end
+      assert_alive()
+    end)
+  end
 
-  it("work with autoresize", function()
-
-    funcs.setline(1, 'line 1')
-    funcs.setline(2, 'line 2')
-    funcs.setline(3, 'line 3')
-    funcs.setline(4, 'line 4')
-
-    feed("zfj")
-    command("set foldcolumn=0")
-    screen:expect{grid=[[
-      {5:^+--  2 lines: line 1·························}|
-      line 3                                       |
-      line 4                                       |
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-      {1:~                                            }|
-                                                   |
-    ]]}
-    -- should adapt to the current nesting of folds (e.g., 1)
-    command("set foldcolumn=auto:1")
-    screen:expect{grid=[[
-    {7:+}{5:^+--  2 lines: line 1························}|
-    {7: }line 3                                      |
-    {7: }line 4                                      |
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-                                                 |
-    ]]}
-    -- fdc should not change with a new fold as the maximum is 1
-    feed("zf3j")
-
-    screen:expect{grid=[[
-    {7:+}{5:^+--  4 lines: line 1························}|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-                                                 |
-    ]]}
-
-    -- relax the maximum fdc thus fdc should expand to
-    -- accomodate the current number of folds
-    command("set foldcolumn=auto:4")
-    screen:expect{grid=[[
-    {7:+ }{5:^+--  4 lines: line 1·······················}|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-                                                 |
-    ]]}
+  describe("with ext_multigrid", function()
+    with_ext_multigrid(true)
   end)
 
-  it('does not crash when foldtext is longer than columns #12988', function()
-    source([[
-      function! MyFoldText() abort
-        return repeat('-', &columns + 100)
-      endfunction
-    ]])
-    command('set foldtext=MyFoldText()')
-    feed("i<cr><esc>")
-    feed("vkzf")
-    screen:expect{grid=[[
-    {5:^---------------------------------------------}|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-    {1:~                                            }|
-                                                 |
-    ]]}
-    assert_alive()
+  describe('without ext_multigrid', function()
+    with_ext_multigrid(false)
   end)
 end)