1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <fstream>
17 #include <vector>
18 #include "file_ex.h"
19 #include "gtest/gtest.h"
20 #include "layout/layout_parser.h"
21 #include "view_api.h"
22
23 using namespace Updater;
24 using namespace std;
25 using namespace testing::ext;
26 namespace Fs = std::filesystem;
27 namespace Updater {
operator ==(const UxViewCommonInfo & lhs,const UxViewCommonInfo & rhs)28 bool operator == (const UxViewCommonInfo &lhs, const UxViewCommonInfo &rhs)
29 {
30 return std::tie(lhs.x, lhs.y, lhs.w, lhs.h, lhs.id, lhs.type, lhs.visible) ==
31 std::tie(rhs.x, rhs.y, rhs.w, rhs.h, rhs.id, rhs.type, rhs.visible);
32 }
33
operator ==(const UxBoxProgressInfo & lhs,const UxBoxProgressInfo & rhs)34 bool operator == (const UxBoxProgressInfo &lhs, const UxBoxProgressInfo &rhs)
35 {
36 return std::tie(lhs.defaultValue, lhs.fgColor, lhs.bgColor, lhs.hasEp, lhs.endPoint) ==
37 std::tie(rhs.defaultValue, rhs.fgColor, rhs.bgColor, rhs.hasEp, rhs.endPoint);
38 }
39
operator ==(const UxLabelInfo & lhs,const UxLabelInfo & rhs)40 bool operator == (const UxLabelInfo &lhs, const UxLabelInfo &rhs)
41 {
42 return std::tie(lhs.text, lhs.bgColor, lhs.align, lhs.fontColor, lhs.fontSize) ==
43 std::tie(rhs.text, rhs.bgColor, rhs.align, rhs.fontColor, rhs.fontSize);
44 }
45
operator ==(const UxImageInfo & lhs,const UxImageInfo & rhs)46 bool operator == (const UxImageInfo &lhs, const UxImageInfo &rhs)
47 {
48 return std::tie(lhs.imgCnt, lhs.updInterval, lhs.resPath, lhs.filePrefix) ==
49 std::tie(rhs.imgCnt, rhs.updInterval, rhs.resPath, rhs.filePrefix);
50 }
51
operator ==(const UxLabelBtnInfo & lhs,const UxLabelBtnInfo & rhs)52 bool operator == (const UxLabelBtnInfo &lhs, const UxLabelBtnInfo &rhs)
53 {
54 return std::tie(lhs.fontSize, lhs.text, lhs.txtColor, lhs.bgColor, lhs.focusedBgColor, lhs.focusedTxtColor) ==
55 std::tie(rhs.fontSize, rhs.text, rhs.txtColor, rhs.bgColor, rhs.focusedBgColor, rhs.focusedTxtColor);
56 }
57
58 template <typename T>
CastSpecificInfoAs(const UxViewSpecificInfo * specPtr)59 const typename T::SpecificInfoType &CastSpecificInfoAs(const UxViewSpecificInfo *specPtr)
60 {
61 return static_cast<const SpecificInfoWrapper<T> *>(specPtr)->data;
62 }
63
64 template <typename T>
Equals(const std::unique_ptr<UxViewSpecificInfo> & lhs,const std::unique_ptr<UxViewSpecificInfo> & rhs)65 bool Equals(const std::unique_ptr<UxViewSpecificInfo> &lhs, const std::unique_ptr<UxViewSpecificInfo> &rhs)
66 {
67 const UxViewSpecificInfo *lhsPtr = lhs.get();
68 const UxViewSpecificInfo *rhsPtr = rhs.get();
69 if (lhsPtr == rhsPtr) {
70 return true;
71 }
72 if (lhsPtr == nullptr || rhsPtr == nullptr) {
73 return false;
74 }
75
76 if (lhsPtr->GetType() != rhsPtr->GetType()) {
77 return false;
78 }
79 if (lhsPtr->GetStructKey() != rhsPtr->GetStructKey()) {
80 return false;
81 }
82
83 const typename T::SpecificInfoType &lhsRef = CastSpecificInfoAs<T>(lhsPtr);
84 const typename T::SpecificInfoType &rhsRef = CastSpecificInfoAs<T>(rhsPtr);
85
86 return lhsRef == rhsRef;
87 }
88
89 }
90 namespace {
91 class UpdaterUiLayoutParserUnitTest : public testing::Test {
92 public:
93 static void SetUpTestCase(void);
94 static void TearDownTestCase(void);
95 void SetUp() override;
96 void TearDown() override;
97
98 protected:
99 void LoadValidConfigs(const std::vector<std::string> &layoutFiles, std::vector<UxPageInfo> &pages);
100 };
101
102
103 // do something at the each function begining
SetUp(void)104 void UpdaterUiLayoutParserUnitTest::SetUp(void)
105 {
106 cout << "Updater Unit UpdaterUiLayoutParserUnitTest Begin!" << endl;
107 }
108
109 // do something at the each function end
TearDown(void)110 void UpdaterUiLayoutParserUnitTest::TearDown(void)
111 {
112 cout << "Updater Unit UpdaterUiLayoutParserUnitTest End!" << endl;
113 }
114
115 // init
SetUpTestCase(void)116 void UpdaterUiLayoutParserUnitTest::SetUpTestCase(void)
117 {
118 cout << "SetUpTestCase" << endl;
119 }
120
121 // end
TearDownTestCase(void)122 void UpdaterUiLayoutParserUnitTest::TearDownTestCase(void)
123 {
124 cout << "TearDownTestCase" << endl;
125 }
126
LoadValidConfigs(const std::vector<std::string> & layoutFiles,std::vector<UxPageInfo> & pages)127 void UpdaterUiLayoutParserUnitTest::LoadValidConfigs(
128 const std::vector<std::string> &layoutFiles, std::vector<UxPageInfo> &pages)
129 {
130 ASSERT_GE(layoutFiles.size(), 1UL);
131 ASSERT_TRUE(pages.empty());
132 EXPECT_TRUE(LayoutParser::GetInstance().LoadLayout(layoutFiles, pages));
133 ASSERT_EQ(pages.size(), layoutFiles.size());
134 }
135
136 template <typename T>
CreateViewInfo(UxViewCommonInfo commonInfo,typename T::SpecificInfoType specInfo)137 UxViewInfo CreateViewInfo(UxViewCommonInfo commonInfo, typename T::SpecificInfoType specInfo)
138 {
139 UxViewInfo info {commonInfo, ComponentFactory::CreateSpecificInfo(T::COMPONENT_TYPE)};
140 EXPECT_NE(info.specificInfo.get(), nullptr);
141
142 static_cast<SpecificInfoWrapper<T> *>(info.specificInfo.get())->data = specInfo;
143 return info;
144 }
145
146 HWTEST_F(UpdaterUiLayoutParserUnitTest, test_label_parser, TestSize.Level0)
147 {
148 std::vector<UxPageInfo> pages;
149 LoadValidConfigs({"/data/updater/ui/label.json"}, pages);
150 UxPageInfo &pageInfo = pages[0];
151
152 ASSERT_EQ(pageInfo.viewInfos.size(), 1UL);
153 EXPECT_EQ(pageInfo.id, "menu"s);
154
155 UxViewInfo expectedLabel =
156 CreateViewInfo<TextLabelAdapter>(UxViewCommonInfo { 0, 0, 100, 100, "label_id_0", "UILabel", true },
157 UxLabelInfo {10,
158 "Reboot to normal system",
159 "center",
160 "#ffffffff",
161 "#ffffffff",
162 "normal",
163 {"#ffffffff", "#ffffffff", false},
164 false,
165 "ellipsis"});
166 EXPECT_EQ(pageInfo.viewInfos[0].commonInfo, expectedLabel.commonInfo);
167 EXPECT_TRUE(Equals<TextLabelAdapter>(pageInfo.viewInfos[0].specificInfo, expectedLabel.specificInfo));
168 }
169
170 HWTEST_F(UpdaterUiLayoutParserUnitTest, test_progress_parser, TestSize.Level0)
171 {
172 std::vector<UxPageInfo> pages;
173 LoadValidConfigs({"/data/updater/ui/boxprogress.json"}, pages);
174 UxPageInfo &pageInfo = pages[0];
175
176 ASSERT_EQ(pageInfo.viewInfos.size(), 1UL);
177 EXPECT_EQ(pageInfo.id, "menu"s);
178
179 UxViewInfo expectedProgress =
180 CreateViewInfo<BoxProgressAdapter>(UxViewCommonInfo {0, 0, 100, 100, "box_progress_0", "UIBoxProgress", true },
181 UxBoxProgressInfo {10, "#ffffffff", "#ffffffff" });
182 EXPECT_EQ(pageInfo.viewInfos[0].commonInfo, expectedProgress.commonInfo);
183 EXPECT_TRUE(Equals<BoxProgressAdapter>(pageInfo.viewInfos[0].specificInfo, expectedProgress.specificInfo));
184 }
185
186 HWTEST_F(UpdaterUiLayoutParserUnitTest, test_image_view_parser, TestSize.Level0)
187 {
188 std::vector<UxPageInfo> pages;
189 LoadValidConfigs({"/data/updater/ui/imageview.json"}, pages);
190 UxPageInfo &pageInfo = pages[0];
191
192 ASSERT_EQ(pageInfo.viewInfos.size(), 1UL);
193 EXPECT_EQ(pageInfo.id, "menu"s);
194
195 UxViewInfo expectedImage = CreateViewInfo<ImgViewAdapter>(
196 UxViewCommonInfo {0, 0, 100, 100, "image_view", "UIImageView", true}, UxImageInfo {"/res/images", "", 100, 1});
197 EXPECT_EQ(pageInfo.viewInfos[0].commonInfo, expectedImage.commonInfo);
198 EXPECT_TRUE(Equals<ImgViewAdapter>(pageInfo.viewInfos[0].specificInfo, expectedImage.specificInfo));
199 }
200
201 HWTEST_F(UpdaterUiLayoutParserUnitTest, test_all, TestSize.Level1)
202 {
203 std::vector<UxPageInfo> pages;
204 LoadValidConfigs({"/data/updater/ui/all.json"}, pages);
205 UxPageInfo &pageInfo = pages[0];
206
207 ASSERT_EQ(pageInfo.viewInfos.size(), 3UL);
208 EXPECT_EQ(pageInfo.id, "menu"s);
209
210 {
211 UxViewInfo expectedLabel =
212 CreateViewInfo<TextLabelAdapter>(UxViewCommonInfo {0, 0, 100, 100, "label_id_0", "UILabel", true},
213 UxLabelInfo {10,
214 "Reboot to normal system",
215 "center",
216 "#ffffffff",
217 "#ffffffff",
218 "normal",
219 {"#ffffffff", "#ffffffff", false},
220 false,
221 "ellipsis"});
222 EXPECT_EQ(pageInfo.viewInfos[0].commonInfo, expectedLabel.commonInfo);
223 EXPECT_TRUE(Equals<TextLabelAdapter>(pageInfo.viewInfos[0].specificInfo, expectedLabel.specificInfo));
224 }
225
226 {
227 UxViewInfo expectedImage =
228 CreateViewInfo<ImgViewAdapter>(UxViewCommonInfo {0, 0, 100, 100, "image_view", "UIImageView", true},
229 UxImageInfo {"/res/images", "", 100, 1});
230 EXPECT_EQ(pageInfo.viewInfos[1].commonInfo, expectedImage.commonInfo);
231 EXPECT_TRUE(Equals<ImgViewAdapter>(pageInfo.viewInfos[1].specificInfo, expectedImage.specificInfo));
232 }
233
234 {
235 UxViewInfo expectedProgress = CreateViewInfo<BoxProgressAdapter>(
236 UxViewCommonInfo {0, 0, 100, 100, "box_progress_0", "UIBoxProgress", true},
237 UxBoxProgressInfo {10, "#ffffffff", "#ffffffff", "", false});
238 EXPECT_EQ(pageInfo.viewInfos[2].commonInfo, expectedProgress.commonInfo);
239 EXPECT_TRUE(Equals<BoxProgressAdapter>(pageInfo.viewInfos[2].specificInfo, expectedProgress.specificInfo));
240 }
241 }
242
243 HWTEST_F(UpdaterUiLayoutParserUnitTest, test_load_multiple_page_info, TestSize.Level0)
244 {
245 std::vector<UxPageInfo> pageInfos {};
246 LoadValidConfigs({"/data/updater/ui/imageview.json", "/data/updater/ui/boxprogress.json"}, pageInfos);
247
248 UxViewInfo expectedImage = CreateViewInfo<ImgViewAdapter>(
249 UxViewCommonInfo {0, 0, 100, 100, "image_view", "UIImageView", true}, UxImageInfo {"/res/images", "", 100, 1});
250 EXPECT_EQ(pageInfos[0].id, "menu");
251 ASSERT_EQ(pageInfos[0].viewInfos.size(), 1ul);
252 EXPECT_EQ(pageInfos[0].viewInfos[0].commonInfo, expectedImage.commonInfo);
253 EXPECT_TRUE(Equals<ImgViewAdapter>(pageInfos[0].viewInfos[0].specificInfo, expectedImage.specificInfo));
254
255 UxViewInfo expectedProgress =
256 CreateViewInfo<BoxProgressAdapter>(UxViewCommonInfo {0, 0, 100, 100, "box_progress_0", "UIBoxProgress", true},
257 UxBoxProgressInfo {10, "#ffffffff", "#ffffffff"});
258 EXPECT_EQ(pageInfos[1].id, "menu");
259 ASSERT_EQ(pageInfos[1].viewInfos.size(), 1ul);
260 EXPECT_EQ(pageInfos[1].viewInfos[0].commonInfo, expectedProgress.commonInfo);
261 EXPECT_TRUE(Equals<BoxProgressAdapter>(pageInfos[1].viewInfos[0].specificInfo, expectedProgress.specificInfo));
262 }
263
264 HWTEST_F(UpdaterUiLayoutParserUnitTest, test_load_sub_page_info, TestSize.Level0)
265 {
266 std::vector<UxPageInfo> pageInfos {};
267 LoadValidConfigs({"/data/updater/ui/subpage.json"}, pageInfos);
268
269 ASSERT_EQ(pageInfos.size(), 1ul);
270 auto &subPages = pageInfos[0].subpages;
271 ASSERT_EQ(subPages.size(), 1UL);
272 EXPECT_EQ(subPages[0].id, "subpage1");
273 EXPECT_EQ(subPages[0].coms.size(), 3UL);
274 EXPECT_EQ(subPages[0].coms[0], "a");
275 EXPECT_EQ(subPages[0].coms[1], "b");
276 EXPECT_EQ(subPages[0].coms[2], "c");
277 }
278
279 HWTEST_F(UpdaterUiLayoutParserUnitTest, test_invalid_cases, TestSize.Level0)
280 {
281 constexpr std::array files { "/data/updater/ui/noPageInfo.json", "/data/updater/ui/noComs.json",
282 "/data/updater/ui/comsNoType.json", "/data/updater/ui/commonInvalid.json",
283 "/data/updater/ui/typeInvalid.json", "/data/updater/ui/incompleteComInfo.json"};
284 for (auto file : files) {
285 std::vector<std::string> layoutFiles { file };
286 std::vector<UxPageInfo> pageInfos {};
287 EXPECT_EQ(true, OHOS::FileExists(file)) << file;
288 EXPECT_FALSE(LayoutParser::GetInstance().LoadLayout(layoutFiles, pageInfos));
289 }
290 }
291
292 class UpdaterUiMenuParserUnitTest : public testing::Test {
293 public:
294 static void SetUpTestCase(void);
295 static void TearDownTestCase(void);
296 void SetUp() override;
297 void TearDown() override;
298
299 protected:
300 struct TestMenuItem {
301 UxViewCommonInfo common;
302 UxLabelInfo label;
303
operator ==(const TestMenuItem & lhs,const TestMenuItem & rhs)304 friend bool operator==(const TestMenuItem &lhs, const TestMenuItem &rhs)
305 {
306 return (lhs.common == rhs.common) && (lhs.label == rhs.label);
307 }
308 };
309 static bool GetMenuItem(size_t index, TestMenuItem &item);
310 static TestMenuItem GetDefaultValue();
311
312 inline static std::vector<UxPageInfo> pages_;
313 };
314
SetUp(void)315 void UpdaterUiMenuParserUnitTest::SetUp(void)
316 {
317 cout << "Updater Unit UpdaterUiMenuParserUnitTest Begin!" << endl;
318 ASSERT_TRUE(LayoutParser::GetInstance().LoadLayout({"/data/updater/ui/menu.json"}, pages_));
319 }
320
TearDown(void)321 void UpdaterUiMenuParserUnitTest::TearDown(void)
322 {
323 cout << "Updater Unit UpdaterUiMenuParserUnitTest End!" << endl;
324 }
325
SetUpTestCase()326 void UpdaterUiMenuParserUnitTest::SetUpTestCase()
327 {
328 cout << "SetUpTestCase" << endl;
329 }
330
TearDownTestCase()331 void UpdaterUiMenuParserUnitTest::TearDownTestCase()
332 {
333 cout << "TearDownTestCase" << endl;
334 }
335
GetMenuItem(size_t index,UpdaterUiMenuParserUnitTest::TestMenuItem & item)336 bool UpdaterUiMenuParserUnitTest::GetMenuItem(size_t index, UpdaterUiMenuParserUnitTest::TestMenuItem &item)
337 {
338 const SpecificInfoWrapper<TextLabelAdapter> emptyItem {};
339
340 if (pages_.size() != 1UL) {
341 return false;
342 }
343
344 if (index >= pages_[0].viewInfos.size()) {
345 return false;
346 }
347
348 UxViewInfo &refInfo = pages_[0].viewInfos[index];
349 item.common = refInfo.commonInfo;
350
351 if (refInfo.specificInfo == nullptr) {
352 return false;
353 }
354 if (refInfo.specificInfo->GetType() != emptyItem.GetType()) {
355 return false;
356 }
357 if (refInfo.specificInfo->GetStructKey() != emptyItem.GetStructKey()) {
358 return false;
359 }
360
361 const UxLabelInfo &refLabel = CastSpecificInfoAs<TextLabelAdapter>(refInfo.specificInfo.get());
362 item.label = refLabel;
363 return true;
364 }
365
GetDefaultValue()366 UpdaterUiMenuParserUnitTest::TestMenuItem UpdaterUiMenuParserUnitTest::GetDefaultValue()
367 {
368 // the default node
369 TestMenuItem item {.common = UxViewCommonInfo {.visible = true},
370 .label = UxLabelInfo {.align = "center",
371 .fontColor = "#ffffffff",
372 .bgColor = "#000000ff",
373 .style = "normal",
374 .focusInfo =
375 LabelFocusInfo {.focusedFontColor = "#ffffffff", .focusedBgColor = "#000000ff", .focusable = false},
376 .touchable = false,
377 .lineBreakMode = "ellipsis"}};
378 return item;
379 }
380
381 HWTEST_F(UpdaterUiMenuParserUnitTest, test_menu_item_basic, TestSize.Level0)
382 {
383 ASSERT_EQ(pages_.size(), 1UL);
384 ASSERT_EQ(pages_[0].viewInfos.size(), 8UL);
385 EXPECT_EQ(pages_[0].id, "menu"s);
386 }
387
388 HWTEST_F(UpdaterUiMenuParserUnitTest, test_menu_item_00, TestSize.Level0)
389 {
390 TestMenuItem item;
391 ASSERT_TRUE(GetMenuItem(0, item));
392
393 TestMenuItem expected = GetDefaultValue();
394 expected.common.type = "UILabel";
395 expected.common.id = "Label_RebootToNormalSystem";
396 expected.common.x = 1280;
397 expected.common.y = 0;
398 expected.common.w = 800;
399 expected.common.h = 200;
400 expected.common.visible = false;
401 expected.label.text = "Reboot to normal system";
402 expected.label.fontSize = 60;
403
404 EXPECT_EQ(item, expected);
405 }
406
407 HWTEST_F(UpdaterUiMenuParserUnitTest, test_menu_item_01, TestSize.Level0)
408 {
409 TestMenuItem item;
410 ASSERT_TRUE(GetMenuItem(1, item));
411
412 TestMenuItem expected = GetDefaultValue();
413 expected.common.type = "UILabel";
414 expected.common.id = "Label_UserdataReset";
415 expected.common.x = 1280;
416 expected.common.y = 200;
417 expected.common.w = 800;
418 expected.common.h = 200;
419 expected.label.text = "Userdata reset";
420 expected.label.fontSize = 60;
421
422 EXPECT_EQ(item, expected);
423 }
424
425 HWTEST_F(UpdaterUiMenuParserUnitTest, test_menu_item_02, TestSize.Level0)
426 {
427 TestMenuItem item;
428 ASSERT_TRUE(GetMenuItem(2, item));
429
430 TestMenuItem expected = GetDefaultValue();
431 expected.common.type = "UILabel";
432 expected.common.id = "Label_UpdateFromSDCard";
433 expected.common.x = 1280;
434 expected.common.y = 400;
435 expected.common.w = 800;
436 expected.common.h = 200;
437 expected.label.text = "Update from SD Card";
438 expected.label.fontSize = 60;
439
440 EXPECT_EQ(item, expected);
441 }
442
443 HWTEST_F(UpdaterUiMenuParserUnitTest, test_menu_item_03, TestSize.Level0)
444 {
445 TestMenuItem item;
446 ASSERT_TRUE(GetMenuItem(3, item));
447
448 TestMenuItem expected = GetDefaultValue();
449 expected.common.type = "UILabel";
450 expected.common.id = "Label_MenuDialogTitle";
451 expected.common.x = 1280;
452 expected.common.y = 600;
453 expected.common.w = 800;
454 expected.common.h = 200;
455 expected.label.text = "Tip";
456 expected.label.fontSize = 40;
457
458 EXPECT_EQ(item, expected);
459 }
460
461 HWTEST_F(UpdaterUiMenuParserUnitTest, test_menu_item_04, TestSize.Level0)
462 {
463 TestMenuItem item;
464 ASSERT_TRUE(GetMenuItem(4, item));
465
466 TestMenuItem expected = GetDefaultValue();
467 expected.common.type = "UILabel";
468 expected.common.id = "Label_MenuDialogNote";
469 expected.common.x = 1280;
470 expected.common.y = 800;
471 expected.common.w = 800;
472 expected.common.h = 200;
473 expected.label.text = "Delete user date now...";
474 expected.label.fontSize = 40;
475
476 EXPECT_EQ(item, expected);
477 }
478
479 HWTEST_F(UpdaterUiMenuParserUnitTest, test_menu_item_05, TestSize.Level0)
480 {
481 TestMenuItem item;
482 ASSERT_TRUE(GetMenuItem(5, item));
483
484 TestMenuItem expected = GetDefaultValue();
485 expected.common.type = "UILabel";
486 expected.common.id = "Label_MenuDialogNext";
487 expected.common.x = 1280;
488 expected.common.y = 1000;
489 expected.common.w = 800;
490 expected.common.h = 200;
491 expected.label.text = "Do you want to continue?";
492 expected.label.fontSize = 40;
493
494 EXPECT_EQ(item, expected);
495 }
496
497 HWTEST_F(UpdaterUiMenuParserUnitTest, test_menu_item_06, TestSize.Level0)
498 {
499 TestMenuItem item;
500 ASSERT_TRUE(GetMenuItem(6, item));
501
502 TestMenuItem expected = GetDefaultValue();
503 expected.common.type = "UILabel";
504 expected.common.id = "Label_MenuDialogOK";
505 expected.common.x = 1280;
506 expected.common.y = 1200;
507 expected.common.w = 800;
508 expected.common.h = 200;
509 expected.label.text = "Continue";
510 expected.label.fontSize = 40;
511
512 EXPECT_EQ(item, expected);
513 }
514
515 HWTEST_F(UpdaterUiMenuParserUnitTest, test_menu_item_07, TestSize.Level0)
516 {
517 TestMenuItem item;
518 ASSERT_TRUE(GetMenuItem(7, item));
519
520 TestMenuItem expected = GetDefaultValue();
521 expected.common.type = "UILabel";
522 expected.common.id = "Label_MenuDialogCancel";
523 expected.common.x = 1680;
524 expected.common.y = 1200;
525 expected.common.w = 800;
526 expected.common.h = 200;
527 expected.label.text = "Cancel";
528 expected.label.fontSize = 40;
529
530 EXPECT_EQ(item, expected);
531 }
532
533 } // namespace
534