• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2018 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <stddef.h>
18 #include <stdio.h>
19 
20 #include <functional>
21 #include <map>
22 #include <memory>
23 #include <string>
24 #include <vector>
25 
26 #include <android-base/file.h>
27 #include <android-base/logging.h>
28 #include <android-base/stringprintf.h>
29 #include <gtest/gtest.h>
30 #include <gtest/gtest_prod.h>
31 
32 #include "common/test_constants.h"
33 #include "minui/minui.h"
34 #include "otautil/paths.h"
35 #include "private/resources.h"
36 #include "recovery_ui/device.h"
37 #include "recovery_ui/screen_ui.h"
38 
39 static const std::vector<std::string> HEADERS{ "header" };
40 static const std::vector<std::string> ITEMS{ "item1", "item2", "item3", "item4", "1234567890" };
41 
42 // TODO(xunchang) check if some draw functions are called when drawing menus.
43 class MockDrawFunctions : public DrawInterface {
SetColor(UIElement) const44   void SetColor(UIElement /* element */) const override {}
DrawHighlightBar(int,int,int,int) const45   void DrawHighlightBar(int /* x */, int /* y */, int /* width */,
46                         int /* height */) const override {}
DrawHorizontalRule(int) const47   int DrawHorizontalRule(int /* y */) const override {
48     return 0;
49   }
DrawTextLine(int,int,const std::string &,bool) const50   int DrawTextLine(int /* x */, int /* y */, const std::string& /* line */,
51                    bool /* bold */) const override {
52     return 0;
53   }
DrawSurface(const GRSurface *,int,int,int,int,int,int) const54   void DrawSurface(const GRSurface* /* surface */, int /* sx */, int /* sy */, int /* w */,
55                    int /* h */, int /* dx */, int /* dy */) const override {}
DrawFill(int,int,int,int) const56   void DrawFill(int /* x */, int /* y */, int /* w */, int /* h */) const override {}
DrawTextIcon(int,int,const GRSurface *) const57   void DrawTextIcon(int /* x */, int /* y */, const GRSurface* /* surface */) const override {}
DrawTextLines(int,int,const std::vector<std::string> &) const58   int DrawTextLines(int /* x */, int /* y */,
59                     const std::vector<std::string>& /* lines */) const override {
60     return 0;
61   }
DrawWrappedTextLines(int,int,const std::vector<std::string> &) const62   int DrawWrappedTextLines(int /* x */, int /* y */,
63                            const std::vector<std::string>& /* lines */) const override {
64     return 0;
65   }
66 };
67 
68 class ScreenUITest : public testing::Test {
69  protected:
70   MockDrawFunctions draw_funcs_;
71 };
72 
TEST_F(ScreenUITest,StartPhoneMenuSmoke)73 TEST_F(ScreenUITest, StartPhoneMenuSmoke) {
74   TextMenu menu(false, 10, 20, HEADERS, ITEMS, 0, 20, draw_funcs_);
75   ASSERT_FALSE(menu.scrollable());
76   ASSERT_EQ(HEADERS[0], menu.text_headers()[0]);
77   ASSERT_EQ(5u, menu.ItemsCount());
78 
79   std::string message;
80   ASSERT_FALSE(menu.ItemsOverflow(&message));
81   for (size_t i = 0; i < menu.ItemsCount(); i++) {
82     ASSERT_EQ(ITEMS[i], menu.TextItem(i));
83   }
84 
85   ASSERT_EQ(0, menu.selection());
86 }
87 
TEST_F(ScreenUITest,StartWearMenuSmoke)88 TEST_F(ScreenUITest, StartWearMenuSmoke) {
89   TextMenu menu(true, 10, 8, HEADERS, ITEMS, 1, 20, draw_funcs_);
90   ASSERT_TRUE(menu.scrollable());
91   ASSERT_EQ(HEADERS[0], menu.text_headers()[0]);
92   ASSERT_EQ(5u, menu.ItemsCount());
93 
94   std::string message;
95   ASSERT_FALSE(menu.ItemsOverflow(&message));
96   for (size_t i = 0; i < menu.ItemsCount() - 1; i++) {
97     ASSERT_EQ(ITEMS[i], menu.TextItem(i));
98   }
99   // Test of the last item is truncated
100   ASSERT_EQ("12345678", menu.TextItem(4));
101   ASSERT_EQ(1, menu.selection());
102 }
103 
TEST_F(ScreenUITest,StartPhoneMenuItemsOverflow)104 TEST_F(ScreenUITest, StartPhoneMenuItemsOverflow) {
105   TextMenu menu(false, 1, 20, HEADERS, ITEMS, 0, 20, draw_funcs_);
106   ASSERT_FALSE(menu.scrollable());
107   ASSERT_EQ(1u, menu.ItemsCount());
108 
109   std::string message;
110   ASSERT_FALSE(menu.ItemsOverflow(&message));
111   for (size_t i = 0; i < menu.ItemsCount(); i++) {
112     ASSERT_EQ(ITEMS[i], menu.TextItem(i));
113   }
114 
115   ASSERT_EQ(0u, menu.MenuStart());
116   ASSERT_EQ(1u, menu.MenuEnd());
117 }
118 
TEST_F(ScreenUITest,StartWearMenuItemsOverflow)119 TEST_F(ScreenUITest, StartWearMenuItemsOverflow) {
120   TextMenu menu(true, 1, 20, HEADERS, ITEMS, 0, 20, draw_funcs_);
121   ASSERT_TRUE(menu.scrollable());
122   ASSERT_EQ(5u, menu.ItemsCount());
123 
124   std::string message;
125   ASSERT_TRUE(menu.ItemsOverflow(&message));
126   ASSERT_EQ("Current item: 1/5", message);
127 
128   for (size_t i = 0; i < menu.ItemsCount(); i++) {
129     ASSERT_EQ(ITEMS[i], menu.TextItem(i));
130   }
131 
132   ASSERT_EQ(0u, menu.MenuStart());
133   ASSERT_EQ(1u, menu.MenuEnd());
134 }
135 
TEST_F(ScreenUITest,PhoneMenuSelectSmoke)136 TEST_F(ScreenUITest, PhoneMenuSelectSmoke) {
137   int sel = 0;
138   TextMenu menu(false, 10, 20, HEADERS, ITEMS, sel, 20, draw_funcs_);
139   // Mimic down button 10 times (2 * items size)
140   for (int i = 0; i < 10; i++) {
141     sel = menu.Select(++sel);
142     ASSERT_EQ(sel, menu.selection());
143 
144     // Wraps the selection for unscrollable menu when it reaches the boundary.
145     int expected = (i + 1) % 5;
146     ASSERT_EQ(expected, menu.selection());
147 
148     ASSERT_EQ(0u, menu.MenuStart());
149     ASSERT_EQ(5u, menu.MenuEnd());
150   }
151 
152   // Mimic up button 10 times
153   for (int i = 0; i < 10; i++) {
154     sel = menu.Select(--sel);
155     ASSERT_EQ(sel, menu.selection());
156 
157     int expected = (9 - i) % 5;
158     ASSERT_EQ(expected, menu.selection());
159 
160     ASSERT_EQ(0u, menu.MenuStart());
161     ASSERT_EQ(5u, menu.MenuEnd());
162   }
163 }
164 
TEST_F(ScreenUITest,WearMenuSelectSmoke)165 TEST_F(ScreenUITest, WearMenuSelectSmoke) {
166   int sel = 0;
167   TextMenu menu(true, 10, 20, HEADERS, ITEMS, sel, 20, draw_funcs_);
168   // Mimic pressing down button 10 times (2 * items size)
169   for (int i = 0; i < 10; i++) {
170     sel = menu.Select(++sel);
171     ASSERT_EQ(sel, menu.selection());
172 
173     // Stops the selection at the boundary if the menu is scrollable.
174     int expected = std::min(i + 1, 4);
175     ASSERT_EQ(expected, menu.selection());
176 
177     ASSERT_EQ(0u, menu.MenuStart());
178     ASSERT_EQ(5u, menu.MenuEnd());
179   }
180 
181   // Mimic pressing up button 10 times
182   for (int i = 0; i < 10; i++) {
183     sel = menu.Select(--sel);
184     ASSERT_EQ(sel, menu.selection());
185 
186     int expected = std::max(3 - i, 0);
187     ASSERT_EQ(expected, menu.selection());
188 
189     ASSERT_EQ(0u, menu.MenuStart());
190     ASSERT_EQ(5u, menu.MenuEnd());
191   }
192 }
193 
TEST_F(ScreenUITest,WearMenuSelectItemsOverflow)194 TEST_F(ScreenUITest, WearMenuSelectItemsOverflow) {
195   int sel = 1;
196   TextMenu menu(true, 3, 20, HEADERS, ITEMS, sel, 20, draw_funcs_);
197   ASSERT_EQ(5u, menu.ItemsCount());
198 
199   // Scroll the menu to the end, and check the start & end of menu.
200   for (int i = 0; i < 3; i++) {
201     sel = menu.Select(++sel);
202     ASSERT_EQ(i + 2, sel);
203     ASSERT_EQ(static_cast<size_t>(i), menu.MenuStart());
204     ASSERT_EQ(static_cast<size_t>(i + 3), menu.MenuEnd());
205   }
206 
207   // Press down button one more time won't change the MenuStart() and MenuEnd().
208   sel = menu.Select(++sel);
209   ASSERT_EQ(4, sel);
210   ASSERT_EQ(2u, menu.MenuStart());
211   ASSERT_EQ(5u, menu.MenuEnd());
212 
213   // Scroll the menu to the top.
214   // The expected menu sel, start & ends are:
215   // sel 3, start 2, end 5
216   // sel 2, start 2, end 5
217   // sel 1, start 1, end 4
218   // sel 0, start 0, end 3
219   for (int i = 0; i < 4; i++) {
220     sel = menu.Select(--sel);
221     ASSERT_EQ(3 - i, sel);
222     ASSERT_EQ(static_cast<size_t>(std::min(3 - i, 2)), menu.MenuStart());
223     ASSERT_EQ(static_cast<size_t>(std::min(6 - i, 5)), menu.MenuEnd());
224   }
225 
226   // Press up button one more time won't change the MenuStart() and MenuEnd().
227   sel = menu.Select(--sel);
228   ASSERT_EQ(0, sel);
229   ASSERT_EQ(0u, menu.MenuStart());
230   ASSERT_EQ(3u, menu.MenuEnd());
231 }
232 
TEST_F(ScreenUITest,GraphicMenuSelection)233 TEST_F(ScreenUITest, GraphicMenuSelection) {
234   auto image = GRSurface::Create(50, 50, 50, 1);
235   auto header = image->Clone();
236   std::vector<const GRSurface*> items = {
237     image.get(),
238     image.get(),
239     image.get(),
240   };
241   GraphicMenu menu(header.get(), items, 0, draw_funcs_);
242 
243   ASSERT_EQ(0, menu.selection());
244 
245   int sel = 0;
246   for (int i = 0; i < 3; i++) {
247     sel = menu.Select(++sel);
248     ASSERT_EQ((i + 1) % 3, sel);
249     ASSERT_EQ(sel, menu.selection());
250   }
251 
252   sel = 0;
253   for (int i = 0; i < 3; i++) {
254     sel = menu.Select(--sel);
255     ASSERT_EQ(2 - i, sel);
256     ASSERT_EQ(sel, menu.selection());
257   }
258 }
259 
TEST_F(ScreenUITest,GraphicMenuValidate)260 TEST_F(ScreenUITest, GraphicMenuValidate) {
261   auto image = GRSurface::Create(50, 50, 50, 1);
262   auto header = image->Clone();
263   std::vector<const GRSurface*> items = {
264     image.get(),
265     image.get(),
266     image.get(),
267   };
268 
269   ASSERT_TRUE(GraphicMenu::Validate(200, 200, header.get(), items));
270 
271   // Menu exceeds the horizontal boundary.
272   auto wide_surface = GRSurface::Create(300, 50, 300, 1);
273   ASSERT_FALSE(GraphicMenu::Validate(299, 200, wide_surface.get(), items));
274 
275   // Menu exceeds the vertical boundary.
276   items.emplace_back(image.get());
277   ASSERT_FALSE(GraphicMenu::Validate(200, 249, header.get(), items));
278 }
279 
280 static constexpr int kMagicAction = 101;
281 
282 enum class KeyCode : int {
283   TIMEOUT = -1,
284   NO_OP = 0,
285   UP = 1,
286   DOWN = 2,
287   ENTER = 3,
288   MAGIC = 1001,
289   LAST,
290 };
291 
292 static const std::map<KeyCode, int> kKeyMapping{
293   // clang-format off
294   { KeyCode::NO_OP, Device::kNoAction },
295   { KeyCode::UP, Device::kHighlightUp },
296   { KeyCode::DOWN, Device::kHighlightDown },
297   { KeyCode::ENTER, Device::kInvokeItem },
298   { KeyCode::MAGIC, kMagicAction },
299   // clang-format on
300 };
301 
302 class TestableScreenRecoveryUI : public ScreenRecoveryUI {
303  public:
304   int WaitKey() override;
305 
306   void SetKeyBuffer(const std::vector<KeyCode>& buffer);
307 
308   int KeyHandler(int key, bool visible) const;
309 
310  private:
311   FRIEND_TEST(DISABLED_ScreenRecoveryUITest, Init);
312   FRIEND_TEST(DISABLED_ScreenRecoveryUITest, RtlLocale);
313   FRIEND_TEST(DISABLED_ScreenRecoveryUITest, RtlLocaleWithSuffix);
314   FRIEND_TEST(DISABLED_ScreenRecoveryUITest, LoadAnimation);
315   FRIEND_TEST(DISABLED_ScreenRecoveryUITest, LoadAnimation_MissingAnimation);
316 
317   std::vector<KeyCode> key_buffer_;
318   size_t key_buffer_index_;
319 };
320 
SetKeyBuffer(const std::vector<KeyCode> & buffer)321 void TestableScreenRecoveryUI::SetKeyBuffer(const std::vector<KeyCode>& buffer) {
322   key_buffer_ = buffer;
323   key_buffer_index_ = 0;
324 }
325 
KeyHandler(int key,bool) const326 int TestableScreenRecoveryUI::KeyHandler(int key, bool) const {
327   KeyCode key_code = static_cast<KeyCode>(key);
328   if (kKeyMapping.find(key_code) != kKeyMapping.end()) {
329     return kKeyMapping.at(key_code);
330   }
331   return Device::kNoAction;
332 }
333 
WaitKey()334 int TestableScreenRecoveryUI::WaitKey() {
335   if (IsKeyInterrupted()) {
336     return static_cast<int>(RecoveryUI::KeyError::INTERRUPTED);
337   }
338 
339   CHECK_LT(key_buffer_index_, key_buffer_.size());
340   return static_cast<int>(key_buffer_[key_buffer_index_++]);
341 }
342 
343 class DISABLED_ScreenRecoveryUITest : public ::testing::Test {
344  protected:
345   const std::string kTestLocale = "en-US";
346   const std::string kTestRtlLocale = "ar";
347   const std::string kTestRtlLocaleWithSuffix = "ar-EG";
348 
SetUp()349   void SetUp() override {
350     has_graphics_ = gr_init() == 0;
351     gr_exit();
352 
353     if (has_graphics_) {
354       ui_ = std::make_unique<TestableScreenRecoveryUI>();
355     }
356 
357     testdata_dir_ = from_testdata_base("");
358     Paths::Get().set_resource_dir(testdata_dir_);
359     res_set_resource_dir(testdata_dir_);
360   }
361 
362   bool has_graphics_;
363   std::unique_ptr<TestableScreenRecoveryUI> ui_;
364   std::string testdata_dir_;
365 };
366 
367 #define RETURN_IF_NO_GRAPHICS                                                 \
368   do {                                                                        \
369     if (!has_graphics_) {                                                     \
370       GTEST_LOG_(INFO) << "Test skipped due to no available graphics device"; \
371       return;                                                                 \
372     }                                                                         \
373   } while (false)
374 
TEST_F(DISABLED_ScreenRecoveryUITest,Init)375 TEST_F(DISABLED_ScreenRecoveryUITest, Init) {
376   RETURN_IF_NO_GRAPHICS;
377 
378   ASSERT_TRUE(ui_->Init(kTestLocale));
379   ASSERT_EQ(kTestLocale, ui_->GetLocale());
380   ASSERT_FALSE(ui_->rtl_locale_);
381   ASSERT_FALSE(ui_->IsTextVisible());
382   ASSERT_FALSE(ui_->WasTextEverVisible());
383 }
384 
TEST_F(DISABLED_ScreenRecoveryUITest,dtor_NotCallingInit)385 TEST_F(DISABLED_ScreenRecoveryUITest, dtor_NotCallingInit) {
386   ui_.reset();
387   ASSERT_FALSE(ui_);
388 }
389 
TEST_F(DISABLED_ScreenRecoveryUITest,ShowText)390 TEST_F(DISABLED_ScreenRecoveryUITest, ShowText) {
391   RETURN_IF_NO_GRAPHICS;
392 
393   ASSERT_TRUE(ui_->Init(kTestLocale));
394   ASSERT_FALSE(ui_->IsTextVisible());
395   ui_->ShowText(true);
396   ASSERT_TRUE(ui_->IsTextVisible());
397   ASSERT_TRUE(ui_->WasTextEverVisible());
398 
399   ui_->ShowText(false);
400   ASSERT_FALSE(ui_->IsTextVisible());
401   ASSERT_TRUE(ui_->WasTextEverVisible());
402 }
403 
TEST_F(DISABLED_ScreenRecoveryUITest,RtlLocale)404 TEST_F(DISABLED_ScreenRecoveryUITest, RtlLocale) {
405   RETURN_IF_NO_GRAPHICS;
406 
407   ASSERT_TRUE(ui_->Init(kTestRtlLocale));
408   ASSERT_TRUE(ui_->rtl_locale_);
409 }
410 
TEST_F(DISABLED_ScreenRecoveryUITest,RtlLocaleWithSuffix)411 TEST_F(DISABLED_ScreenRecoveryUITest, RtlLocaleWithSuffix) {
412   RETURN_IF_NO_GRAPHICS;
413 
414   ASSERT_TRUE(ui_->Init(kTestRtlLocaleWithSuffix));
415   ASSERT_TRUE(ui_->rtl_locale_);
416 }
417 
TEST_F(DISABLED_ScreenRecoveryUITest,ShowMenu)418 TEST_F(DISABLED_ScreenRecoveryUITest, ShowMenu) {
419   RETURN_IF_NO_GRAPHICS;
420 
421   ASSERT_TRUE(ui_->Init(kTestLocale));
422   ui_->SetKeyBuffer({
423       KeyCode::UP,
424       KeyCode::DOWN,
425       KeyCode::UP,
426       KeyCode::DOWN,
427       KeyCode::ENTER,
428   });
429   ASSERT_EQ(3u, ui_->ShowMenu(HEADERS, ITEMS, 3, true,
430                               std::bind(&TestableScreenRecoveryUI::KeyHandler, ui_.get(),
431                                         std::placeholders::_1, std::placeholders::_2)));
432 
433   ui_->SetKeyBuffer({
434       KeyCode::UP,
435       KeyCode::UP,
436       KeyCode::NO_OP,
437       KeyCode::NO_OP,
438       KeyCode::UP,
439       KeyCode::ENTER,
440   });
441   ASSERT_EQ(2u, ui_->ShowMenu(HEADERS, ITEMS, 0, true,
442                               std::bind(&TestableScreenRecoveryUI::KeyHandler, ui_.get(),
443                                         std::placeholders::_1, std::placeholders::_2)));
444 }
445 
TEST_F(DISABLED_ScreenRecoveryUITest,ShowMenu_NotMenuOnly)446 TEST_F(DISABLED_ScreenRecoveryUITest, ShowMenu_NotMenuOnly) {
447   RETURN_IF_NO_GRAPHICS;
448 
449   ASSERT_TRUE(ui_->Init(kTestLocale));
450   ui_->SetKeyBuffer({
451       KeyCode::MAGIC,
452   });
453   ASSERT_EQ(static_cast<size_t>(kMagicAction),
454             ui_->ShowMenu(HEADERS, ITEMS, 3, false,
455                           std::bind(&TestableScreenRecoveryUI::KeyHandler, ui_.get(),
456                                     std::placeholders::_1, std::placeholders::_2)));
457 }
458 
TEST_F(DISABLED_ScreenRecoveryUITest,ShowMenu_TimedOut)459 TEST_F(DISABLED_ScreenRecoveryUITest, ShowMenu_TimedOut) {
460   RETURN_IF_NO_GRAPHICS;
461 
462   ASSERT_TRUE(ui_->Init(kTestLocale));
463   ui_->SetKeyBuffer({
464       KeyCode::TIMEOUT,
465   });
466   ASSERT_EQ(static_cast<size_t>(RecoveryUI::KeyError::TIMED_OUT),
467             ui_->ShowMenu(HEADERS, ITEMS, 3, true, nullptr));
468 }
469 
TEST_F(DISABLED_ScreenRecoveryUITest,ShowMenu_TimedOut_TextWasEverVisible)470 TEST_F(DISABLED_ScreenRecoveryUITest, ShowMenu_TimedOut_TextWasEverVisible) {
471   RETURN_IF_NO_GRAPHICS;
472 
473   ASSERT_TRUE(ui_->Init(kTestLocale));
474   ui_->ShowText(true);
475   ui_->ShowText(false);
476   ASSERT_TRUE(ui_->WasTextEverVisible());
477 
478   ui_->SetKeyBuffer({
479       KeyCode::TIMEOUT,
480       KeyCode::DOWN,
481       KeyCode::ENTER,
482   });
483   ASSERT_EQ(4u, ui_->ShowMenu(HEADERS, ITEMS, 3, true,
484                               std::bind(&TestableScreenRecoveryUI::KeyHandler, ui_.get(),
485                                         std::placeholders::_1, std::placeholders::_2)));
486 }
487 
TEST_F(DISABLED_ScreenRecoveryUITest,ShowMenuWithInterrupt)488 TEST_F(DISABLED_ScreenRecoveryUITest, ShowMenuWithInterrupt) {
489   RETURN_IF_NO_GRAPHICS;
490 
491   ASSERT_TRUE(ui_->Init(kTestLocale));
492   ui_->SetKeyBuffer({
493       KeyCode::UP,
494       KeyCode::DOWN,
495       KeyCode::UP,
496       KeyCode::DOWN,
497       KeyCode::ENTER,
498   });
499 
500   ui_->InterruptKey();
501   ASSERT_EQ(static_cast<size_t>(RecoveryUI::KeyError::INTERRUPTED),
502             ui_->ShowMenu(HEADERS, ITEMS, 3, true,
503                           std::bind(&TestableScreenRecoveryUI::KeyHandler, ui_.get(),
504                                     std::placeholders::_1, std::placeholders::_2)));
505 
506   ui_->SetKeyBuffer({
507       KeyCode::UP,
508       KeyCode::UP,
509       KeyCode::NO_OP,
510       KeyCode::NO_OP,
511       KeyCode::UP,
512       KeyCode::ENTER,
513   });
514   ASSERT_EQ(static_cast<size_t>(RecoveryUI::KeyError::INTERRUPTED),
515             ui_->ShowMenu(HEADERS, ITEMS, 0, true,
516                           std::bind(&TestableScreenRecoveryUI::KeyHandler, ui_.get(),
517                                     std::placeholders::_1, std::placeholders::_2)));
518 }
519 
TEST_F(DISABLED_ScreenRecoveryUITest,LoadAnimation)520 TEST_F(DISABLED_ScreenRecoveryUITest, LoadAnimation) {
521   RETURN_IF_NO_GRAPHICS;
522 
523   ASSERT_TRUE(ui_->Init(kTestLocale));
524   // Make a few copies of loop00000.png from testdata.
525   std::string image_data;
526   ASSERT_TRUE(android::base::ReadFileToString(testdata_dir_ + "/loop00000.png", &image_data));
527 
528   std::vector<std::string> tempfiles;
529   TemporaryDir resource_dir;
530   for (const auto& name : { "00002", "00100", "00050" }) {
531     tempfiles.push_back(android::base::StringPrintf("%s/loop%s.png", resource_dir.path, name));
532     ASSERT_TRUE(android::base::WriteStringToFile(image_data, tempfiles.back()));
533   }
534   for (const auto& name : { "00", "01" }) {
535     tempfiles.push_back(android::base::StringPrintf("%s/intro%s.png", resource_dir.path, name));
536     ASSERT_TRUE(android::base::WriteStringToFile(image_data, tempfiles.back()));
537   }
538   Paths::Get().set_resource_dir(resource_dir.path);
539 
540   ui_->LoadAnimation();
541 
542   ASSERT_EQ(2u, ui_->intro_frames_.size());
543   ASSERT_EQ(3u, ui_->loop_frames_.size());
544 
545   for (const auto& name : tempfiles) {
546     ASSERT_EQ(0, unlink(name.c_str()));
547   }
548 }
549 
TEST_F(DISABLED_ScreenRecoveryUITest,LoadAnimation_MissingAnimation)550 TEST_F(DISABLED_ScreenRecoveryUITest, LoadAnimation_MissingAnimation) {
551   RETURN_IF_NO_GRAPHICS;
552 
553   ASSERT_TRUE(ui_->Init(kTestLocale));
554   // We need a dir that doesn't contain any animation. However, using TemporaryDir will give
555   // leftovers since this is a death test where TemporaryDir::~TemporaryDir() won't be called.
556   Paths::Get().set_resource_dir("/proc/self");
557 
558   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
559   ASSERT_EXIT(ui_->LoadAnimation(), ::testing::KilledBySignal(SIGABRT), "");
560 }
561 
562 #undef RETURN_IF_NO_GRAPHICS
563