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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/quick_insert/search/quick_insert_date_search.h"
#include <vector>
#include "base/check.h"
#include "base/strings/strcat.h"
#include "base/time/time.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace ash {
namespace {
using ::testing::AllOf;
using ::testing::Combine;
using ::testing::Each;
using ::testing::Field;
using ::testing::IsEmpty;
using ::testing::Not;
using ::testing::Optional;
using ::testing::Pointwise;
using ::testing::Property;
using ::testing::Values;
using ::testing::VariantWith;
base::Time TimeFromDateString(const std::string& time_string) {
base::Time date;
bool result = base::Time::FromString(time_string.c_str(), &date);
CHECK(result);
return date;
}
MATCHER(ResultMatchesDate, "") {
const auto& [actual_result, expected_result] = arg;
return ExplainMatchResult(
AllOf(VariantWith<QuickInsertTextResult>(
Field("text", &QuickInsertTextResult::primary_text,
expected_result.primary_text)),
VariantWith<QuickInsertTextResult>(
Field("text", &QuickInsertTextResult::secondary_text,
expected_result.secondary_text)),
VariantWith<QuickInsertTextResult>(
Field("source", &QuickInsertTextResult::source,
expected_result.source))),
actual_result, result_listener);
}
struct TestCase {
std::string_view date;
std::u16string_view query;
std::vector<QuickInsertTextResult> expected_results;
};
QuickInsertTextResult MakeResult(std::u16string primary_text,
std::u16string secondary_text = u"") {
return QuickInsertTextResult(primary_text, secondary_text, ui::ImageModel(),
QuickInsertTextResult::Source::kDate);
}
class QuickInsertDateSearchTest
: public ::testing::TestWithParam<std::tuple<std::string_view, TestCase>> {
};
INSTANTIATE_TEST_SUITE_P(
,
QuickInsertDateSearchTest,
Combine(Values("00:00", "12:00", "23:59"),
Values(
// No result
TestCase{
.date = "23 Jan 2000",
.query = u"abc",
.expected_results = {},
},
// Today
TestCase{
.date = "23 Jan 2000",
.query = u"today",
.expected_results = {MakeResult(u"Jan 23")},
},
// Yesterday
TestCase{
.date = "23 Jan 2000",
.query = u"yesterday",
.expected_results = {MakeResult(u"Jan 22")},
},
// Tomorrow
TestCase{
.date = "23 Jan 2000",
.query = u"tomorrow",
.expected_results = {MakeResult(u"Jan 24")},
},
// X days from now
TestCase{
.date = "23 Jan 2000",
.query = u"10 days from now",
.expected_results = {MakeResult(u"Feb 2")},
},
// X days ago
TestCase{
.date = "23 Jan 2000",
.query = u"five days ago",
.expected_results = {MakeResult(u"Jan 18")},
},
// X weeks from now
TestCase{
.date = "23 Jan 2000",
.query = u"three weeks from now",
.expected_results = {MakeResult(u"Feb 13")},
},
// X weeks ago
TestCase{
.date = "23 Jan 2000",
.query = u"2 weeks ago",
.expected_results = {MakeResult(u"Jan 9")},
},
// search for Friday on Tuesday
TestCase{
.date = "19 Mar 2024",
.query = u"Friday",
.expected_results = {MakeResult(u"Mar 22")},
},
// search for this Friday on Tuesday
TestCase{
.date = "19 Mar 2024",
.query = u"this Friday",
.expected_results = {MakeResult(u"Mar 22")},
},
// search for next Friday on Tuesday
TestCase{
.date = "19 Mar 2024",
.query = u"next Friday",
.expected_results =
{MakeResult(u"Mar 29", u"Friday next week"),
MakeResult(u"Mar 22", u"This coming Friday")},
},
// search for last Friday on Tuesday
TestCase{
.date = "19 Mar 2024",
.query = u"last Friday",
.expected_results = {MakeResult(u"Mar 15")},
},
// search for Tuesday on Friday
TestCase{
.date = "22 Mar 2024",
.query = u"Tuesday",
.expected_results =
{MakeResult(u"Mar 26", u"This coming Tuesday"),
MakeResult(u"Mar 19", u"This past Tuesday")},
},
// search for this Tuesday on Friday
TestCase{
.date = "22 Mar 2024",
.query = u"this Tuesday",
.expected_results =
{MakeResult(u"Mar 26", u"This coming Tuesday"),
MakeResult(u"Mar 19", u"This past Tuesday")},
},
// search for next Tuesday on Friday
TestCase{
.date = "22 Mar 2024",
.query = u"next Tuesday",
.expected_results = {MakeResult(u"Mar 26")},
},
// search for last Tuesday on Friday
TestCase{
.date = "22 Mar 2024",
.query = u"last Tuesday",
.expected_results =
{MakeResult(u"Mar 12", u"Tuesday last week"),
MakeResult(u"Mar 19", u"This past Tuesday")},
},
// search for Monday on Monday
TestCase{
.date = "18 Mar 2024",
.query = u"Monday",
.expected_results = {MakeResult(u"Mar 18")},
},
// search for this Monday on Monday
TestCase{
.date = "18 Mar 2024",
.query = u"this Monday",
.expected_results = {MakeResult(u"Mar 18")},
},
// search for next Monday on Monday
TestCase{
.date = "18 Mar 2024",
.query = u"next Monday",
.expected_results = {MakeResult(u"Mar 25")},
},
// search for last Monday on Monday
TestCase{
.date = "18 Mar 2024",
.query = u"last Monday",
.expected_results = {MakeResult(u"Mar 11")},
})));
TEST_P(QuickInsertDateSearchTest, ReturnsExpectedDates) {
std::string_view time = std::get<0>(GetParam());
const auto& [date, query, expected_results] = std::get<1>(GetParam());
EXPECT_THAT(QuickInsertDateSearch(
TimeFromDateString(base::StrCat({date, " ", time})), query),
Pointwise(ResultMatchesDate(), expected_results));
}
TEST(QuickInsertSuggestedDateResults, ReturnsSuggestedResults) {
std::vector<QuickInsertSearchResult> results =
QuickInsertSuggestedDateResults();
EXPECT_THAT(results, Not(IsEmpty()));
EXPECT_THAT(
results,
Each(VariantWith<QuickInsertSearchRequestResult>(AllOf(
Field("primary_text", &QuickInsertSearchRequestResult::primary_text,
Not(IsEmpty())),
Field("secondary_text",
&QuickInsertSearchRequestResult::secondary_text,
Not(IsEmpty()))))));
}
} // namespace
} // namespace ash
|
