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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ui/base/models/dialog_model.h"
#include <memory>
#include <string>
#include "base/functional/callback.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/bind.h"
#include "testing/gmock/include/gmock/gmock-matchers.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/base/interaction/element_identifier.h"
#include "ui/base/test/test_dialog_model_host.h"
#include "ui/events/event.h"
namespace ui {
class DialogModelButtonTest : public testing::Test {};
TEST_F(DialogModelButtonTest, UsesParamsUniqueId) {
DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kUniqueId);
auto host = std::make_unique<TestDialogModelHost>(
DialogModel::Builder()
.AddOkButton(base::DoNothing(),
DialogModel::Button::Params().SetId(kUniqueId))
.Build());
EXPECT_EQ(kUniqueId, host->GetId(TestDialogModelHost::ButtonId::kOk));
}
TEST_F(DialogModelButtonTest, UsesParamsAccelerators) {
const Accelerator accelerator_1;
const Accelerator accelerator_2(VKEY_Z, EF_SHIFT_DOWN | EF_CONTROL_DOWN);
auto host = std::make_unique<TestDialogModelHost>(
DialogModel::Builder()
.AddOkButton(base::DoNothing(), DialogModel::Button::Params()
.AddAccelerator(accelerator_1)
.AddAccelerator(accelerator_2))
.Build());
EXPECT_THAT(host->GetAccelerators(TestDialogModelHost::ButtonId::kOk),
testing::UnorderedElementsAre(accelerator_1, accelerator_2));
}
TEST_F(DialogModelButtonTest, UsesCallback) {
int callback_count = 0;
std::unique_ptr<KeyEvent> last_event;
auto host = std::make_unique<TestDialogModelHost>(
DialogModel::Builder()
.AddExtraButton(base::BindLambdaForTesting([&](const Event& event) {
++callback_count;
last_event =
std::make_unique<KeyEvent>(*event.AsKeyEvent());
}),
DialogModel::Button::Params().SetLabel(u"button"))
.Build());
KeyEvent first_event(EventType::kKeyPressed, VKEY_RETURN, EF_NONE);
host->TriggerExtraButton(first_event);
EXPECT_EQ(1, callback_count);
EXPECT_EQ(first_event.key_code(), last_event->key_code());
KeyEvent second_event(EventType::kKeyPressed, VKEY_SPACE, EF_NONE);
host->TriggerExtraButton(second_event);
EXPECT_EQ(2, callback_count);
EXPECT_EQ(second_event.key_code(), last_event->key_code());
}
class DialogModelDialogButtonTest : public testing::Test {
public:
void DialogButtonUsesArguments(TestDialogModelHost::ButtonId button_id) {
DialogModel::Builder builder;
// Callback to verify that the first parameter is used.
bool callback_called = false;
base::OnceClosure callback = base::BindRepeating(
[](bool* callback_called) { *callback_called = true; },
&callback_called);
// The presence of an accelerator in |params| will be used to verify that
// |params| are forwarded correctly to the DialogModel::Button constructor.
DialogModel::Button::Params params;
const Accelerator accelerator(VKEY_Z, EF_SHIFT_DOWN | EF_CONTROL_DOWN);
const std::u16string label = u"my cool button";
params.AddAccelerator(accelerator);
params.SetLabel(label);
switch (button_id) {
case TestDialogModelHost::ButtonId::kCancel:
builder.AddCancelButton(std::move(callback), params);
break;
case TestDialogModelHost::ButtonId::kExtra:
// Wrap the callback into a repeating callback that'll only be called
// once so the same verification can be used for the extra button.
builder.AddExtraButton(
base::BindRepeating(
[](base::OnceClosure* callback, const Event& event) {
std::move(*callback).Run();
},
&callback),
params);
break;
case TestDialogModelHost::ButtonId::kOk:
builder.AddOkButton(std::move(callback), params);
break;
}
auto host = std::make_unique<TestDialogModelHost>(builder.Build());
EXPECT_EQ(label, host->GetLabel(button_id))
<< "The label parameter wasn't used.";
EXPECT_THAT(host->GetAccelerators(button_id),
testing::UnorderedElementsAre(accelerator))
<< "The params parameter wasn't used.";
// Trigger the corresponding action.
switch (button_id) {
case TestDialogModelHost::ButtonId::kCancel:
TestDialogModelHost::Cancel(std::move(host));
break;
case TestDialogModelHost::ButtonId::kExtra:
host->TriggerExtraButton(
KeyEvent(EventType::kKeyPressed, VKEY_RETURN, EF_NONE));
break;
case TestDialogModelHost::ButtonId::kOk:
TestDialogModelHost::Accept(std::move(host));
break;
}
EXPECT_TRUE(callback_called) << "The callback parameter wasn't used.";
}
};
TEST_F(DialogModelDialogButtonTest, OkButtonUsesArguments) {
DialogButtonUsesArguments(TestDialogModelHost::ButtonId::kOk);
}
TEST_F(DialogModelDialogButtonTest, ExtraButtonUsesArguments) {
DialogButtonUsesArguments(TestDialogModelHost::ButtonId::kExtra);
}
TEST_F(DialogModelDialogButtonTest, CancelButtonUsesArguments) {
DialogButtonUsesArguments(TestDialogModelHost::ButtonId::kCancel);
}
} // namespace ui
|
