1 /*
2 * Copyright (c) 2022 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 <fcntl.h>
17 #include <gtest/gtest.h>
18 #include <memory>
19 #include <sys/ioctl.h>
20 #include "common/flashd_define.h"
21 #include "daemon/format_commander.h"
22 #include "daemon/commander_factory.h"
23 #include "daemon/daemon_updater.h"
24 #include "daemon/flashd_utils.h"
25 #include "hdi/client/update_hdi_client.h"
26 #include "partition.h"
27 #include "fs_manager/mount.h"
28 #include "log/log.h"
29 #include "securec.h"
30 #include "updater/updater_const.h"
31 #include "misc_info/misc_info.h"
32
33 using namespace std;
34 using namespace Flashd;
35 using namespace testing::ext;
36 using namespace Hdc;
37
38 namespace {
39
40 class FLashServiceUnitTest : public testing::Test {
41 public:
FLashServiceUnitTest()42 FLashServiceUnitTest()
43 {
44 std::cout<<"FLashServiceUnitTest()";
45 }
~FLashServiceUnitTest()46 ~FLashServiceUnitTest() {}
47
SetUpTestCase(void)48 static void SetUpTestCase(void)
49 {
50 InitUpdaterLogger("FLASHD", TMP_LOG, TMP_STAGE_LOG, TMP_ERROR_CODE_PATH);
51 }
TearDownTestCase(void)52 static void TearDownTestCase(void) {}
SetUp()53 void SetUp() {}
TearDown()54 void TearDown() {}
TestBody()55 void TestBody() {}
56 std::unique_ptr<Flashd::Commander> commander_ = nullptr;
57 };
58
59 HWTEST_F(FLashServiceUnitTest, FormatCommanderDoCommand, TestSize.Level1)
60 {
61 LoadFstab();
62 std::unique_ptr<Flashd::Commander> commander = nullptr;
63 Flashd::UpdaterState ret = UpdaterState::DOING;
__anon65fe650b0202(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 64 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
65 ret = state;
66 };
67 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_FORMAT_PARTITION, callbackFail);
68 EXPECT_NE(nullptr, commander);
69 std::string cmdstr = "format data";
70 uint8_t *payload = nullptr;
71 int payloadSize = cmdstr.size() + 1;
72 commander->DoCommand(payload, payloadSize);
73 EXPECT_EQ(UpdaterState::FAIL, ret);
74
75 payload = reinterpret_cast<uint8_t*>(cmdstr.data());
76 payloadSize = 0;
77 commander->DoCommand(payload, payloadSize);
78 EXPECT_EQ(UpdaterState::FAIL, ret);
79
80 cmdstr = "format";
81 payload = reinterpret_cast<uint8_t*>(cmdstr.data());
82 payloadSize = cmdstr.size();
83 commander->DoCommand(payload, payloadSize);
84 EXPECT_EQ(UpdaterState::FAIL, ret);
85
86 cmdstr = "format databack";
87 payload = reinterpret_cast<uint8_t*>(cmdstr.data());
88 payloadSize = cmdstr.size() + 1;
89 commander->DoCommand(payload, payloadSize);
90 EXPECT_EQ(UpdaterState::FAIL, ret);
91 }
92
93 HWTEST_F(FLashServiceUnitTest, UpdateCommanderDoCommand, TestSize.Level1)
94 {
95 LoadFstab();
96 std::unique_ptr<Flashd::Commander> commander = nullptr;
97 Flashd::UpdaterState ret = UpdaterState::DOING;
__anon65fe650b0302(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 98 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
99 ret = state;
100 };
101 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_UPDATE_SYSTEM, callbackFail);
102 EXPECT_NE(nullptr, commander);
103 std::string cmdstr = "test.zip";
104 uint8_t *payload = nullptr;
105 int payloadSize = cmdstr.size();
106 commander->DoCommand(payload, payloadSize);
107 EXPECT_EQ(UpdaterState::FAIL, ret);
108
109 payload = reinterpret_cast<uint8_t*>(cmdstr.data());
110 payloadSize = 0;
111 commander->DoCommand(payload, payloadSize);
112 EXPECT_EQ(UpdaterState::FAIL, ret);
113
114 cmdstr = "update 123.zip";
115 payload = reinterpret_cast<uint8_t*>(cmdstr.data());
116 payloadSize = cmdstr.size() + 1;
117 commander->DoCommand(payload, payloadSize);
118 EXPECT_EQ(UpdaterState::FAIL, ret);
119
120 cmdstr = "format databack";
121 payload = reinterpret_cast<uint8_t*>(cmdstr.data());
122 payloadSize = cmdstr.size() + 1;
123 commander->DoCommand(payload, payloadSize);
124 EXPECT_EQ(UpdaterState::FAIL, ret);
125 }
126
127 HWTEST_F(FLashServiceUnitTest, EraseCommanderDoCommand, TestSize.Level1)
128 {
129 LoadFstab();
130 std::unique_ptr<Flashd::Commander> commander = nullptr;
131 Flashd::UpdaterState ret = UpdaterState::DOING;
__anon65fe650b0402(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 132 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
133 ret = state;
134 };
135 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_ERASE_PARTITION, callbackFail);
136 EXPECT_NE(nullptr, commander);
137 std::string cmdstr = "erase misc";
138 uint8_t *payload = nullptr;
139 int payloadSize = cmdstr.size() + 1;
140 commander->DoCommand(payload, payloadSize);
141 EXPECT_EQ(UpdaterState::FAIL, ret);
142
143 payload = reinterpret_cast<uint8_t*>(cmdstr.data());
144 payloadSize = 0;
145 commander->DoCommand(payload, payloadSize);
146 EXPECT_EQ(UpdaterState::FAIL, ret);
147
148 cmdstr = "erase";
149 payload = reinterpret_cast<uint8_t*>(cmdstr.data());
150 payloadSize = cmdstr.size();
151 commander->DoCommand(payload, payloadSize);
152 EXPECT_EQ(UpdaterState::FAIL, ret);
153
154 cmdstr = "erase misctest";
155 payload = reinterpret_cast<uint8_t*>(cmdstr.data());
156 payloadSize = cmdstr.size() + 1;
157 commander->DoCommand(payload, payloadSize);
158 EXPECT_EQ(UpdaterState::FAIL, ret);
159 }
160
161 HWTEST_F(FLashServiceUnitTest, FlashCommanderDoCommand, TestSize.Level1)
162 {
163 LoadFstab();
164 std::unique_ptr<Flashd::Commander> commander = nullptr;
165 Flashd::UpdaterState ret = UpdaterState::DOING;
__anon65fe650b0502(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 166 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
167 ret = state;
168 };
169 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_FLASH_PARTITION, callbackFail);
170 EXPECT_NE(nullptr, commander);
171 std::string cmdstr = "flash updater updater.img";
172 uint8_t *payload = nullptr;
173 int payloadSize = cmdstr.size() + 1;
174 commander->DoCommand(payload, payloadSize);
175 EXPECT_EQ(UpdaterState::FAIL, ret);
176
177 payload = reinterpret_cast<uint8_t*>(cmdstr.data());
178 payloadSize = 0;
179 commander->DoCommand(payload, payloadSize);
180 EXPECT_EQ(UpdaterState::FAIL, ret);
181
182 cmdstr = "flash updatertest updater.img";
183 payload = reinterpret_cast<uint8_t*>(cmdstr.data());
184 payloadSize = cmdstr.size() + 1;
185 commander->DoCommand(payload, payloadSize);
186 EXPECT_EQ(UpdaterState::SUCCESS, ret);
187 }
188
189 HWTEST_F(FLashServiceUnitTest, GetFileName, TestSize.Level1)
190 {
191 std::string testStr = "data/test/test.zip";
192 std::string res = GetFileName(testStr);
193 EXPECT_EQ("test.zip", res);
194
195 testStr = "D:\\test\\test.zip";
196 res = GetFileName(testStr);
197 EXPECT_EQ("test.zip", res);
198
199 testStr = "test.zip";
200 res = GetFileName(testStr);
201 EXPECT_EQ("", res);
202 }
203
204 HWTEST_F(FLashServiceUnitTest, GetWriter, TestSize.Level1)
205 {
206 std::string partName = "";
207 std::string temp = "";
208 uint8_t *buffer = reinterpret_cast<uint8_t*>(temp.data());
209 int bufferSize = partName.size();
210 std::unique_ptr<FlashdWriter> writer = FlashdImageWriter::GetInstance().GetWriter(partName, buffer, bufferSize);
211 if (writer == nullptr) {
212 std::cout << "writer is nullptr";
213 }
214 EXPECT_NE(nullptr, writer);
215
216 partName = "test";
217 writer = FlashdImageWriter::GetInstance().GetWriter(partName, buffer, bufferSize);
218 EXPECT_NE(nullptr, writer);
219
220 int ret = writer->Write(partName, reinterpret_cast<uint8_t*>(temp.data()), temp.size());
221 EXPECT_EQ(-1, ret);
222 }
223
224 HWTEST_F(FLashServiceUnitTest, FlashdWriterRawWriter, TestSize.Level1)
225 {
226 std::string partName = "updater_ramdisk.img";
227 std::string temp = "";
228 std::unique_ptr<FlashdWriterRaw> writer = std::make_unique<FlashdWriterRaw>();
229 if (writer == nullptr) {
230 std::cout << "writer is nullptr";
231 }
232 EXPECT_NE(nullptr, writer);
233
234 int ret = writer->Write(partName, reinterpret_cast<uint8_t*>(temp.data()), temp.size());
235 EXPECT_EQ(-1, ret);
236 }
237
238 HWTEST_F(FLashServiceUnitTest, RegisterUserWriter, TestSize.Level0)
239 {
240 std::string partName = "";
241 std::string temp = "";
242 uint8_t *buffer = reinterpret_cast<uint8_t*>(temp.data());
243 int bufferSize = partName.size();
244 std::unique_ptr<FlashdWriter> writer = FlashdImageWriter::GetInstance().GetWriter(partName, buffer, bufferSize);
245 if (writer == nullptr) {
246 std::cout << "writer is nullptr";
247 }
248 EXPECT_NE(nullptr, writer);
249 LOG(INFO) << "RegisterUserWriter finish";
250 }
251
252 HWTEST_F(FLashServiceUnitTest, UpdateCommanderPostCommand, TestSize.Level0)
253 {
254 LoadFstab();
255 std::unique_ptr<Flashd::Commander> commander = nullptr;
256 Flashd::UpdaterState ret = UpdaterState::DOING;
__anon65fe650b0602(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 257 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
258 ret = state;
259 };
260 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_UPDATE_SYSTEM, callbackFail);
261 EXPECT_NE(nullptr, commander);
262 commander->PostCommand();
263 EXPECT_NE(nullptr, commander);
264 LOG(INFO) << "UpdateCommanderPostCommand finish";
265 }
266
267 HWTEST_F(FLashServiceUnitTest, PartitionGetBlockDeviceSize, TestSize.Level1)
268 {
269 std::string partitionName = "test";
270 Partition partTest(partitionName);
271 int fd = 1;
272 int ret = partTest.GetBlockDeviceSize(fd);
273 LOG(INFO) << "PartitionGetBlockDeviceSize ret: " << ret;
274 EXPECT_EQ(0, ret);
275 }
276
IsTestImg(const std::string & partition,const uint8_t * data,size_t len)277 bool IsTestImg(const std::string &partition, const uint8_t *data, size_t len)
278 {
279 if (data == nullptr) {
280 return false;
281 }
282 std::cout << "IsTestImg " << partition << " len " << len;
283 return true;
284 }
285
GetTestWriter()286 std::unique_ptr<FlashdWriter> GetTestWriter()
287 {
288 return std::make_unique<FlashdWriterRaw>();
289 }
290
291 HWTEST_F(FLashServiceUnitTest, PartitionDoErase, TestSize.Level1)
292 {
293 std::string partitionName = "test";
294 Partition partTest(partitionName);
295 int ret = partTest.DoErase();
296 EXPECT_EQ(FLASHING_OPEN_PART_ERROR, ret);
297 }
298
299 HWTEST_F(FLashServiceUnitTest, PartitionDoFormat, TestSize.Level1)
300 {
301 std::string partitionName = "test";
302 Partition partTest(partitionName);
303 int ret = partTest.DoFormat();
304 EXPECT_EQ(-1, ret);
305 }
306
307 HWTEST_F(FLashServiceUnitTest, PartitionDoFlash, TestSize.Level1)
308 {
309 std::string temp = "test.img";
310 uint8_t *buffer = reinterpret_cast<uint8_t*>(temp.data());
311 int bufferSize = 0;
312 std::unique_ptr<FlashdWriter> writer = nullptr;
313 std::string partName = "updater";
314 std::string cmdstr = "flash updater updater.img";
315 uint8_t *payload = reinterpret_cast<uint8_t*>(cmdstr.data());
316 int payloadSize = cmdstr.size();
317 std::unique_ptr<Partition> partition_ = std::make_unique<Partition>(partName, std::move(writer));
318 EXPECT_NE(nullptr, partition_);
319 int ret = partition_->DoFlash(payload, payloadSize);
320 EXPECT_EQ(FLASHING_ARG_INVALID, ret);
321 writer = FlashdImageWriter::GetInstance().GetWriter(partName, buffer, bufferSize);
322 EXPECT_NE(nullptr, partition_);
323
324 payloadSize = 0;
325 partition_ = std::make_unique<Partition>(partName, std::move(writer));
326 ret = partition_->DoFlash(payload, payloadSize);
327 EXPECT_EQ(FLASHING_ARG_INVALID, ret);
328 payloadSize = cmdstr.size();
329 payload = nullptr;
330 ret = partition_->DoFlash(payload, payloadSize);
331 EXPECT_EQ(FLASHING_ARG_INVALID, ret);
332 }
333
334 HWTEST_F(FLashServiceUnitTest, UpdateProgress, TestSize.Level1)
335 {
336 std::string partitionName = "test";
337 Partition partTest(partitionName);
338 int ret = partTest.DoFormat();
339 EXPECT_EQ(-1, ret);
340 }
341
342 HWTEST_F(FLashServiceUnitTest, UpdateCommanderDoCommand2, TestSize.Level1)
343 {
344 LoadFstab();
345 std::unique_ptr<Flashd::Commander> commander = nullptr;
346 Flashd::UpdaterState ret = UpdaterState::DOING;
__anon65fe650b0702(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 347 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
348 ret = state;
349 };
350 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_UPDATE_SYSTEM, callbackFail);
351 EXPECT_NE(nullptr, commander);
352 std::string cmd = "update";
353 size_t size = cmd.size();
354 commander->DoCommand(cmd, size);
355 EXPECT_EQ(UpdaterState::FAIL, ret);
356
357 cmd = "";
358 size = cmd.size();
359 commander->DoCommand(cmd, size);
360 EXPECT_EQ(UpdaterState::FAIL, ret);
361
362 cmd = "update test.zip";
363 commander->DoCommand(cmd, size);
364 EXPECT_EQ(UpdaterState::FAIL, ret);
365
366 LoadSpecificFstab("/data/updater/updater/etc/fstab.ut.updater");
367 cmd = "update test.zip";
368 commander->DoCommand(cmd, size);
369 EXPECT_EQ(UpdaterState::FAIL, ret);
370 }
371
372 HWTEST_F(FLashServiceUnitTest, FlashCommanderDoCommand2, TestSize.Level1)
373 {
374 LoadFstab();
375 std::unique_ptr<Flashd::Commander> commander = nullptr;
376 Flashd::UpdaterState ret = UpdaterState::DOING;
__anon65fe650b0802(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 377 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
378 ret = state;
379 };
380 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_FLASH_PARTITION, callbackFail);
381 EXPECT_NE(nullptr, commander);
382 std::string cmd = "flash";
383 size_t size = cmd.size();
384 commander->DoCommand(cmd, size);
385 EXPECT_EQ(UpdaterState::FAIL, ret);
386
387 cmd = "flash test test.img";
388 size = 20;
389 commander->DoCommand(cmd, size);
390 EXPECT_EQ(UpdaterState::FAIL, ret);
391 }
392
393 HWTEST_F(FLashServiceUnitTest, PartitionEraseSuccessTest, TestSize.Level1)
394 {
395 std::string partitionName = "misc";
396 Partition partTest(partitionName);
397 int ret = partTest.DoErase();
398 EXPECT_EQ(0, ret);
399
400 partitionName = "system";
401 ret = partTest.DoErase();
402 EXPECT_EQ(0, ret);
403
404 partitionName = "sys_prod";
405 ret = partTest.DoErase();
406 EXPECT_EQ(0, ret);
407
408 partitionName = "vendor";
409 ret = partTest.DoErase();
410 EXPECT_EQ(0, ret);
411
412 partitionName = "userdata";
413 ret = partTest.DoErase();
414 EXPECT_EQ(0, ret);
415 }
416
417 HWTEST_F(FLashServiceUnitTest, DoEraseCommanderSuccessTest, TestSize.Level1)
418 {
419 LoadFstab();
420 std::unique_ptr<Flashd::Commander> commander = nullptr;
421 Flashd::UpdaterState ret = UpdaterState::DOING;
__anon65fe650b0902(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 422 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
423 ret = state;
424 };
425 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_ERASE_PARTITION, callbackFail);
426 EXPECT_NE(nullptr, commander);
427 std::string cmdstr = "erase misc";
428 uint8_t *payload = reinterpret_cast<uint8_t*>(cmdstr.data());
429 int payloadSize = cmdstr.size() + 1;
430 commander->DoCommand(payload, payloadSize);
431 EXPECT_EQ(UpdaterState::SUCCESS, ret);
432
433 cmdstr = "erase vendor";
434 payload = reinterpret_cast<uint8_t*>(cmdstr.data());
435 payloadSize = cmdstr.size() + 1;
436 commander->DoCommand(payload, payloadSize);
437 EXPECT_EQ(UpdaterState::SUCCESS, ret);
438
439 cmdstr = "erase userdata";
440 payload = reinterpret_cast<uint8_t*>(cmdstr.data());
441 payloadSize = cmdstr.size() + 1;
442 commander->DoCommand(payload, payloadSize);
443 EXPECT_EQ(UpdaterState::SUCCESS, ret);
444 }
445
446 HWTEST_F(FLashServiceUnitTest, DoFlashSuccessTest, TestSize.Level1)
447 {
448 LoadFstab();
449 std::unique_ptr<Flashd::Commander> commander = nullptr;
450 Flashd::UpdaterState ret = UpdaterState::DOING;
__anon65fe650b0a02(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 451 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
452 ret = state;
453 };
454 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_FLASH_PARTITION, callbackFail);
455 EXPECT_NE(nullptr, commander);
456 std::string cmdstr = "flash updatertest updater.fd";
457 uint8_t *payload = reinterpret_cast<uint8_t*>(cmdstr.data());
458 int payloadSize = cmdstr.size() + 1;
459 commander->DoCommand(payload, payloadSize);
460 EXPECT_EQ(UpdaterState::SUCCESS, ret);
461
462 cmdstr = "flash test test.img";
463 payload = reinterpret_cast<uint8_t*>(cmdstr.data());
464 payloadSize = cmdstr.size() + 1;
465 commander->DoCommand(payload, payloadSize);
466 EXPECT_EQ(UpdaterState::SUCCESS, ret);
467 }
468
469 HWTEST_F(FLashServiceUnitTest, CreateCommanderTest, TestSize.Level1)
470 {
471 std::unique_ptr<Flashd::Commander> commander = nullptr;
472 Flashd::UpdaterState ret = UpdaterState::DOING;
__anon65fe650b0b02(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 473 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) {
474 ret = state;
475 };
476 std::string cmd = "TEST";
477 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(cmd, callbackFail);
478 EXPECT_EQ(nullptr, commander);
479
480 cmd = "";
481 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(cmd, callbackFail);
482 EXPECT_EQ(nullptr, commander);
483
484 cmd = Hdc::CMDSTR_FLASH_PARTITION;
485 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(cmd, callbackFail);
486 EXPECT_NE(nullptr, commander);
487
488 cmd = Hdc::CMDSTR_FORMAT_PARTITION;
489 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(cmd, callbackFail);
490 EXPECT_NE(nullptr, commander);
491
492 cmd = Hdc::CMDSTR_ERASE_PARTITION;
493 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(cmd, callbackFail);
494 EXPECT_NE(nullptr, commander);
495 }
496
497 HWTEST_F(FLashServiceUnitTest, GetLockStatusTest, TestSize.Level1)
498 {
499 bool isLocked = true;
500 if (auto ret = Updater::UpdateHdiClient::GetInstance().GetLockStatus(isLocked); ret != 0) {
501 std::cout << "get lock failed";
502 }
503 EXPECT_EQ(isLocked, false);
504 }
505
506 HWTEST_F(FLashServiceUnitTest, CommandDispatchrTest, TestSize.Level1)
507 {
508 HTaskInfo hTaskInfo = nullptr;
509 std::shared_ptr<TaskInformation> task = std::make_shared<TaskInformation>();
510 if (task == nullptr) {
511 return;
512 }
513 hTaskInfo = task.get();
514 hTaskInfo->channelId = 1;
515 hTaskInfo->sessionId = 0;
516 hTaskInfo->runLoop = uv_default_loop();
517 hTaskInfo->serverOrDaemon = 0;
518 hTaskInfo->ownerSessionClass = nullptr;
519 std::string testString = "x";
520 std::unique_ptr<DaemonUpdater> testDaemonUpdater = std::make_unique<DaemonUpdater>(hTaskInfo);
521 bool ret = testDaemonUpdater->CommandDispatch(CMD_UPDATER_UPDATE_INIT,
522 reinterpret_cast<uint8_t *>(const_cast<char*>(testString.c_str())), 1);
523 EXPECT_EQ(ret, false);
524 ret = testDaemonUpdater->CommandDispatch(CMD_UPDATER_DATA,
525 reinterpret_cast<uint8_t *>(const_cast<char*>(testString.c_str())), 1);
526 EXPECT_EQ(ret, true);
527 ret = testDaemonUpdater->CommandDispatch(CMD_UPDATER_CHECK,
528 reinterpret_cast<uint8_t *>(const_cast<char*>(testString.c_str())), 100); // 100 : test number
529 EXPECT_EQ(ret, true);
530 ret = testDaemonUpdater->CommandDispatch(CMD_UPDATER_DATA,
531 reinterpret_cast<uint8_t *>(const_cast<char*>(testString.c_str())), 1);
532 EXPECT_EQ(ret, true);
533 ret = testDaemonUpdater->CommandDispatch(CMD_UPDATER_ERASE,
534 reinterpret_cast<uint8_t *>(const_cast<char*>(testString.c_str())), 1);
535 EXPECT_EQ(ret, true);
536 ret = testDaemonUpdater->CommandDispatch(CMD_UPDATER_FORMAT,
537 reinterpret_cast<uint8_t *>(const_cast<char*>(testString.c_str())), 1);
538 EXPECT_EQ(ret, true);
539 }
540 } // namespace
541