Bram Moolenaar | 2d6c800 | 2016-01-03 23:31:24 +0100 | [diff] [blame] | 1 | " Test that the system menu can be loaded. |
| 2 | |
Bram Moolenaar | b46fecd | 2019-06-15 17:58:09 +0200 | [diff] [blame] | 3 | source check.vim |
| 4 | CheckFeature menu |
Bram Moolenaar | 11dd8c1 | 2017-03-04 20:41:34 +0100 | [diff] [blame] | 5 | |
Bram Moolenaar | 2d6c800 | 2016-01-03 23:31:24 +0100 | [diff] [blame] | 6 | func Test_load_menu() |
| 7 | try |
| 8 | source $VIMRUNTIME/menu.vim |
| 9 | catch |
Bram Moolenaar | 3717540 | 2017-03-18 20:18:45 +0100 | [diff] [blame] | 10 | call assert_report('error while loading menus: ' . v:exception) |
Bram Moolenaar | 2d6c800 | 2016-01-03 23:31:24 +0100 | [diff] [blame] | 11 | endtry |
Bram Moolenaar | a1c8ecf | 2017-03-04 21:41:05 +0100 | [diff] [blame] | 12 | call assert_match('browse confirm w', execute(':menu File.Save')) |
Bram Moolenaar | e24c5b3 | 2019-12-10 22:11:53 +0100 | [diff] [blame] | 13 | |
| 14 | let v:errmsg = '' |
| 15 | doautocmd LoadBufferMenu VimEnter |
| 16 | call assert_equal('', v:errmsg) |
| 17 | |
Bram Moolenaar | 11dd8c1 | 2017-03-04 20:41:34 +0100 | [diff] [blame] | 18 | source $VIMRUNTIME/delmenu.vim |
Bram Moolenaar | e24c5b3 | 2019-12-10 22:11:53 +0100 | [diff] [blame] | 19 | call assert_equal('', v:errmsg) |
Bram Moolenaar | 11dd8c1 | 2017-03-04 20:41:34 +0100 | [diff] [blame] | 20 | endfunc |
| 21 | |
| 22 | func Test_translate_menu() |
| 23 | if !has('multi_lang') |
| 24 | return |
| 25 | endif |
| 26 | if !filereadable($VIMRUNTIME . '/lang/menu_de_de.latin1.vim') |
| 27 | throw 'Skipped: translated menu not found' |
| 28 | endif |
| 29 | |
Bram Moolenaar | a1c8ecf | 2017-03-04 21:41:05 +0100 | [diff] [blame] | 30 | " First delete any English menus. |
| 31 | source $VIMRUNTIME/delmenu.vim |
Bram Moolenaar | 11dd8c1 | 2017-03-04 20:41:34 +0100 | [diff] [blame] | 32 | set langmenu=de_de |
| 33 | source $VIMRUNTIME/menu.vim |
Bram Moolenaar | 5558d19 | 2017-03-04 21:02:22 +0100 | [diff] [blame] | 34 | call assert_match('browse confirm w', execute(':menu Datei.Speichern')) |
Bram Moolenaar | 11dd8c1 | 2017-03-04 20:41:34 +0100 | [diff] [blame] | 35 | |
| 36 | source $VIMRUNTIME/delmenu.vim |
Bram Moolenaar | 2d6c800 | 2016-01-03 23:31:24 +0100 | [diff] [blame] | 37 | endfunc |
Bram Moolenaar | 4c5d815 | 2018-10-19 22:36:53 +0200 | [diff] [blame] | 38 | |
| 39 | func Test_menu_commands() |
| 40 | nmenu 2 Test.FooBar :let g:did_menu = 'normal'<CR> |
| 41 | vmenu 2 Test.FooBar :let g:did_menu = 'visual'<CR> |
| 42 | smenu 2 Test.FooBar :let g:did_menu = 'select'<CR> |
| 43 | omenu 2 Test.FooBar :let g:did_menu = 'op-pending'<CR> |
| 44 | tlmenu 2 Test.FooBar :let g:did_menu = 'terminal'<CR> |
| 45 | imenu 2 Test.FooBar :let g:did_menu = 'insert'<CR> |
| 46 | cmenu 2 Test.FooBar :let g:did_menu = 'cmdline'<CR> |
| 47 | emenu n Test.FooBar |
Bram Moolenaar | 297610b | 2019-12-27 17:20:55 +0100 | [diff] [blame] | 48 | |
| 49 | call feedkeys(":menu Test.FooB\<C-A>\<C-B>\"\<CR>", 'tx') |
| 50 | call assert_equal('"menu Test.FooBar', @:) |
| 51 | |
Bram Moolenaar | 4c5d815 | 2018-10-19 22:36:53 +0200 | [diff] [blame] | 52 | call assert_equal('normal', g:did_menu) |
| 53 | emenu v Test.FooBar |
| 54 | call assert_equal('visual', g:did_menu) |
| 55 | emenu s Test.FooBar |
| 56 | call assert_equal('select', g:did_menu) |
| 57 | emenu o Test.FooBar |
| 58 | call assert_equal('op-pending', g:did_menu) |
| 59 | emenu t Test.FooBar |
| 60 | call assert_equal('terminal', g:did_menu) |
| 61 | emenu i Test.FooBar |
| 62 | call assert_equal('insert', g:did_menu) |
| 63 | emenu c Test.FooBar |
| 64 | call assert_equal('cmdline', g:did_menu) |
| 65 | |
Bram Moolenaar | ce79353 | 2019-05-05 14:19:20 +0200 | [diff] [blame] | 66 | nunmenu Test.FooBar |
| 67 | call assert_fails('emenu n Test.FooBar', 'E335: Menu not defined for Normal mode') |
| 68 | vunmenu Test.FooBar |
| 69 | call assert_fails('emenu v Test.FooBar', 'E335: Menu not defined for Visual mode') |
| 70 | vmenu 2 Test.FooBar :let g:did_menu = 'visual'<CR> |
| 71 | sunmenu Test.FooBar |
| 72 | call assert_fails('emenu s Test.FooBar', 'E335: Menu not defined for Select mode') |
| 73 | ounmenu Test.FooBar |
| 74 | call assert_fails('emenu o Test.FooBar', 'E335: Menu not defined for Op-pending mode') |
| 75 | iunmenu Test.FooBar |
| 76 | call assert_fails('emenu i Test.FooBar', 'E335: Menu not defined for Insert mode') |
| 77 | cunmenu Test.FooBar |
| 78 | call assert_fails('emenu c Test.FooBar', 'E335: Menu not defined for Cmdline mode') |
Bram Moolenaar | 4c5d815 | 2018-10-19 22:36:53 +0200 | [diff] [blame] | 79 | tlunmenu Test.FooBar |
Bram Moolenaar | ce79353 | 2019-05-05 14:19:20 +0200 | [diff] [blame] | 80 | call assert_fails('emenu t Test.FooBar', 'E335: Menu not defined for Terminal mode') |
| 81 | |
| 82 | aunmenu Test.FooBar |
Bram Moolenaar | 4c5d815 | 2018-10-19 22:36:53 +0200 | [diff] [blame] | 83 | call assert_fails('emenu n Test.FooBar', 'E334:') |
| 84 | |
| 85 | nmenu 2 Test.FooBar.Child :let g:did_menu = 'foobar'<CR> |
| 86 | call assert_fails('emenu n Test.FooBar', 'E333:') |
| 87 | nunmenu Test.FooBar.Child |
| 88 | |
| 89 | unlet g:did_menu |
| 90 | endfun |
Bram Moolenaar | 8d588cc | 2020-02-25 21:47:45 +0100 | [diff] [blame] | 91 | |
Bram Moolenaar | 0eabd4d | 2020-03-15 16:13:53 +0100 | [diff] [blame] | 92 | " Test various menu related errors |
| 93 | func Test_menu_errors() |
| 94 | menu Test.Foo :version<CR> |
| 95 | |
| 96 | " Error cases |
| 97 | call assert_fails('menu .Test.Foo :ls<CR>', 'E475:') |
| 98 | call assert_fails('menu Test. :ls<CR>', 'E330:') |
| 99 | call assert_fails('menu Foo. :ls<CR>', 'E331:') |
| 100 | call assert_fails('unmenu Test.Foo abc', 'E488:') |
| 101 | call assert_fails('menu <Tab>:ls :ls<CR>', 'E792:') |
| 102 | call assert_fails('menu Test.<Tab>:ls :ls<CR>', 'E792:') |
| 103 | call assert_fails('menu Test.Foo.Bar :ls<CR>', 'E327:') |
| 104 | call assert_fails('menu Test.-Sep-.Baz :ls<CR>', 'E332:') |
| 105 | call assert_fails('menu Foo.Bar.--.Baz :ls<CR>', 'E332:') |
| 106 | call assert_fails('menu disable Test.Foo.Bar', 'E327:') |
| 107 | call assert_fails('menu disable T.Foo', 'E329:') |
| 108 | call assert_fails('unmenu Test.Foo.Bar', 'E327:') |
| 109 | call assert_fails('cunmenu Test.Foo', 'E328:') |
| 110 | call assert_fails('unmenu Test.Bar', 'E329:') |
| 111 | call assert_fails('menu Test.Foo.Bar', 'E327:') |
| 112 | call assert_fails('cmenu Test.Foo', 'E328:') |
| 113 | call assert_fails('emenu x Test.Foo', 'E475:') |
| 114 | call assert_fails('emenu Test.Foo.Bar', 'E334:') |
| 115 | call assert_fails('menutranslate Test', 'E474:') |
| 116 | |
| 117 | silent! unmenu Foo |
| 118 | unmenu Test |
| 119 | endfunc |
| 120 | |
Bram Moolenaar | 8d588cc | 2020-02-25 21:47:45 +0100 | [diff] [blame] | 121 | " Test for menu item completion in command line |
| 122 | func Test_menu_expand() |
| 123 | " Create the menu itmes for test |
| 124 | for i in range(1, 4) |
| 125 | let m = 'menu Xmenu.A' .. i .. '.A' .. i |
| 126 | for j in range(1, 4) |
| 127 | exe m .. 'B' .. j .. ' :echo "A' .. i .. 'B' .. j .. '"' .. "<CR>" |
| 128 | endfor |
| 129 | endfor |
| 130 | set wildmenu |
| 131 | |
| 132 | " Test for <CR> selecting a submenu |
| 133 | call feedkeys(":emenu Xmenu.A\<Tab>\<CR>\<Right>x\<BS>\<C-B>\"\<CR>", 'xt') |
| 134 | call assert_equal('"emenu Xmenu.A1.A1B2', @:) |
| 135 | |
| 136 | " Test for <Down> selecting a submenu |
| 137 | call feedkeys(":emenu Xmenu.A\<Tab>\<Right>\<Right>\<Down>" .. |
| 138 | \ "\<C-A>\<C-B>\"\<CR>", 'xt') |
| 139 | call assert_equal('"emenu Xmenu.A3.A3B1 A3B2 A3B3 A3B4', @:) |
| 140 | |
| 141 | " Test for <Up> to go up a submenu |
| 142 | call feedkeys(":emenu Xmenu.A\<Tab>\<Down>\<Up>\<Right>\<Right>" .. |
| 143 | \ "\<Left>\<Down>\<C-A>\<C-B>\"\<CR>", 'xt') |
| 144 | call assert_equal('"emenu Xmenu.A2.A2B1 A2B2 A2B3 A2B4', @:) |
| 145 | |
| 146 | " Test for <Up> to go up a menu |
| 147 | call feedkeys(":emenu Xmenu.A\<Tab>\<Down>\<Up>\<Up>\<Up>" .. |
| 148 | \ "\<C-A>\<C-B>\"\<CR>", 'xt') |
| 149 | call assert_equal('"emenu Buffers. Xmenu.', @:) |
| 150 | |
Bram Moolenaar | 0eabd4d | 2020-03-15 16:13:53 +0100 | [diff] [blame] | 151 | " Test for expanding only submenus |
| 152 | call feedkeys(":popup Xmenu.\<C-A>\<C-B>\"\<CR>", 'xt') |
| 153 | call assert_equal('"popup Xmenu.A1 A2 A3 A4', @:) |
| 154 | |
| 155 | " Test for expanding menus after enable/disable |
| 156 | call feedkeys(":menu enable Xmenu.\<C-A>\<C-B>\"\<CR>", 'xt') |
| 157 | call assert_equal('"menu enable Xmenu.A1. A2. A3. A4.', @:) |
| 158 | call feedkeys(":menu disable Xmenu.\<C-A>\<C-B>\"\<CR>", 'xt') |
| 159 | call assert_equal('"menu disable Xmenu.A1. A2. A3. A4.', @:) |
| 160 | |
| 161 | " Test for expanding non-existing menu path |
| 162 | call feedkeys(":menu xyz.\<C-A>\<C-B>\"\<CR>", 'xt') |
| 163 | call assert_equal('"menu xyz.', @:) |
| 164 | call feedkeys(":menu Xmenu.A1.A1B1.xyz.\<C-A>\<C-B>\"\<CR>", 'xt') |
| 165 | call assert_equal('"menu Xmenu.A1.A1B1.xyz.', @:) |
| 166 | |
Bram Moolenaar | 8d588cc | 2020-02-25 21:47:45 +0100 | [diff] [blame] | 167 | set wildmenu& |
| 168 | unmenu Xmenu |
Bram Moolenaar | 0eabd4d | 2020-03-15 16:13:53 +0100 | [diff] [blame] | 169 | |
| 170 | " Test for expanding popup menus with some hidden items |
| 171 | menu Xmenu.foo.A1 a1 |
| 172 | menu Xmenu.]bar bar |
| 173 | menu Xmenu.]baz.B1 b1 |
| 174 | menu Xmenu.-sep- : |
| 175 | call feedkeys(":popup Xmenu.\<C-A>\<C-B>\"\<CR>", 'xt') |
| 176 | call assert_equal('"popup Xmenu.foo', @:) |
| 177 | unmenu Xmenu |
| 178 | |
| 179 | endfunc |
| 180 | |
| 181 | " Test for the menu_info() function |
| 182 | func Test_menu_info() |
| 183 | " Define menus with various attributes |
| 184 | 10nnoremenu 10.10 T&est.F&oo :echo 'foo'<CR> |
| 185 | 10nmenu <silent> 10.20 T&est.B&ar<Tab>:bar :echo 'bar'<CR> |
| 186 | 10nmenu <script> 10.30.5 T&est.Ba&z.Qu&x :echo 'qux'<CR> |
| 187 | |
| 188 | let d = #{name: "B&ar\t:bar", display: 'Bar', modes: 'n', shortcut: 'a', |
| 189 | \ accel: ':bar', priority: 20, enabled: v:true, silent: v:true, |
| 190 | \ noremenu: v:false, script: v:false, rhs: ":echo 'bar'<CR>"} |
| 191 | call assert_equal(d, menu_info('Test.Bar')) |
| 192 | |
| 193 | let d = #{name: 'Ba&z', display: 'Baz', modes: 'n', shortcut: 'z', |
| 194 | \ priority: 30, submenus: ['Qux']} |
| 195 | call assert_equal(d, menu_info('Test.Baz')) |
| 196 | |
| 197 | let d = #{name: 'T&est', display: 'Test', modes: 'n', shortcut: 'e', |
| 198 | \ priority: 10, submenus: ['Foo', 'Bar', 'Baz']} |
| 199 | call assert_equal(d, menu_info('Test')) |
| 200 | call assert_equal({}, menu_info('Test.Dummy')) |
| 201 | call assert_equal({}, menu_info('Dummy')) |
| 202 | |
| 203 | nmenu disable Test.Foo |
| 204 | call assert_equal(v:false, menu_info('Test.Foo').enabled) |
| 205 | nmenu enable Test.Foo |
| 206 | call assert_equal(v:true, menu_info('Test.Foo').enabled) |
| 207 | |
| 208 | call assert_equal(menu_info('Test.Foo'), menu_info('Test.Foo', '')) |
| 209 | nmenu Test.abc <Nop> |
| 210 | call assert_equal('<Nop>', menu_info('Test.abc').rhs) |
| 211 | call assert_fails('call menu_info([])', 'E730:') |
| 212 | nunmenu Test |
| 213 | |
| 214 | " Test for defining menus in different modes |
| 215 | menu Test.menu :menu<CR> |
| 216 | menu! Test.menu! :menu!<CR> |
| 217 | amenu Test.amenu :amenu<CR> |
| 218 | nmenu Test.nmenu :nmenu<CR> |
| 219 | omenu Test.omenu :omenu<CR> |
| 220 | vmenu Test.vmenu :vmenu<CR> |
| 221 | xmenu Test.xmenu :xmenu<CR> |
| 222 | smenu Test.smenu :smenu<CR> |
| 223 | imenu <silent> <script> Test.imenu :imenu<CR> |
| 224 | cmenu Test.cmenu :cmenu<CR> |
| 225 | tlmenu Test.tlmenu :tlmenu<CR> |
| 226 | tmenu Test.nmenu Normal mode menu |
| 227 | tmenu Test.omenu Op-pending mode menu |
| 228 | noremenu Test.noremenu :noremenu<CR> |
| 229 | noremenu! Test.noremenu! :noremenu!<CR> |
| 230 | anoremenu Test.anoremenu :anoremenu<CR> |
| 231 | nnoremenu Test.nnoremenu :nnoremenu<CR> |
| 232 | onoremenu Test.onoremenu :onoremenu<CR> |
| 233 | vnoremenu Test.vnoremenu :vnoremenu<CR> |
| 234 | xnoremenu Test.xnoremenu :xnoremenu<CR> |
| 235 | snoremenu Test.snoremenu :snoremenu<CR> |
| 236 | inoremenu <silent> Test.inoremenu :inoremenu<CR> |
| 237 | cnoremenu Test.cnoremenu :cnoremenu<CR> |
| 238 | tlnoremenu Test.tlnoremenu :tlnoremenu<CR> |
| 239 | call assert_equal(#{name: 'menu', priority: 500, shortcut: '', |
| 240 | \ display: 'menu', modes: ' ', enabled: v:true, silent: v:false, |
| 241 | \ rhs: ":menu<CR>", noremenu: v:false, script: v:false}, |
| 242 | \ menu_info('Test.menu')) |
| 243 | call assert_equal(#{name: 'menu!', priority: 500, shortcut: '', |
| 244 | \ display: 'menu!', modes: '!', enabled: v:true, silent: v:false, |
| 245 | \ rhs: ":menu!<CR>", noremenu: v:false, script: v:false}, |
| 246 | \ menu_info('Test.menu!', '!')) |
| 247 | call assert_equal(#{name: 'amenu', priority: 500, shortcut: '', |
| 248 | \ display: 'amenu', modes: 'a', enabled: v:true, silent: v:false, |
| 249 | \ rhs: ":amenu<CR>", noremenu: v:false, script: v:false}, |
| 250 | \ menu_info('Test.amenu', 'a')) |
| 251 | call assert_equal(#{name: 'nmenu', priority: 500, shortcut: '', |
| 252 | \ display: 'nmenu', modes: 'n', enabled: v:true, silent: v:false, |
| 253 | \ rhs: ':nmenu<CR>', noremenu: v:false, script: v:false}, |
| 254 | \ menu_info('Test.nmenu', 'n')) |
| 255 | call assert_equal(#{name: 'omenu', priority: 500, shortcut: '', |
| 256 | \ display: 'omenu', modes: 'o', enabled: v:true, silent: v:false, |
| 257 | \ rhs: ':omenu<CR>', noremenu: v:false, script: v:false}, |
| 258 | \ menu_info('Test.omenu', 'o')) |
| 259 | call assert_equal(#{name: 'vmenu', priority: 500, shortcut: '', |
| 260 | \ display: 'vmenu', modes: 'v', enabled: v:true, silent: v:false, |
| 261 | \ rhs: ':vmenu<CR>', noremenu: v:false, script: v:false}, |
| 262 | \ menu_info('Test.vmenu', 'v')) |
| 263 | call assert_equal(#{name: 'xmenu', priority: 500, shortcut: '', |
| 264 | \ display: 'xmenu', modes: 'x', enabled: v:true, silent: v:false, |
| 265 | \ rhs: ':xmenu<CR>', noremenu: v:false, script: v:false}, |
| 266 | \ menu_info('Test.xmenu', 'x')) |
| 267 | call assert_equal(#{name: 'smenu', priority: 500, shortcut: '', |
| 268 | \ display: 'smenu', modes: 's', enabled: v:true, silent: v:false, |
| 269 | \ rhs: ':smenu<CR>', noremenu: v:false, script: v:false}, |
| 270 | \ menu_info('Test.smenu', 's')) |
| 271 | call assert_equal(#{name: 'imenu', priority: 500, shortcut: '', |
| 272 | \ display: 'imenu', modes: 'i', enabled: v:true, silent: v:true, |
| 273 | \ rhs: ':imenu<CR>', noremenu: v:false, script: v:true}, |
| 274 | \ menu_info('Test.imenu', 'i')) |
| 275 | call assert_equal(#{ name: 'cmenu', priority: 500, shortcut: '', |
| 276 | \ display: 'cmenu', modes: 'c', enabled: v:true, silent: v:false, |
| 277 | \ rhs: ':cmenu<CR>', noremenu: v:false, script: v:false}, |
| 278 | \ menu_info('Test.cmenu', 'c')) |
| 279 | call assert_equal(#{name: 'tlmenu', priority: 500, shortcut: '', |
| 280 | \ display: 'tlmenu', modes: 'tl', enabled: v:true, silent: v:false, |
| 281 | \ rhs: ':tlmenu<CR>', noremenu: v:false, script: v:false}, |
| 282 | \ menu_info('Test.tlmenu', 'tl')) |
| 283 | call assert_equal(#{name: 'noremenu', priority: 500, shortcut: '', |
| 284 | \ display: 'noremenu', modes: ' ', enabled: v:true, silent: v:false, |
| 285 | \ rhs: ":noremenu<CR>", noremenu: v:true, script: v:false}, |
| 286 | \ menu_info('Test.noremenu')) |
| 287 | call assert_equal(#{name: 'noremenu!', priority: 500, shortcut: '', |
| 288 | \ display: 'noremenu!', modes: '!', enabled: v:true, silent: v:false, |
| 289 | \ rhs: ":noremenu!<CR>", noremenu: v:true, script: v:false}, |
| 290 | \ menu_info('Test.noremenu!', '!')) |
| 291 | call assert_equal(#{name: 'anoremenu', priority: 500, shortcut: '', |
| 292 | \ display: 'anoremenu', modes: 'a', enabled: v:true, silent: v:false, |
| 293 | \ rhs: ":anoremenu<CR>", noremenu: v:true, script: v:false}, |
| 294 | \ menu_info('Test.anoremenu', 'a')) |
| 295 | call assert_equal(#{name: 'nnoremenu', priority: 500, shortcut: '', |
| 296 | \ display: 'nnoremenu', modes: 'n', enabled: v:true, silent: v:false, |
| 297 | \ rhs: ':nnoremenu<CR>', noremenu: v:true, script: v:false}, |
| 298 | \ menu_info('Test.nnoremenu', 'n')) |
| 299 | call assert_equal(#{name: 'onoremenu', priority: 500, shortcut: '', |
| 300 | \ display: 'onoremenu', modes: 'o', enabled: v:true, silent: v:false, |
| 301 | \ rhs: ':onoremenu<CR>', noremenu: v:true, script: v:false}, |
| 302 | \ menu_info('Test.onoremenu', 'o')) |
| 303 | call assert_equal(#{name: 'vnoremenu', priority: 500, shortcut: '', |
| 304 | \ display: 'vnoremenu', modes: 'v', enabled: v:true, silent: v:false, |
| 305 | \ rhs: ':vnoremenu<CR>', noremenu: v:true, script: v:false}, |
| 306 | \ menu_info('Test.vnoremenu', 'v')) |
| 307 | call assert_equal(#{name: 'xnoremenu', priority: 500, shortcut: '', |
| 308 | \ display: 'xnoremenu', modes: 'x', enabled: v:true, silent: v:false, |
| 309 | \ rhs: ':xnoremenu<CR>', noremenu: v:true, script: v:false}, |
| 310 | \ menu_info('Test.xnoremenu', 'x')) |
| 311 | call assert_equal(#{name: 'snoremenu', priority: 500, shortcut: '', |
| 312 | \ display: 'snoremenu', modes: 's', enabled: v:true, silent: v:false, |
| 313 | \ rhs: ':snoremenu<CR>', noremenu: v:true, script: v:false}, |
| 314 | \ menu_info('Test.snoremenu', 's')) |
| 315 | call assert_equal(#{name: 'inoremenu', priority: 500, shortcut: '', |
| 316 | \ display: 'inoremenu', modes: 'i', enabled: v:true, silent: v:true, |
| 317 | \ rhs: ':inoremenu<CR>', noremenu: v:true, script: v:false}, |
| 318 | \ menu_info('Test.inoremenu', 'i')) |
| 319 | call assert_equal(#{ name: 'cnoremenu', priority: 500, shortcut: '', |
| 320 | \ display: 'cnoremenu', modes: 'c', enabled: v:true, silent: v:false, |
| 321 | \ rhs: ':cnoremenu<CR>', noremenu: v:true, script: v:false}, |
| 322 | \ menu_info('Test.cnoremenu', 'c')) |
| 323 | call assert_equal(#{name: 'tlnoremenu', priority: 500, shortcut: '', |
| 324 | \ display: 'tlnoremenu', modes: 'tl', enabled: v:true, silent: v:false, |
| 325 | \ rhs: ':tlnoremenu<CR>', noremenu: v:true, script: v:false}, |
| 326 | \ menu_info('Test.tlnoremenu', 'tl')) |
| 327 | aunmenu Test |
| 328 | tlunmenu Test |
| 329 | call assert_equal({}, menu_info('Test')) |
| 330 | call assert_equal({}, menu_info('Test', '!')) |
| 331 | call assert_equal({}, menu_info('Test', 'a')) |
| 332 | call assert_equal({}, menu_info('Test', 'n')) |
| 333 | call assert_equal({}, menu_info('Test', 'o')) |
| 334 | call assert_equal({}, menu_info('Test', 'v')) |
| 335 | call assert_equal({}, menu_info('Test', 'x')) |
| 336 | call assert_equal({}, menu_info('Test', 's')) |
| 337 | call assert_equal({}, menu_info('Test', 'i')) |
| 338 | call assert_equal({}, menu_info('Test', 'c')) |
| 339 | call assert_equal({}, menu_info('Test', 't')) |
| 340 | call assert_equal({}, menu_info('Test', 'tl')) |
| 341 | |
| 342 | amenu Test.amenu :amenu<CR> |
| 343 | call assert_equal(':amenu<CR>', menu_info('Test.amenu', '').rhs) |
| 344 | call assert_equal('<C-\><C-O>:amenu<CR>', menu_info('Test.amenu', '!').rhs) |
| 345 | call assert_equal(':amenu<CR>', menu_info('Test.amenu', 'n').rhs) |
| 346 | call assert_equal('<C-C>:amenu<CR><C-\><C-G>', |
| 347 | \ menu_info('Test.amenu', 'o').rhs) |
| 348 | call assert_equal('<C-C>:amenu<CR><C-\><C-G>', |
| 349 | \ menu_info('Test.amenu', 'v').rhs) |
| 350 | call assert_equal('<C-C>:amenu<CR><C-\><C-G>', |
| 351 | \ menu_info('Test.amenu', 'x').rhs) |
| 352 | call assert_equal('<C-C>:amenu<CR><C-\><C-G>', |
| 353 | \ menu_info('Test.amenu', 's').rhs) |
| 354 | call assert_equal('<C-\><C-O>:amenu<CR>', menu_info('Test.amenu', 'i').rhs) |
| 355 | call assert_equal('<C-C>:amenu<CR><C-\><C-G>', |
| 356 | \ menu_info('Test.amenu', 'c').rhs) |
| 357 | aunmenu Test.amenu |
| 358 | |
| 359 | " Test for hidden menus |
| 360 | menu ]Test.menu :menu<CR> |
| 361 | call assert_equal(#{name: ']Test', display: ']Test', priority: 500, |
| 362 | \ shortcut: '', modes: ' ', submenus: ['menu']}, |
| 363 | \ menu_info(']Test')) |
| 364 | unmenu ]Test |
| 365 | endfunc |
| 366 | |
| 367 | " Test for <special> keyword in a menu with 'cpo' containing '<' |
| 368 | func Test_menu_special() |
| 369 | new |
| 370 | set cpo+=< |
| 371 | nmenu Test.Sign am<Tab>n<Esc> |
| 372 | call feedkeys(":emenu n Test.Sign\<CR>", 'x') |
| 373 | call assert_equal("m<Tab>n<Esc>", getline(1)) |
| 374 | nunmenu Test.Sign |
| 375 | nmenu <special> Test.Sign am<Tab>n<Esc> |
| 376 | call setline(1, '') |
| 377 | call feedkeys(":emenu n Test.Sign\<CR>", 'x') |
| 378 | call assert_equal("m\tn", getline(1)) |
| 379 | set cpo-=< |
| 380 | close! |
| 381 | nunmenu Test.Sign |
| 382 | endfunc |
| 383 | |
| 384 | " Test for "icon=filname" in a toolbar |
| 385 | func Test_menu_icon() |
| 386 | CheckFeature toolbar |
| 387 | nmenu icon=myicon.xpm Toolbar.Foo :echo "Foo"<CR> |
| 388 | call assert_equal('myicon.xpm', "Toolbar.Foo"->menu_info().icon) |
| 389 | nunmenu Toolbar.Foo |
| 390 | |
| 391 | " Test for using the builtin icon |
| 392 | amenu ToolBar.BuiltIn22 :echo "BuiltIn22"<CR> |
| 393 | call assert_equal(#{name: 'BuiltIn22', display: 'BuiltIn22', |
| 394 | \ enabled: v:true, shortcut: '', modes: 'a', script: v:false, |
| 395 | \ iconidx: 22, priority: 500, silent: v:false, |
| 396 | \ rhs: ':echo "BuiltIn22"<CR>', noremenu: v:false}, |
| 397 | \ menu_info("ToolBar.BuiltIn22")) |
| 398 | aunmenu ToolBar.BuiltIn22 |
| 399 | endfunc |
| 400 | |
| 401 | " Test for ":emenu" command in different modes |
| 402 | func Test_emenu_cmd() |
| 403 | new |
| 404 | xmenu Test.foo rx |
| 405 | call setline(1, ['aaaa', 'bbbb']) |
| 406 | normal ggVj |
| 407 | %emenu Test.foo |
| 408 | call assert_equal(['xxxx', 'xxxx'], getline(1, 2)) |
| 409 | call setline(1, ['aaaa', 'bbbb']) |
| 410 | exe "normal ggVj\<Esc>" |
| 411 | %emenu Test.foo |
| 412 | call assert_equal(['xxxx', 'xxxx'], getline(1, 2)) |
| 413 | call setline(1, ['aaaa', 'bbbb']) |
| 414 | exe "normal ggV\<Esc>" |
| 415 | 2emenu Test.foo |
| 416 | call assert_equal(['aaaa', 'xxxx'], getline(1, 2)) |
| 417 | xunmenu Test.foo |
| 418 | close! |
| 419 | endfunc |
| 420 | |
| 421 | " Test for PopUp menus |
| 422 | func Test_popup_menu() |
| 423 | 20menu PopUp.foo :echo 'foo'<CR> |
| 424 | 20menu PopUp.bar :echo 'bar'<CR> |
| 425 | call assert_equal(#{name: 'PopUp', display: 'PopUp', priority: 20, |
| 426 | \ shortcut: '', modes: ' ', submenus: ['foo', 'bar']}, |
| 427 | \ menu_info('PopUp')) |
| 428 | menu disable PopUp.bar |
| 429 | call assert_equal(v:true, "PopUp.foo"->menu_info().enabled) |
| 430 | call assert_equal(v:false, "PopUp.bar"->menu_info().enabled) |
| 431 | menu enable PopUp.bar |
| 432 | call assert_equal(v:true, "PopUp.bar"->menu_info().enabled) |
| 433 | unmenu PopUp |
| 434 | endfunc |
| 435 | |
| 436 | " Test for listing the menus using the :menu command |
| 437 | func Test_show_menus() |
| 438 | " In the GUI, tear-off menu items are present in the output below |
| 439 | " So skip this test |
| 440 | CheckNotGui |
| 441 | aunmenu * |
| 442 | call assert_equal(['--- Menus ---'], split(execute('menu'), "\n")) |
| 443 | nmenu <script> 200.10 Test.nmenu1 :nmenu1<CR> |
| 444 | nmenu 200.20 Test.nmenu2 :nmenu2<CR> |
| 445 | nnoremenu 200.30 Test.nmenu3 :nmenu3<CR> |
| 446 | nmenu 200.40 Test.nmenu4 :nmenu4<CR> |
| 447 | nmenu 200.50 disable Test.nmenu4 |
| 448 | let exp =<< trim [TEXT] |
| 449 | --- Menus --- |
| 450 | 200 Test |
| 451 | 10 nmenu1 |
| 452 | n& :nmenu1<CR> |
| 453 | 20 nmenu2 |
| 454 | n :nmenu2<CR> |
| 455 | 30 nmenu3 |
| 456 | n* :nmenu3<CR> |
| 457 | 40 nmenu4 |
| 458 | n - :nmenu4<CR> |
| 459 | [TEXT] |
| 460 | call assert_equal(exp, split(execute('nmenu'), "\n")) |
| 461 | nunmenu Test |
| 462 | endfunc |
| 463 | |
| 464 | " Test for menu tips |
| 465 | func Test_tmenu() |
| 466 | tunmenu * |
| 467 | call assert_equal(['--- Menus ---'], split(execute('tmenu'), "\n")) |
| 468 | tmenu Test.nmenu1 nmenu1 |
| 469 | tmenu Test.nmenu2.sub1 nmenu2.sub1 |
| 470 | let exp =<< trim [TEXT] |
| 471 | --- Menus --- |
| 472 | 500 Test |
| 473 | 500 nmenu1 |
| 474 | t - nmenu1 |
| 475 | 500 nmenu2 |
| 476 | 500 sub1 |
| 477 | t - nmenu2.sub1 |
| 478 | [TEXT] |
| 479 | call assert_equal(exp, split(execute('tmenu'), "\n")) |
| 480 | tunmenu Test |
Bram Moolenaar | 8d588cc | 2020-02-25 21:47:45 +0100 | [diff] [blame] | 481 | endfunc |
| 482 | |
| 483 | " vim: shiftwidth=2 sts=2 expandtab |