Merge pull request #19638 from zeertzjq/vim-8.2.0385

vim-patch:8.2.{0385,0392,3459}: menu_info()

4 files changed, 603 insertions, 48 deletions

diff --git a/src/nvim/eval.lua b/src/nvim/eval.lua
index c8eb0334fa..6d8776d08b 100644
--- a/src/nvim/eval.lua
+++ b/src/nvim/eval.lua
@@ -264,6 +264,7 @@ return {
     matchstrpos={args={2,4}, base=1},
     max={args=1, base=1},
     menu_get={args={1, 2}},
+    menu_info={args={1, 2}, base=1},
     min={args=1, base=1},
     mkdir={args={1, 3}, base=1},
     mode={args={0, 1}, base=1},
diff --git a/src/nvim/menu.c b/src/nvim/menu.c
index febb66081a..be13675b2a 100644
--- a/src/nvim/menu.c
+++ b/src/nvim/menu.c
@@ -810,17 +810,23 @@ static vimmenu_T *find_menu(vimmenu_T *menu, char *name, int modes)
 /// Show the mapping associated with a menu item or hierarchy in a sub-menu.
 static int show_menus(char *const path_name, int modes)
 {
-  // First, find the (sub)menu with the given name
-  vimmenu_T *menu = find_menu(*get_root_menu(path_name), path_name, modes);
-  if (!menu) {
-    return FAIL;
+  vimmenu_T *menu = *get_root_menu(path_name);
+  if (menu != NULL) {
+    // First, find the (sub)menu with the given name
+    menu = find_menu(menu, path_name, modes);
+    if (menu == NULL) {
+      return FAIL;
+    }
   }
+  // When there are no menus at all, the title still needs to be shown.
 
   // Now we have found the matching menu, and we list the mappings
   // Highlight title
   msg_puts_title(_("\n--- Menus ---"));
 
-  show_menus_recursive(menu->parent, modes, 0);
+  if (menu != NULL) {
+    show_menus_recursive(menu->parent, modes, 0);
+  }
   return OK;
 }
 
@@ -1161,7 +1167,7 @@ char *menu_name_skip(char *const name)
  * Return TRUE when "name" matches with menu "menu".  The name is compared in
  * two ways: raw menu name and menu name without '&'.  ignore part after a TAB.
  */
-static bool menu_name_equal(const char *const name, vimmenu_T *const menu)
+static bool menu_name_equal(const char *const name, const vimmenu_T *const menu)
 {
   if (menu->en_name != NULL
       && (menu_namecmp(name, menu->en_name)
@@ -1256,6 +1262,58 @@ int get_menu_cmd_modes(const char *cmd, bool forceit, int *noremap, int *unmenu)
   return modes;
 }
 
+/// Return the string representation of the menu modes. Does the opposite
+/// of get_menu_cmd_modes().
+static char *get_menu_mode_str(int modes)
+{
+  if ((modes & (MENU_INSERT_MODE | MENU_CMDLINE_MODE | MENU_NORMAL_MODE |
+                MENU_VISUAL_MODE | MENU_SELECT_MODE | MENU_OP_PENDING_MODE))
+      == (MENU_INSERT_MODE | MENU_CMDLINE_MODE | MENU_NORMAL_MODE |
+          MENU_VISUAL_MODE | MENU_SELECT_MODE | MENU_OP_PENDING_MODE)) {
+    return "a";
+  }
+  if ((modes & (MENU_NORMAL_MODE | MENU_VISUAL_MODE | MENU_SELECT_MODE |
+                MENU_OP_PENDING_MODE))
+      == (MENU_NORMAL_MODE | MENU_VISUAL_MODE | MENU_SELECT_MODE |
+          MENU_OP_PENDING_MODE)) {
+    return " ";
+  }
+  if ((modes & (MENU_INSERT_MODE | MENU_CMDLINE_MODE))
+      == (MENU_INSERT_MODE | MENU_CMDLINE_MODE)) {
+    return "!";
+  }
+  if ((modes & (MENU_VISUAL_MODE | MENU_SELECT_MODE))
+      == (MENU_VISUAL_MODE | MENU_SELECT_MODE)) {
+    return "v";
+  }
+  if (modes & MENU_VISUAL_MODE) {
+    return "x";
+  }
+  if (modes & MENU_SELECT_MODE) {
+    return "s";
+  }
+  if (modes & MENU_OP_PENDING_MODE) {
+    return "o";
+  }
+  if (modes & MENU_INSERT_MODE) {
+    return "i";
+  }
+  if (modes & MENU_TERMINAL_MODE) {
+    return "tl";
+  }
+  if (modes & MENU_CMDLINE_MODE) {
+    return "c";
+  }
+  if (modes & MENU_NORMAL_MODE) {
+    return "n";
+  }
+  if (modes & MENU_TIP_MODE) {
+    return "t";
+  }
+
+  return "";
+}
+
 /*
  * Modify a menu name starting with "PopUp" to include the mode character.
  * Returns the name in allocated memory.
@@ -1547,8 +1605,52 @@ void execute_menu(const exarg_T *eap, vimmenu_T *menu, int mode_idx)
   }
 }
 
-// Given a menu descriptor, e.g. "File.New", find it in the menu hierarchy and
-// execute it.
+/// Lookup a menu by the descriptor name e.g. "File.New"
+/// Returns NULL if the menu is not found
+static vimmenu_T *menu_getbyname(char *name_arg)
+  FUNC_ATTR_NONNULL_ALL
+{
+  char *saved_name = xstrdup(name_arg);
+  vimmenu_T *menu = *get_root_menu(saved_name);
+  char *name = saved_name;
+  bool gave_emsg = false;
+  while (*name) {
+    // Find in the menu hierarchy
+    char *p = menu_name_skip(name);
+
+    while (menu != NULL) {
+      if (menu_name_equal(name, menu)) {
+        if (*p == NUL && menu->children != NULL) {
+          emsg(_("E333: Menu path must lead to a menu item"));
+          gave_emsg = true;
+          menu = NULL;
+        } else if (*p != NUL && menu->children == NULL) {
+          emsg(_(e_notsubmenu));
+          menu = NULL;
+        }
+        break;
+      }
+      menu = menu->next;
+    }
+    if (menu == NULL || *p == NUL) {
+      break;
+    }
+    menu = menu->children;
+    name = p;
+  }
+  xfree(saved_name);
+  if (menu == NULL) {
+    if (!gave_emsg) {
+      semsg(_("E334: Menu not found: %s"), name_arg);
+    }
+    return NULL;
+  }
+
+  return menu;
+}
+
+/// Given a menu descriptor, e.g. "File.New", find it in the menu hierarchy and
+/// execute it.
 void ex_emenu(exarg_T *eap)
 {
   char *arg = eap->arg;
@@ -1584,39 +1686,8 @@ void ex_emenu(exarg_T *eap)
     arg = skipwhite(arg + 2);
   }
 
-  char *saved_name = xstrdup(arg);
-  vimmenu_T *menu = *get_root_menu(saved_name);
-  char *name = saved_name;
-  bool gave_emsg = false;
-  while (*name) {
-    // Find in the menu hierarchy
-    char *p = menu_name_skip(name);
-
-    while (menu != NULL) {
-      if (menu_name_equal(name, menu)) {
-        if (*p == NUL && menu->children != NULL) {
-          emsg(_("E333: Menu path must lead to a menu item"));
-          gave_emsg = true;
-          menu = NULL;
-        } else if (*p != NUL && menu->children == NULL) {
-          emsg(_(e_notsubmenu));
-          menu = NULL;
-        }
-        break;
-      }
-      menu = menu->next;
-    }
-    if (menu == NULL || *p == NUL) {
-      break;
-    }
-    menu = menu->children;
-    name = p;
-  }
-  xfree(saved_name);
+  vimmenu_T *menu = menu_getbyname(arg);
   if (menu == NULL) {
-    if (!gave_emsg) {
-      semsg(_("E334: Menu not found: %s"), arg);
-    }
     return;
   }
 
@@ -1819,3 +1890,119 @@ static char *menu_translate_tab_and_shift(char *arg_start)
 
   return arg;
 }
+
+/// Get the information about a menu item in mode 'which'
+static void menuitem_getinfo(const char *menu_name, const vimmenu_T *menu, int modes, dict_T *dict)
+  FUNC_ATTR_NONNULL_ALL
+{
+  if (*menu_name == NUL) {
+    // Return all the top-level menus
+    list_T *const l = tv_list_alloc(kListLenMayKnow);
+    tv_dict_add_list(dict, S_LEN("submenus"), l);
+    // get all the children.  Skip PopUp[nvoci].
+    for (const vimmenu_T *topmenu = menu; topmenu != NULL; topmenu = topmenu->next) {
+      if (!menu_is_hidden(topmenu->dname)) {
+        tv_list_append_string(l, topmenu->dname, -1);
+      }
+    }
+    return;
+  }
+
+  tv_dict_add_str(dict, S_LEN("name"), menu->name);
+  tv_dict_add_str(dict, S_LEN("display"), menu->dname);
+  if (menu->actext != NULL) {
+    tv_dict_add_str(dict, S_LEN("accel"), menu->actext);
+  }
+  tv_dict_add_nr(dict, S_LEN("priority"), (int)menu->priority);
+  tv_dict_add_str(dict, S_LEN("modes"), get_menu_mode_str(menu->modes));
+
+  char buf[NUMBUFLEN];
+  buf[utf_char2bytes(menu->mnemonic, buf)] = NUL;
+  tv_dict_add_str(dict, S_LEN("shortcut"), buf);
+
+  if (menu->children == NULL) {  // leaf menu
+    int bit;
+
+    // Get the first mode in which the menu is available
+    for (bit = 0; (bit < MENU_MODES) && !((1 << bit) & modes); bit++) {}
+
+    if (bit < MENU_MODES) {  // just in case, avoid Coverity warning
+      if (menu->strings[bit] != NULL) {
+        tv_dict_add_allocated_str(dict, S_LEN("rhs"),
+                                  *menu->strings[bit] == NUL
+                                  ? xstrdup("<Nop>")
+                                  : str2special_save(menu->strings[bit], false, false));
+      }
+      tv_dict_add_bool(dict, S_LEN("noremenu"), menu->noremap[bit] == REMAP_NONE);
+      tv_dict_add_bool(dict, S_LEN("script"), menu->noremap[bit] == REMAP_SCRIPT);
+      tv_dict_add_bool(dict, S_LEN("silent"), menu->silent[bit]);
+      tv_dict_add_bool(dict, S_LEN("enabled"), (menu->enabled & (1 << bit)) != 0);
+    }
+  } else {
+    // If there are submenus, add all the submenu display names
+    list_T *const l = tv_list_alloc(kListLenMayKnow);
+    tv_dict_add_list(dict, S_LEN("submenus"), l);
+    const vimmenu_T *child = menu->children;
+    while (child != NULL) {
+      tv_list_append_string(l, child->dname, -1);
+      child = child->next;
+    }
+  }
+}
+
+/// "menu_info()" function
+/// Return information about a menu (including all the child menus)
+void f_menu_info(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+{
+  tv_dict_alloc_ret(rettv);
+  dict_T *const retdict = rettv->vval.v_dict;
+
+  const char *const menu_name = tv_get_string_chk(&argvars[0]);
+  if (menu_name == NULL) {
+    return;
+  }
+
+  // menu mode
+  const char *which;
+  if (argvars[1].v_type != VAR_UNKNOWN) {
+    which = tv_get_string_chk(&argvars[1]);
+  } else {
+    which = "";  // Default is modes for "menu"
+  }
+  if (which == NULL) {
+    return;
+  }
+
+  const int modes = get_menu_cmd_modes(which, *which == '!', NULL, NULL);
+
+  // Locate the specified menu or menu item
+  const vimmenu_T *menu = *get_root_menu(menu_name);
+  char *const saved_name = xstrdup(menu_name);
+  if (*saved_name != NUL) {
+    char *name = saved_name;
+    while (*name) {
+      // Find in the menu hierarchy
+      char *p = menu_name_skip(name);
+      while (menu != NULL) {
+        if (menu_name_equal(name, menu)) {
+          break;
+        }
+        menu = menu->next;
+      }
+      if (menu == NULL || *p == NUL) {
+        break;
+      }
+      menu = menu->children;
+      name = p;
+    }
+  }
+  xfree(saved_name);
+
+  if (menu == NULL) {  // specified menu not found
+    return;
+  }
+
+  if (menu->modes & modes) {
+    menuitem_getinfo(menu_name, menu, modes, retdict);
+  }
+}
diff --git a/src/nvim/testdir/test_menu.vim b/src/nvim/testdir/test_menu.vim
index 4af75be514..28db050f82 100644
--- a/src/nvim/testdir/test_menu.vim
+++ b/src/nvim/testdir/test_menu.vim
@@ -89,6 +89,35 @@ func Test_menu_commands()
   unlet g:did_menu
 endfun
 
+" Test various menu related errors
+func Test_menu_errors()
+  menu Test.Foo  :version<CR>
+
+  " Error cases
+  call assert_fails('menu .Test.Foo :ls<CR>', 'E475:')
+  call assert_fails('menu Test. :ls<CR>', 'E330:')
+  call assert_fails('menu Foo. :ls<CR>', 'E331:')
+  call assert_fails('unmenu Test.Foo abc', 'E488:')
+  call assert_fails('menu <Tab>:ls  :ls<CR>', 'E792:')
+  call assert_fails('menu Test.<Tab>:ls  :ls<CR>', 'E792:')
+  call assert_fails('menu Test.Foo.Bar  :ls<CR>', 'E327:')
+  call assert_fails('menu Test.-Sep-.Baz  :ls<CR>', 'E332:')
+  call assert_fails('menu Foo.Bar.--.Baz  :ls<CR>', 'E332:')
+  call assert_fails('menu disable Test.Foo.Bar', 'E327:')
+  call assert_fails('menu disable T.Foo', 'E329:')
+  call assert_fails('unmenu Test.Foo.Bar', 'E327:')
+  call assert_fails('cunmenu Test.Foo', 'E328:')
+  call assert_fails('unmenu Test.Bar', 'E329:')
+  call assert_fails('menu Test.Foo.Bar', 'E327:')
+  call assert_fails('cmenu Test.Foo', 'E328:')
+  call assert_fails('emenu x Test.Foo', 'E475:')
+  call assert_fails('emenu Test.Foo.Bar', 'E334:')
+  call assert_fails('menutranslate Test', 'E474:')
+
+  silent! unmenu Foo
+  unmenu Test
+endfunc
+
 " Test for menu item completion in command line
 func Test_menu_expand()
   " Create the menu itmes for test
@@ -119,8 +148,340 @@ func Test_menu_expand()
         \ "\<C-A>\<C-B>\"\<CR>", 'xt')
   call assert_equal('"emenu Buffers. Xmenu.', @:)
 
+  " Test for expanding only submenus
+  call feedkeys(":popup Xmenu.\<C-A>\<C-B>\"\<CR>", 'xt')
+  call assert_equal('"popup Xmenu.A1 A2 A3 A4', @:)
+
+  " Test for expanding menus after enable/disable
+  call feedkeys(":menu enable Xmenu.\<C-A>\<C-B>\"\<CR>", 'xt')
+  call assert_equal('"menu enable Xmenu.A1. A2. A3. A4.', @:)
+  call feedkeys(":menu disable Xmenu.\<C-A>\<C-B>\"\<CR>", 'xt')
+  call assert_equal('"menu disable Xmenu.A1. A2. A3. A4.', @:)
+
+  " Test for expanding non-existing menu path
+  call feedkeys(":menu xyz.\<C-A>\<C-B>\"\<CR>", 'xt')
+  call assert_equal('"menu xyz.', @:)
+  call feedkeys(":menu Xmenu.A1.A1B1.xyz.\<C-A>\<C-B>\"\<CR>", 'xt')
+  call assert_equal('"menu Xmenu.A1.A1B1.xyz.', @:)
+
   set wildmenu&
   unmenu Xmenu
+
+  " Test for expanding popup menus with some hidden items
+  menu Xmenu.foo.A1 a1
+  menu Xmenu.]bar bar
+  menu Xmenu.]baz.B1 b1
+  menu Xmenu.-sep- :
+  call feedkeys(":popup Xmenu.\<C-A>\<C-B>\"\<CR>", 'xt')
+  call assert_equal('"popup Xmenu.foo', @:)
+  unmenu Xmenu
+
+endfunc
+
+" Test for the menu_info() function
+func Test_menu_info()
+  " Define menus with various attributes
+  10nnoremenu 10.10 T&est.F&oo  :echo 'foo'<CR>
+  10nmenu <silent> 10.20 T&est.B&ar<Tab>:bar  :echo 'bar'<CR>
+  10nmenu <script> 10.30.5 T&est.Ba&z.Qu&x  :echo 'qux'<CR>
+
+  let d = #{name: "B&ar\t:bar", display: 'Bar', modes: 'n', shortcut: 'a',
+        \ accel: ':bar', priority: 20, enabled: v:true, silent: v:true,
+        \ noremenu: v:false, script: v:false, rhs: ":echo 'bar'<CR>"}
+  call assert_equal(d, menu_info('Test.Bar'))
+
+  let d = #{name: 'Ba&z', display: 'Baz', modes: 'n', shortcut: 'z',
+        \ priority: 30, submenus: ['Qux']}
+  call assert_equal(d, menu_info('Test.Baz'))
+
+  let d = #{name: 'T&est', display: 'Test', modes: 'n', shortcut: 'e',
+        \ priority: 10, submenus: ['Foo', 'Bar', 'Baz']}
+  call assert_equal(d, menu_info('Test'))
+  call assert_equal({}, menu_info('Test.Dummy'))
+  call assert_equal({}, menu_info('Dummy'))
+
+  nmenu disable Test.Foo
+  call assert_equal(v:false, menu_info('Test.Foo').enabled)
+  nmenu enable Test.Foo
+  call assert_equal(v:true, menu_info('Test.Foo').enabled)
+
+  call assert_equal(menu_info('Test.Foo'), menu_info('Test.Foo', ''))
+  nmenu Test.abc  <Nop>
+  call assert_equal('<Nop>', menu_info('Test.abc').rhs)
+  call assert_fails('call menu_info([])', 'E730:')
+  nunmenu Test
+
+  " Test for defining menus in different modes
+  menu Test.menu :menu<CR>
+  menu! Test.menu! :menu!<CR>
+  amenu Test.amenu  :amenu<CR>
+  nmenu Test.nmenu  :nmenu<CR>
+  omenu Test.omenu  :omenu<CR>
+  vmenu Test.vmenu  :vmenu<CR>
+  xmenu Test.xmenu  :xmenu<CR>
+  smenu Test.smenu  :smenu<CR>
+  imenu <silent> <script> Test.imenu  :imenu<CR>
+  cmenu Test.cmenu  :cmenu<CR>
+  tlmenu Test.tlmenu  :tlmenu<CR>
+  tmenu Test.nmenu Normal mode menu
+  tmenu Test.omenu Op-pending mode menu
+  noremenu Test.noremenu :noremenu<CR>
+  noremenu! Test.noremenu! :noremenu!<CR>
+  anoremenu Test.anoremenu  :anoremenu<CR>
+  nnoremenu Test.nnoremenu  :nnoremenu<CR>
+  onoremenu Test.onoremenu  :onoremenu<CR>
+  vnoremenu Test.vnoremenu  :vnoremenu<CR>
+  xnoremenu Test.xnoremenu  :xnoremenu<CR>
+  snoremenu Test.snoremenu  :snoremenu<CR>
+  inoremenu <silent> Test.inoremenu  :inoremenu<CR>
+  cnoremenu Test.cnoremenu  :cnoremenu<CR>
+  tlnoremenu Test.tlnoremenu  :tlnoremenu<CR>
+  call assert_equal(#{name: 'menu', priority: 500, shortcut: '',
+        \ display: 'menu', modes: ' ', enabled: v:true, silent: v:false,
+        \ rhs: ":menu<CR>", noremenu: v:false, script: v:false},
+        \ menu_info('Test.menu'))
+  call assert_equal(#{name: 'menu!', priority: 500, shortcut: '',
+        \ display: 'menu!', modes: '!', enabled: v:true, silent: v:false,
+        \ rhs: ":menu!<CR>", noremenu: v:false, script: v:false},
+        \ menu_info('Test.menu!', '!'))
+  call assert_equal(#{name: 'amenu', priority: 500, shortcut: '',
+        \ display: 'amenu', modes: 'a', enabled: v:true, silent: v:false,
+        \ rhs: ":amenu<CR>", noremenu: v:false, script: v:false},
+        \ menu_info('Test.amenu', 'a'))
+  call assert_equal(#{name: 'nmenu', priority: 500, shortcut: '',
+        \ display: 'nmenu', modes: 'n', enabled: v:true, silent: v:false,
+        \ rhs: ':nmenu<CR>', noremenu: v:false, script: v:false},
+        \ menu_info('Test.nmenu', 'n'))
+  call assert_equal(#{name: 'omenu', priority: 500, shortcut: '',
+        \ display: 'omenu', modes: 'o', enabled: v:true, silent: v:false,
+        \ rhs: ':omenu<CR>', noremenu: v:false, script: v:false},
+        \ menu_info('Test.omenu', 'o'))
+  call assert_equal(#{name: 'vmenu', priority: 500, shortcut: '',
+        \ display: 'vmenu', modes: 'v', enabled: v:true, silent: v:false,
+        \ rhs: ':vmenu<CR>', noremenu: v:false, script: v:false},
+        \ menu_info('Test.vmenu', 'v'))
+  call assert_equal(#{name: 'xmenu', priority: 500, shortcut: '',
+        \ display: 'xmenu', modes: 'x', enabled: v:true, silent: v:false,
+        \ rhs: ':xmenu<CR>', noremenu: v:false, script: v:false},
+        \ menu_info('Test.xmenu', 'x'))
+  call assert_equal(#{name: 'smenu', priority: 500, shortcut: '',
+        \ display: 'smenu', modes: 's', enabled: v:true, silent: v:false,
+        \ rhs: ':smenu<CR>', noremenu: v:false, script: v:false},
+        \ menu_info('Test.smenu', 's'))
+  call assert_equal(#{name: 'imenu', priority: 500, shortcut: '',
+        \ display: 'imenu', modes: 'i', enabled: v:true, silent: v:true,
+        \ rhs: ':imenu<CR>', noremenu: v:false, script: v:true},
+        \ menu_info('Test.imenu', 'i'))
+  call assert_equal(#{ name: 'cmenu', priority: 500, shortcut: '',
+        \ display: 'cmenu', modes: 'c', enabled: v:true, silent: v:false,
+        \ rhs: ':cmenu<CR>', noremenu: v:false, script: v:false},
+        \ menu_info('Test.cmenu', 'c'))
+  call assert_equal(#{name: 'tlmenu', priority: 500, shortcut: '',
+        \ display: 'tlmenu', modes: 'tl', enabled: v:true, silent: v:false,
+        \ rhs: ':tlmenu<CR>', noremenu: v:false, script: v:false},
+        \ menu_info('Test.tlmenu', 'tl'))
+  call assert_equal(#{name: 'noremenu', priority: 500, shortcut: '',
+        \ display: 'noremenu', modes: ' ', enabled: v:true, silent: v:false,
+        \ rhs: ":noremenu<CR>", noremenu: v:true, script: v:false},
+        \ menu_info('Test.noremenu'))
+  call assert_equal(#{name: 'noremenu!', priority: 500, shortcut: '',
+        \ display: 'noremenu!', modes: '!', enabled: v:true, silent: v:false,
+        \ rhs: ":noremenu!<CR>", noremenu: v:true, script: v:false},
+        \ menu_info('Test.noremenu!', '!'))
+  call assert_equal(#{name: 'anoremenu', priority: 500, shortcut: '',
+        \ display: 'anoremenu', modes: 'a', enabled: v:true, silent: v:false,
+        \ rhs: ":anoremenu<CR>", noremenu: v:true, script: v:false},
+        \ menu_info('Test.anoremenu', 'a'))
+  call assert_equal(#{name: 'nnoremenu', priority: 500, shortcut: '',
+        \ display: 'nnoremenu', modes: 'n', enabled: v:true, silent: v:false,
+        \ rhs: ':nnoremenu<CR>', noremenu: v:true, script: v:false},
+        \ menu_info('Test.nnoremenu', 'n'))
+  call assert_equal(#{name: 'onoremenu', priority: 500, shortcut: '',
+        \ display: 'onoremenu', modes: 'o', enabled: v:true, silent: v:false,
+        \ rhs: ':onoremenu<CR>', noremenu: v:true, script: v:false},
+        \ menu_info('Test.onoremenu', 'o'))
+  call assert_equal(#{name: 'vnoremenu', priority: 500, shortcut: '',
+        \ display: 'vnoremenu', modes: 'v', enabled: v:true, silent: v:false,
+        \ rhs: ':vnoremenu<CR>', noremenu: v:true, script: v:false},
+        \ menu_info('Test.vnoremenu', 'v'))
+  call assert_equal(#{name: 'xnoremenu', priority: 500, shortcut: '',
+        \ display: 'xnoremenu', modes: 'x', enabled: v:true, silent: v:false,
+        \ rhs: ':xnoremenu<CR>', noremenu: v:true, script: v:false},
+        \ menu_info('Test.xnoremenu', 'x'))
+  call assert_equal(#{name: 'snoremenu', priority: 500, shortcut: '',
+        \ display: 'snoremenu', modes: 's', enabled: v:true, silent: v:false,
+        \ rhs: ':snoremenu<CR>', noremenu: v:true, script: v:false},
+        \ menu_info('Test.snoremenu', 's'))
+  call assert_equal(#{name: 'inoremenu', priority: 500, shortcut: '',
+        \ display: 'inoremenu', modes: 'i', enabled: v:true, silent: v:true,
+        \ rhs: ':inoremenu<CR>', noremenu: v:true, script: v:false},
+        \ menu_info('Test.inoremenu', 'i'))
+  call assert_equal(#{ name: 'cnoremenu', priority: 500, shortcut: '',
+        \ display: 'cnoremenu', modes: 'c', enabled: v:true, silent: v:false,
+        \ rhs: ':cnoremenu<CR>', noremenu: v:true, script: v:false},
+        \ menu_info('Test.cnoremenu', 'c'))
+  call assert_equal(#{name: 'tlnoremenu', priority: 500, shortcut: '',
+        \ display: 'tlnoremenu', modes: 'tl', enabled: v:true, silent: v:false,
+        \ rhs: ':tlnoremenu<CR>', noremenu: v:true, script: v:false},
+        \ menu_info('Test.tlnoremenu', 'tl'))
+  aunmenu Test
+  tlunmenu Test
+  call assert_equal({}, menu_info('Test'))
+  call assert_equal({}, menu_info('Test', '!'))
+  call assert_equal({}, menu_info('Test', 'a'))
+  call assert_equal({}, menu_info('Test', 'n'))
+  call assert_equal({}, menu_info('Test', 'o'))
+  call assert_equal({}, menu_info('Test', 'v'))
+  call assert_equal({}, menu_info('Test', 'x'))
+  call assert_equal({}, menu_info('Test', 's'))
+  call assert_equal({}, menu_info('Test', 'i'))
+  call assert_equal({}, menu_info('Test', 'c'))
+  call assert_equal({}, menu_info('Test', 't'))
+  call assert_equal({}, menu_info('Test', 'tl'))
+
+  amenu Test.amenu  :amenu<CR>
+  call assert_equal(':amenu<CR>', menu_info('Test.amenu', '').rhs)
+  call assert_equal('<C-\><C-O>:amenu<CR>', menu_info('Test.amenu', '!').rhs)
+  call assert_equal(':amenu<CR>', menu_info('Test.amenu', 'n').rhs)
+  call assert_equal('<C-C>:amenu<CR><C-\><C-G>',
+        \ menu_info('Test.amenu', 'o').rhs)
+  call assert_equal('<C-C>:amenu<CR><C-\><C-G>',
+        \ menu_info('Test.amenu', 'v').rhs)
+  call assert_equal('<C-C>:amenu<CR><C-\><C-G>',
+        \ menu_info('Test.amenu', 'x').rhs)
+  call assert_equal('<C-C>:amenu<CR><C-\><C-G>',
+        \ menu_info('Test.amenu', 's').rhs)
+  call assert_equal('<C-\><C-O>:amenu<CR>', menu_info('Test.amenu', 'i').rhs)
+  call assert_equal('<C-C>:amenu<CR><C-\><C-G>',
+        \ menu_info('Test.amenu', 'c').rhs)
+  aunmenu Test.amenu
+
+  " Test for hidden menus
+  menu ]Test.menu :menu<CR>
+  call assert_equal(#{name: ']Test', display: ']Test', priority: 500,
+        \ shortcut: '', modes: ' ', submenus: ['menu']},
+        \ menu_info(']Test'))
+  unmenu ]Test
+
+  " Test for getting all the top-level menu names
+  call assert_notequal(menu_info('').submenus, [])
+endfunc
+
+" Test for <special> keyword in a menu with 'cpo' containing '<'
+func Test_menu_special()
+  throw 'Skipped: Nvim does not support cpoptions flag "<"'
+  new
+  set cpo+=<
+  nmenu Test.Sign  am<Tab>n<Esc>
+  call feedkeys(":emenu n Test.Sign\<CR>", 'x')
+  call assert_equal("m<Tab>n<Esc>", getline(1))
+  nunmenu Test.Sign
+  nmenu <special> Test.Sign  am<Tab>n<Esc>
+  call setline(1, '')
+  call feedkeys(":emenu n Test.Sign\<CR>", 'x')
+  call assert_equal("m\tn", getline(1))
+  set cpo-=<
+  close!
+  nunmenu Test.Sign
+endfunc
+
+" Test for "icon=filname" in a toolbar
+func Test_menu_icon()
+  CheckFeature toolbar
+  nmenu icon=myicon.xpm Toolbar.Foo  :echo "Foo"<CR>
+  call assert_equal('myicon.xpm', "Toolbar.Foo"->menu_info().icon)
+  nunmenu Toolbar.Foo
+
+  " Test for using the builtin icon
+  amenu ToolBar.BuiltIn22 :echo "BuiltIn22"<CR>
+  call assert_equal(#{name: 'BuiltIn22', display: 'BuiltIn22',
+        \ enabled: v:true, shortcut: '', modes: 'a', script: v:false,
+        \ iconidx: 22, priority: 500, silent: v:false,
+        \ rhs: ':echo "BuiltIn22"<CR>', noremenu: v:false},
+        \ menu_info("ToolBar.BuiltIn22"))
+  aunmenu ToolBar.BuiltIn22
+endfunc
+
+" Test for ":emenu" command in different modes
+func Test_emenu_cmd()
+  new
+  xmenu Test.foo rx
+  call setline(1, ['aaaa', 'bbbb'])
+  normal ggVj
+  %emenu Test.foo
+  call assert_equal(['xxxx', 'xxxx'], getline(1, 2))
+  call setline(1, ['aaaa', 'bbbb'])
+  exe "normal ggVj\<Esc>"
+  %emenu Test.foo
+  call assert_equal(['xxxx', 'xxxx'], getline(1, 2))
+  call setline(1, ['aaaa', 'bbbb'])
+  exe "normal ggV\<Esc>"
+  2emenu Test.foo
+  call assert_equal(['aaaa', 'xxxx'], getline(1, 2))
+  xunmenu Test.foo
+  close!
+endfunc
+
+" Test for PopUp menus
+func Test_popup_menu()
+  20menu PopUp.foo :echo 'foo'<CR>
+  20menu PopUp.bar :echo 'bar'<CR>
+  call assert_equal(#{name: 'PopUp', display: 'PopUp', priority: 20,
+        \ shortcut: '', modes: ' ', submenus: ['foo', 'bar']},
+        \ menu_info('PopUp'))
+  menu disable PopUp.bar
+  call assert_equal(v:true, "PopUp.foo"->menu_info().enabled)
+  call assert_equal(v:false, "PopUp.bar"->menu_info().enabled)
+  menu enable PopUp.bar
+  call assert_equal(v:true, "PopUp.bar"->menu_info().enabled)
+  unmenu PopUp
+endfunc
+
+" Test for listing the menus using the :menu command
+func Test_show_menus()
+  " In the GUI, tear-off menu items are present in the output below
+  " So skip this test
+  CheckNotGui
+  aunmenu *
+  call assert_equal(['--- Menus ---'], split(execute('menu'), "\n"))
+  nmenu <script> 200.10 Test.nmenu1 :nmenu1<CR>
+  nmenu 200.20 Test.nmenu2 :nmenu2<CR>
+  nnoremenu 200.30 Test.nmenu3 :nmenu3<CR>
+  nmenu 200.40 Test.nmenu4 :nmenu4<CR>
+  nmenu 200.50 disable Test.nmenu4
+  let exp =<< trim [TEXT]
+  --- Menus ---
+  200 Test
+    10 nmenu1
+        n&   :nmenu1<CR>
+    20 nmenu2
+        n    :nmenu2<CR>
+    30 nmenu3
+        n*   :nmenu3<CR>
+    40 nmenu4
+        n  - :nmenu4<CR>
+  [TEXT]
+  call assert_equal(exp, split(execute('nmenu'), "\n"))
+  nunmenu Test
+endfunc
+
+" Test for menu tips
+func Test_tmenu()
+  tunmenu *
+  call assert_equal(['--- Menus ---'], split(execute('tmenu'), "\n"))
+  tmenu Test.nmenu1 nmenu1
+  tmenu Test.nmenu2.sub1 nmenu2.sub1
+  let exp =<< trim [TEXT]
+  --- Menus ---
+  500 Test
+    500 nmenu1
+        t  - nmenu1
+    500 nmenu2
+      500 sub1
+          t  - nmenu2.sub1
+  [TEXT]
+  call assert_equal(exp, split(execute('tmenu'), "\n"))
+  tunmenu Test
 endfunc
 
 " vim: shiftwidth=2 sts=2 expandtab
diff --git a/src/nvim/testdir/test_popup.vim b/src/nvim/testdir/test_popup.vim
index 0486ed83ad..3d1e3fa6db 100644
--- a/src/nvim/testdir/test_popup.vim
+++ b/src/nvim/testdir/test_popup.vim
@@ -864,15 +864,21 @@ func Test_popup_position()
 endfunc
 
 func Test_popup_command()
-  if !CanRunVimInTerminal() || !has('menu')
-    return
-  endif
+  CheckScreendump
+  CheckFeature menu
 
-  call writefile([
-	\ 'one two three four five',
-	\ 'and one two Xthree four five',
-	\ 'one more two three four five',
-	\ ], 'Xtest')
+  menu Test.Foo Foo
+  call assert_fails('popup Test.Foo', 'E336:')
+  call assert_fails('popup Test.Foo.X', 'E327:')
+  call assert_fails('popup Foo', 'E337:')
+  unmenu Test.Foo
+
+  let lines =<< trim END
+	one two three four five
+	and one two Xthree four five
+	one more two three four five
+  END
+  call writefile(lines, 'Xtest')
   let buf = RunVimInTerminal('Xtest', {})
   call term_sendkeys(buf, ":source $VIMRUNTIME/menu.vim\<CR>")
   call term_sendkeys(buf, "/X\<CR>:popup PopUp\<CR>")