1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
// Copyright 2015 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 "ui/views/controls/menu/menu_runner.h"
#include "base/memory/scoped_ptr.h"
#include "ui/base/ui_base_types.h"
#include "ui/views/controls/menu/menu_delegate.h"
#include "ui/views/controls/menu/menu_item_view.h"
#include "ui/views/controls/menu/menu_types.h"
#include "ui/views/test/views_test_base.h"
#include "ui/views/widget/widget.h"
namespace views {
namespace test {
// Implementation of MenuDelegate that only reports the values of calls to
// OnMenuClosed.
class TestMenuDelegate : public MenuDelegate {
public:
TestMenuDelegate();
~TestMenuDelegate() override;
int on_menu_closed_called() { return on_menu_closed_called_; }
MenuItemView* on_menu_closed_menu() { return on_menu_closed_menu_; }
MenuRunner::RunResult on_menu_closed_run_result() {
return on_menu_closed_run_result_;
}
// MenuDelegate:
void OnMenuClosed(MenuItemView* menu, MenuRunner::RunResult result) override;
private:
// The number of times OnMenuClosed was called.
int on_menu_closed_called_;
// The values of the last call to OnMenuClosed.
MenuItemView* on_menu_closed_menu_;
MenuRunner::RunResult on_menu_closed_run_result_;
DISALLOW_COPY_AND_ASSIGN(TestMenuDelegate);
};
TestMenuDelegate::TestMenuDelegate()
: on_menu_closed_called_(0),
on_menu_closed_menu_(nullptr),
on_menu_closed_run_result_(MenuRunner::MENU_DELETED) {}
TestMenuDelegate::~TestMenuDelegate() {}
void TestMenuDelegate::OnMenuClosed(MenuItemView* menu,
MenuRunner::RunResult result) {
on_menu_closed_called_++;
on_menu_closed_menu_ = menu;
on_menu_closed_run_result_ = result;
}
class MenuRunnerTest : public ViewsTestBase {
public:
MenuRunnerTest();
~MenuRunnerTest() override;
// Initializes a MenuRunner with |run_types|. It takes ownership of
// |menu_item_view_|.
void InitMenuRunner(int32 run_types);
MenuItemView* menu_item_view() { return menu_item_view_; }
TestMenuDelegate* menu_delegate() { return menu_delegate_.get(); }
MenuRunner* menu_runner() { return menu_runner_.get(); }
Widget* owner() { return owner_.get(); }
// ViewsTestBase:
void SetUp() override;
void TearDown() override;
private:
// Owned by MenuRunner.
MenuItemView* menu_item_view_;
scoped_ptr<TestMenuDelegate> menu_delegate_;
scoped_ptr<MenuRunner> menu_runner_;
scoped_ptr<Widget> owner_;
DISALLOW_COPY_AND_ASSIGN(MenuRunnerTest);
};
MenuRunnerTest::MenuRunnerTest() {}
MenuRunnerTest::~MenuRunnerTest() {}
void MenuRunnerTest::InitMenuRunner(int32 run_types) {
menu_runner_.reset(new MenuRunner(menu_item_view_, run_types));
}
void MenuRunnerTest::SetUp() {
ViewsTestBase::SetUp();
menu_delegate_.reset(new TestMenuDelegate);
menu_item_view_ = new MenuItemView(menu_delegate_.get());
owner_.reset(new Widget);
Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
owner_->Init(params);
owner_->Show();
}
void MenuRunnerTest::TearDown() {
owner_->CloseNow();
ViewsTestBase::TearDown();
}
// Tests that MenuRunner is still running after the call to RunMenuAt when
// initialized with MenuRunner::ASYNC, and that MenuDelegate is notified upon
// the closing of the menu.
TEST_F(MenuRunnerTest, AsynchronousRun) {
InitMenuRunner(MenuRunner::ASYNC);
MenuRunner* runner = menu_runner();
MenuRunner::RunResult result = runner->RunMenuAt(
owner(), nullptr, gfx::Rect(), MENU_ANCHOR_TOPLEFT, ui::MENU_SOURCE_NONE);
EXPECT_EQ(MenuRunner::NORMAL_EXIT, result);
EXPECT_TRUE(runner->IsRunning());
runner->Cancel();
EXPECT_FALSE(runner->IsRunning());
TestMenuDelegate* delegate = menu_delegate();
EXPECT_EQ(1, delegate->on_menu_closed_called());
EXPECT_EQ(nullptr, delegate->on_menu_closed_menu());
EXPECT_EQ(MenuRunner::NORMAL_EXIT, delegate->on_menu_closed_run_result());
}
} // namespace test
} // namespace views
|
