Add MenuItemView API to add and remove items at a particular index.

chrome/test/menu_item_view_test.cc

Index: chrome/test/menu_item_view_test.cc
diff --git a/chrome/test/menu_item_view_test.cc b/chrome/test/menu_item_view_test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c935eed7d8c4779051c440061ef9e3ec42f0ff88
--- /dev/null
+++ b/chrome/test/menu_item_view_test.cc
@@ -0,0 +1,593 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/message_loop.h"
+#include "base/task.h"
+#include "chrome/browser/automation/ui_controls.h"

[Paweł Hajdan Jr., 2011/05/06 08:11:03]

Are those chrome includes the only reason why this file has been put in
chrome/test? It seems generally bad to have the code under test in one place and
the test somewhere else. If you really need something from there, we should
rather move that lower in the file hierarchy instead of moving this test higher.

+#include "chrome/test/interactive_ui/view_event_test_base.h"
+#include "chrome/test/testing_profile.h"

[Paweł Hajdan Jr., 2011/05/06 08:11:03]

Is this #include used?

+#include "chrome/test/ui_test_utils.h"

[Paweł Hajdan Jr., 2011/05/06 08:11:03]

Is this #include used?

+#include "views/controls/button/menu_button.h"
+#include "views/controls/menu/menu_controller.h"
+#include "views/controls/menu/menu_item_view.h"
+#include "views/controls/menu/submenu_view.h"
+#include "views/controls/menu/view_menu_delegate.h"
+#include "views/views_delegate.h"
+#include "views/window/window.h"
+
+// This constant is used to delay certain testing steps.  It is
+// normally 0 but can be set higher for local development and
+// debugging so the behavior can be observed.
+static const int kStepMilliseconds = 0;

[Paweł Hajdan Jr., 2011/05/06 08:11:03]

I don't think it's a good idea to check that in (while of course it may help
with local debugging/development). The PostDelayedTasks make the code more
complicated and less deterministic (another task _might_ execute), which is
generally bad.

+
+// This is a convenience base class for all tests to provide some
+// common functionality.  It sets up a MenuButton and a MenuItemView
+// and clicks the MenuButton.
+//
+// Subclasses should implement:
+//  BuildMenu()            populate the menu
+//  DoTestOnMessageLoop()  initiate the test
+//  Step1()                called when the menu is posted
+//
+// Subclasses can call:
+//  Click()       to post a mouse click on a View
+//
+// Although it should be possible to post a menu multiple times,
+// MenuItemView prevents repeated activation of of a menu by

[sky, 2011/05/06 16:17:00]

'of of' -> of

[rhashimoto, 2011/05/11 00:44:53]

Done.

+// clicks too close in time.
+class MenuItemViewTestBase : public ViewEventTestBase,
+                             public views::ViewMenuDelegate,
+                             public views::MenuDelegate {
+ public:
+  MenuItemViewTestBase() : ViewEventTestBase(),
+                           button_(NULL),
+                           menu_(NULL) {
+  }
+
+  virtual ~MenuItemViewTestBase() {
+  }
+
+  // ViewEventTestBase implementation.
+
+  virtual void SetUp() OVERRIDE {
+    button_ = new views::MenuButton(NULL, L"Menu Test", this, true);
+
+    menu_ = new views::MenuItemView(this);
+    BuildMenu(menu_);
+
+    ViewEventTestBase::SetUp();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    delete menu_;

[Paweł Hajdan Jr., 2011/05/06 08:11:03]

Why not a scoped_ptr then? Non-scoped memory management like this is the #1
source of leaks in tests.

[rhashimoto, 2011/05/11 00:44:53]

Done.

+    menu_ = NULL;
+    ViewEventTestBase::TearDown();
+  }
+
+  virtual views::View* CreateContentsView() OVERRIDE {
+    return button_;
+  }
+
+  virtual gfx::Size GetPreferredSize() OVERRIDE {
+    return button_->GetPreferredSize();
+  }
+
+  // views::ViewMenuDelegate implementation.
+  virtual void RunMenu(views::View* source, const gfx::Point& pt) OVERRIDE {
+    gfx::Point screen_location;
+    views::View::ConvertPointToScreen(source, &screen_location);
+    gfx::Rect bounds(screen_location, source->size());
+    menu_->RunMenuAt(
+        source->GetWindow()->GetNativeWindow(),
+        button_,
+        bounds,
+        views::MenuItemView::TOPLEFT,
+        true);
+ }
+
+ protected:
+  // Generate a mouse click on the specified view and post a new task.
+  virtual void Click(views::View* view,Task* next) {

[sky, 2011/05/06 16:17:00]

'view,task' -> 'view, task'

[rhashimoto, 2011/05/11 00:44:53]

Done.

+    ui_controls::MoveMouseToCenterAndPress(
+        view,
+        ui_controls::LEFT,
+        ui_controls::DOWN | ui_controls::UP,
+        next);
+  }
+
+  virtual void BuildMenu(views::MenuItemView* menu) {
+  }
+
+  views::MenuButton* button_;
+  views::MenuItemView* menu_;
+};
+
+// Simple test for clicking a menu item.  This template class clicks on an
+// item and checks that the returned id matches.  The index of the item
+// is the template argument.
+template<int INDEX>
+class MenuItemViewTestBasic : public MenuItemViewTestBase {
+ public:
+  MenuItemViewTestBasic() : last_command_(0) {
+  }
+
+  virtual ~MenuItemViewTestBasic() {
+  }
+
+  // views::MenuDelegate implementation
+  virtual void ExecuteCommand(int id) OVERRIDE {
+    last_command_ = id;
+  }
+
+  // MenuItemViewTestBase implementation
+  virtual void BuildMenu(views::MenuItemView* menu) OVERRIDE {
+    menu->AppendMenuItemWithLabel(1, L"item 1");
+    menu->AppendMenuItemWithLabel(2, L"item 2");
+    menu->AppendSeparator();
+    menu->AppendMenuItemWithLabel(3, L"item 3");
+  }
+
+  // ViewEventTestBase implementation
+  virtual void DoTestOnMessageLoop() OVERRIDE {
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestBasic::Step0),
+        kStepMilliseconds);
+  }
+
+  // Open the menu.
+  void Step0() {
+    Click(button_, CreateEventTask(this, &MenuItemViewTestBasic::Step1));
+  }
+
+  // Click on item INDEX.
+  void Step1() {
+    ASSERT_TRUE(menu_);
+
+    views::SubmenuView* submenu = menu_->GetSubmenu();
+    ASSERT_TRUE(submenu);
+    ASSERT_TRUE(submenu->IsShowing());
+    ASSERT_EQ(3, submenu->GetMenuItemCount());
+
+    // click an item and pass control to the next step
+    views::MenuItemView* item = submenu->GetMenuItemAt(INDEX);
+    ASSERT_TRUE(item);
+    Click(item, CreateEventTask(this, &MenuItemViewTestBasic::Step2));
+  }
+
+  // Check the clicked item and complete the test.
+  void Step2() {
+    ASSERT_FALSE(menu_->GetSubmenu()->IsShowing());
+    ASSERT_EQ(INDEX + 1,last_command_);
+    Done();
+  }
+
+ private:
+  int last_command_;
+};
+
+// Click each item of a 3-item menu (with separator).
+typedef MenuItemViewTestBasic<0> MenuItemViewTestBasic0;
+typedef MenuItemViewTestBasic<1> MenuItemViewTestBasic1;
+typedef MenuItemViewTestBasic<2> MenuItemViewTestBasic2;
+VIEW_TEST(MenuItemViewTestBasic0, FLAKY_SelectItem0)
+VIEW_TEST(MenuItemViewTestBasic1, FLAKY_SelectItem1)
+VIEW_TEST(MenuItemViewTestBasic2, FLAKY_SelectItem2)
+
+// Test class for inserting a menu item while the menu is open.
+template<int INSERT_INDEX, int SELECT_INDEX>
+class MenuItemViewTestInsert : public MenuItemViewTestBase {
+ public:
+  MenuItemViewTestInsert() : last_command_(0),
+                             inserted_item_(NULL) {
+  }
+
+  virtual ~MenuItemViewTestInsert() {
+  }
+
+  // views::MenuDelegate implementation
+  virtual void ExecuteCommand(int id) OVERRIDE {
+    last_command_ = id;
+  }
+
+  // MenuItemViewTestBase implementation
+  virtual void BuildMenu(views::MenuItemView* menu) OVERRIDE {
+    menu->AppendMenuItemWithLabel(1, L"item 1");
+    menu->AppendMenuItemWithLabel(2, L"item 2");
+  }
+
+  // ViewEventTestBase implementation
+  virtual void DoTestOnMessageLoop() OVERRIDE {
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestInsert::Step0),
+        kStepMilliseconds);
+  }
+
+  // Post the menu.
+  void Step0() {
+    Click(button_, CreateEventTask(this, &MenuItemViewTestInsert::Step1));
+  }
+
+  // Add optional delay for debugging.
+  void Step1() {
+    ASSERT_TRUE(menu_);
+
+    views::SubmenuView* submenu = menu_->GetSubmenu();
+    ASSERT_TRUE(submenu);
+    ASSERT_TRUE(submenu->IsShowing());
+    ASSERT_EQ(2, submenu->GetMenuItemCount());
+
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestInsert::Step2),
+        kStepMilliseconds);
+  }
+
+  // Insert item at INSERT_INDEX.
+  void Step2() {
+    inserted_item_ = menu_->AddMenuItemAt(INSERT_INDEX,
+                                          1000,
+                                          L"inserted item",
+                                          SkBitmap(),
+                                          views::MenuItemView::NORMAL);
+    ASSERT_TRUE(inserted_item_);
+    menu_->ChildrenChanged();
+
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestInsert::Step3),
+        kStepMilliseconds);
+  }
+
+  // Click item SELECT_INDEX.
+  void Step3() {
+    ASSERT_TRUE(menu_);
+
+    views::SubmenuView* submenu = menu_->GetSubmenu();
+    ASSERT_TRUE(submenu);
+    ASSERT_TRUE(submenu->IsShowing());
+    ASSERT_EQ(3, submenu->GetMenuItemCount());
+
+    // click an item and pass control to the next step
+    views::MenuItemView* item = submenu->GetMenuItemAt(SELECT_INDEX);
+    ASSERT_TRUE(item);
+    Click(item, CreateEventTask(this, &MenuItemViewTestInsert::Step4));
+  }
+
+  // Check clicked item and complete test.
+  void Step4() {
+    ASSERT_FALSE(menu_->GetSubmenu()->IsShowing());
+
+    if (SELECT_INDEX == INSERT_INDEX)
+      ASSERT_EQ(1000, last_command_);
+    else if (SELECT_INDEX < INSERT_INDEX)
+      ASSERT_EQ(SELECT_INDEX + 1, last_command_);
+    else
+      ASSERT_EQ(SELECT_INDEX, last_command_);
+
+    Done();
+  }
+
+ private:
+  int last_command_;
+  views::MenuItemView* inserted_item_;
+};
+
+// MenuItemViewTestInsertXY inserts an item at index X and selects the
+// item at index Y (after the insertion).  The tests here cover
+// inserting at the beginning, middle, and end, crossbarred with
+// selecting the first and last item.
+typedef MenuItemViewTestInsert<0,0> MenuItemViewTestInsert00;
+typedef MenuItemViewTestInsert<0,2> MenuItemViewTestInsert02;
+typedef MenuItemViewTestInsert<1,0> MenuItemViewTestInsert10;
+typedef MenuItemViewTestInsert<1,2> MenuItemViewTestInsert12;
+typedef MenuItemViewTestInsert<2,0> MenuItemViewTestInsert20;
+typedef MenuItemViewTestInsert<2,2> MenuItemViewTestInsert22;
+VIEW_TEST(MenuItemViewTestInsert00, FLAKY_InsertItem00)
+VIEW_TEST(MenuItemViewTestInsert02, FLAKY_InsertItem02)
+VIEW_TEST(MenuItemViewTestInsert10, FLAKY_InsertItem10)
+VIEW_TEST(MenuItemViewTestInsert12, FLAKY_InsertItem12)
+VIEW_TEST(MenuItemViewTestInsert20, FLAKY_InsertItem20)
+VIEW_TEST(MenuItemViewTestInsert22, FLAKY_InsertItem22)
+
+// Test class for inserting a menu item while a submenu is open.
+template<int INSERT_INDEX>
+class MenuItemViewTestInsertWithSubmenu : public MenuItemViewTestBase {
+ public:
+  MenuItemViewTestInsertWithSubmenu() : last_command_(0),
+                                        submenu_(NULL),
+                                        inserted_item_(NULL) {
+  }
+
+  virtual ~MenuItemViewTestInsertWithSubmenu() {
+  }
+
+  // views::MenuDelegate implementation
+  virtual void ExecuteCommand(int id) OVERRIDE {
+    last_command_ = id;
+  }
+
+  // MenuItemViewTestBase implementation
+  virtual void BuildMenu(views::MenuItemView* menu) OVERRIDE {
+    submenu_ = menu->AppendSubMenu(1, L"My Submenu");
+    submenu_->AppendMenuItemWithLabel(101, L"submenu item 1");
+    submenu_->AppendMenuItemWithLabel(101, L"submenu item 2");
+    menu->AppendMenuItemWithLabel(2, L"item 2");
+  }
+
+  // ViewEventTestBase implementation
+  virtual void DoTestOnMessageLoop() OVERRIDE {
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestInsertWithSubmenu::Step0),
+        kStepMilliseconds);
+  }
+
+  // Post the menu.
+  void Step0() {
+    Click(button_,
+          CreateEventTask(this, &MenuItemViewTestInsertWithSubmenu::Step1));
+  }
+
+  // Add optional delay for debugging.
+  void Step1() {
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestInsertWithSubmenu::Step2),
+        kStepMilliseconds);
+  }
+
+  // Post submenu.
+  void Step2() {
+    Click(submenu_,
+          CreateEventTask(this, &MenuItemViewTestInsertWithSubmenu::Step3));
+  }
+
+  // Add optional delay for debugging.
+  void Step3() {
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestInsertWithSubmenu::Step4),
+        kStepMilliseconds);
+  }
+
+  // Insert item at INSERT_INDEX.
+  void Step4() {
+    inserted_item_ = menu_->AddMenuItemAt(INSERT_INDEX,
+                                          1000,
+                                          L"inserted item",
+                                          SkBitmap(),
+                                          views::MenuItemView::NORMAL);
+    ASSERT_TRUE(inserted_item_);
+    menu_->ChildrenChanged();
+
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestInsertWithSubmenu::Step5),
+        kStepMilliseconds);
+  }
+
+  // Select item to exit menu loop.
+  void Step5() {
+    ASSERT_TRUE(menu_->GetSubmenu()->IsShowing());
+
+    Click(inserted_item_,
+          CreateEventTask(this, &MenuItemViewTestInsertWithSubmenu::Step6));
+  }
+
+  void Step6() {
+    Done();
+  }
+
+  private:
+  int last_command_;
+  views::MenuItemView* submenu_;
+  views::MenuItemView* inserted_item_;
+};
+
+// MenuItemViewTestInsertWithSubmenuX posts a menu and its submenu,
+// then inserts an item in the top-level menu at X.
+typedef MenuItemViewTestInsertWithSubmenu<0> MenuItemViewTestInsertWithSubmenu0;
+typedef MenuItemViewTestInsertWithSubmenu<1> MenuItemViewTestInsertWithSubmenu1;
+VIEW_TEST(MenuItemViewTestInsertWithSubmenu0, FLAKY_InsertItemWithSubmenu0)
+VIEW_TEST(MenuItemViewTestInsertWithSubmenu1, FLAKY_InsertItemWithSubmenu1)
+
+// Test class for removing a menu item while the menu is open.
+template<int REMOVE_INDEX, int SELECT_INDEX>
+class MenuItemViewTestRemove : public MenuItemViewTestBase {
+ public:
+  MenuItemViewTestRemove() : last_command_(0) {
+  }
+
+  virtual ~MenuItemViewTestRemove() {
+  }
+
+  // views::MenuDelegate implementation
+  virtual void ExecuteCommand(int id) OVERRIDE {
+    last_command_ = id;
+  }
+
+  // MenuItemViewTestBase implementation
+  virtual void BuildMenu(views::MenuItemView* menu) OVERRIDE {
+    menu->AppendMenuItemWithLabel(1, L"item 1");
+    menu->AppendMenuItemWithLabel(2, L"item 2");
+    menu->AppendMenuItemWithLabel(3, L"item 3");
+  }
+
+  // ViewEventTestBase implementation
+  virtual void DoTestOnMessageLoop() OVERRIDE {
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestRemove::Step0),
+        kStepMilliseconds);
+  }
+
+  // Post the menu.
+  void Step0() {
+    Click(button_, CreateEventTask(this, &MenuItemViewTestRemove::Step1));
+  }
+
+  // Add optional delay for debugging.
+  void Step1() {
+    ASSERT_TRUE(menu_);
+
+    views::SubmenuView* submenu = menu_->GetSubmenu();
+    ASSERT_TRUE(submenu);
+    ASSERT_TRUE(submenu->IsShowing());
+    ASSERT_EQ(3, submenu->GetMenuItemCount());
+
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestRemove::Step2),
+        kStepMilliseconds);
+  }
+
+  // Remove item at REMOVE_INDEX.
+  void Step2() {
+    menu_->RemoveMenuItemAt(REMOVE_INDEX);
+    menu_->ChildrenChanged();
+
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestRemove::Step3),
+        kStepMilliseconds);
+  }
+
+  // Click item SELECT_INDEX.
+  void Step3() {
+    ASSERT_TRUE(menu_);
+
+    views::SubmenuView* submenu = menu_->GetSubmenu();
+    ASSERT_TRUE(submenu);
+    ASSERT_TRUE(submenu->IsShowing());
+    ASSERT_EQ(2, submenu->GetMenuItemCount());
+
+    // click an item and pass control to the next step
+    views::MenuItemView* item = submenu->GetMenuItemAt(SELECT_INDEX);
+    ASSERT_TRUE(item);
+    Click(item, CreateEventTask(this, &MenuItemViewTestRemove::Step4));
+  }
+
+  // Check clicked item and complete test.
+  void Step4() {
+    ASSERT_FALSE(menu_->GetSubmenu()->IsShowing());
+
+    if (SELECT_INDEX < REMOVE_INDEX)
+      ASSERT_EQ(SELECT_INDEX + 1, last_command_);
+    else
+      ASSERT_EQ(SELECT_INDEX + 2, last_command_);
+
+    Done();
+  }
+
+ private:
+  int last_command_;
+};
+
+typedef MenuItemViewTestRemove<0,0> MenuItemViewTestRemove00;
+typedef MenuItemViewTestRemove<0,1> MenuItemViewTestRemove01;
+typedef MenuItemViewTestRemove<1,0> MenuItemViewTestRemove10;
+typedef MenuItemViewTestRemove<1,1> MenuItemViewTestRemove11;
+typedef MenuItemViewTestRemove<2,0> MenuItemViewTestRemove20;
+typedef MenuItemViewTestRemove<2,1> MenuItemViewTestRemove21;
+VIEW_TEST(MenuItemViewTestRemove00, FLAKY_RemoveItem00)
+VIEW_TEST(MenuItemViewTestRemove01, FLAKY_RemoveItem01)
+VIEW_TEST(MenuItemViewTestRemove10, FLAKY_RemoveItem10)
+VIEW_TEST(MenuItemViewTestRemove11, FLAKY_RemoveItem11)
+VIEW_TEST(MenuItemViewTestRemove20, FLAKY_RemoveItem20)
+VIEW_TEST(MenuItemViewTestRemove21, FLAKY_RemoveItem21)
+
+// Test class for removing a menu item while a submenu is open.
+template<int REMOVE_INDEX>
+class MenuItemViewTestRemoveWithSubmenu : public MenuItemViewTestBase {
+ public:
+  MenuItemViewTestRemoveWithSubmenu() : last_command_(0),
+                                        submenu_(NULL) {
+  }
+
+  virtual ~MenuItemViewTestRemoveWithSubmenu() {
+  }
+
+  // views::MenuDelegate implementation
+  virtual void ExecuteCommand(int id) OVERRIDE {
+    last_command_ = id;
+  }
+
+  // MenuItemViewTestBase implementation
+  virtual void BuildMenu(views::MenuItemView* menu) OVERRIDE {
+    menu->AppendMenuItemWithLabel(1, L"item 1");
+    submenu_ = menu->AppendSubMenu(2, L"My Submenu");
+    submenu_->AppendMenuItemWithLabel(101, L"submenu item 1");
+    submenu_->AppendMenuItemWithLabel(102, L"submenu item 2");
+  }
+
+  // ViewEventTestBase implementation
+  virtual void DoTestOnMessageLoop() OVERRIDE {
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestRemoveWithSubmenu::Step0),
+        kStepMilliseconds);
+  }
+
+  // Post the menu.
+  void Step0() {
+    Click(button_,
+          CreateEventTask(this, &MenuItemViewTestRemoveWithSubmenu::Step1));
+  }
+
+  // Add optional delay for debugging.
+  void Step1() {
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestRemoveWithSubmenu::Step2),
+        kStepMilliseconds);
+  }
+
+  // Post submenu.
+  void Step2() {
+    Click(submenu_,
+          CreateEventTask(this, &MenuItemViewTestRemoveWithSubmenu::Step3));
+  }
+
+  // Add optional delay for debugging.
+  void Step3() {
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestRemoveWithSubmenu::Step4),
+        kStepMilliseconds);
+  }
+
+  // Remove item at REMOVE_INDEX.
+  void Step4() {
+    menu_->RemoveMenuItemAt(REMOVE_INDEX);
+    menu_->ChildrenChanged();
+
+    MessageLoopForUI::current()->PostDelayedTask(
+        FROM_HERE,
+        CreateEventTask(this, &MenuItemViewTestRemoveWithSubmenu::Step5),
+        kStepMilliseconds);
+  }
+
+  // Select item to exit menu loop.
+  void Step5() {
+    ASSERT_TRUE(menu_->GetSubmenu()->IsShowing());
+
+    Click(button_,
+          CreateEventTask(this, &MenuItemViewTestRemoveWithSubmenu::Step6));
+  }
+
+  void Step6() {
+    Done();
+  }
+
+  private:
+  int last_command_;
+  views::MenuItemView* submenu_;
+};
+
+typedef MenuItemViewTestRemoveWithSubmenu<0> MenuItemViewTestRemoveWithSubmenu0;
+typedef MenuItemViewTestRemoveWithSubmenu<1> MenuItemViewTestRemoveWithSubmenu1;
+VIEW_TEST(MenuItemViewTestRemoveWithSubmenu0, FLAKY_RemoveItemWithSubmenu0)
+VIEW_TEST(MenuItemViewTestRemoveWithSubmenu1, FLAKY_RemoveItemWithSubmenu1)