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/flashd_utils.h" 24 #include "partition.h" 25 #include "fs_manager/mount.h" 26 #include "log/log.h" 27 #include "securec.h" 28 #include "updater/updater_const.h" 29 #include "misc_info/misc_info.h" 30 31 using namespace std; 32 using namespace Flashd; 33 using namespace testing::ext; 34 35 namespace { 36 37 class FLashServiceUnitTest : public testing::Test { 38 public: FLashServiceUnitTest()39 FLashServiceUnitTest() 40 { 41 std::cout<<"FLashServiceUnitTest()"; 42 InitUpdaterLogger("FLASHD", TMP_LOG, TMP_STAGE_LOG, TMP_ERROR_CODE_PATH); 43 } ~FLashServiceUnitTest()44 ~FLashServiceUnitTest() {} 45 SetUpTestCase(void)46 static void SetUpTestCase(void) {} TearDownTestCase(void)47 static void TearDownTestCase(void) {} SetUp()48 void SetUp() {} TearDown()49 void TearDown() {} TestBody()50 void TestBody() {} 51 std::unique_ptr<Flashd::Commander> commander_ = nullptr; 52 }; 53 54 HWTEST_F(FLashServiceUnitTest, FormatCommanderDoCommand, TestSize.Level1) 55 { 56 LoadFstab(); 57 std::unique_ptr<Flashd::Commander> commander = nullptr; 58 Flashd::UpdaterState ret = UpdaterState::DOING; __anona39d9bd60202(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 59 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) { 60 ret = state; 61 }; 62 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_FORMAT_PARTITION, callbackFail); 63 EXPECT_NE(nullptr, commander); 64 std::string cmdstr = "format data"; 65 uint8_t *payload = nullptr; 66 int payloadSize = cmdstr.size() + 1; 67 commander->DoCommand(payload, payloadSize); 68 EXPECT_EQ(UpdaterState::FAIL, ret); 69 70 payload = reinterpret_cast<uint8_t*>(cmdstr.data()); 71 payloadSize = 0; 72 commander->DoCommand(payload, payloadSize); 73 EXPECT_EQ(UpdaterState::FAIL, ret); 74 75 cmdstr = "format"; 76 payload = reinterpret_cast<uint8_t*>(cmdstr.data()); 77 payloadSize = cmdstr.size(); 78 commander->DoCommand(payload, payloadSize); 79 EXPECT_EQ(UpdaterState::FAIL, ret); 80 81 cmdstr = "format databack"; 82 payload = reinterpret_cast<uint8_t*>(cmdstr.data()); 83 payloadSize = cmdstr.size() + 1; 84 commander->DoCommand(payload, payloadSize); 85 EXPECT_EQ(UpdaterState::FAIL, ret); 86 } 87 88 HWTEST_F(FLashServiceUnitTest, UpdateCommanderDoCommand, TestSize.Level1) 89 { 90 LoadFstab(); 91 std::unique_ptr<Flashd::Commander> commander = nullptr; 92 Flashd::UpdaterState ret = UpdaterState::DOING; __anona39d9bd60302(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 93 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) { 94 ret = state; 95 }; 96 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_UPDATE_SYSTEM, callbackFail); 97 EXPECT_NE(nullptr, commander); 98 std::string cmdstr = "test.zip"; 99 uint8_t *payload = nullptr; 100 int payloadSize = cmdstr.size(); 101 commander->DoCommand(payload, payloadSize); 102 EXPECT_EQ(UpdaterState::FAIL, ret); 103 104 payload = reinterpret_cast<uint8_t*>(cmdstr.data()); 105 payloadSize = 0; 106 commander->DoCommand(payload, payloadSize); 107 EXPECT_EQ(UpdaterState::FAIL, ret); 108 109 cmdstr = "update 123.zip"; 110 payload = reinterpret_cast<uint8_t*>(cmdstr.data()); 111 payloadSize = cmdstr.size() + 1; 112 commander->DoCommand(payload, payloadSize); 113 EXPECT_EQ(UpdaterState::FAIL, ret); 114 115 cmdstr = "format databack"; 116 payload = reinterpret_cast<uint8_t*>(cmdstr.data()); 117 payloadSize = cmdstr.size() + 1; 118 commander->DoCommand(payload, payloadSize); 119 EXPECT_EQ(UpdaterState::FAIL, ret); 120 } 121 122 HWTEST_F(FLashServiceUnitTest, EraseCommanderDoCommand, TestSize.Level1) 123 { 124 LoadFstab(); 125 std::unique_ptr<Flashd::Commander> commander = nullptr; 126 Flashd::UpdaterState ret = UpdaterState::DOING; __anona39d9bd60402(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 127 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) { 128 ret = state; 129 }; 130 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_ERASE_PARTITION, callbackFail); 131 EXPECT_NE(nullptr, commander); 132 std::string cmdstr = "erase misc"; 133 uint8_t *payload = nullptr; 134 int payloadSize = cmdstr.size() + 1; 135 commander->DoCommand(payload, payloadSize); 136 EXPECT_EQ(UpdaterState::FAIL, ret); 137 138 payload = reinterpret_cast<uint8_t*>(cmdstr.data()); 139 payloadSize = 0; 140 commander->DoCommand(payload, payloadSize); 141 EXPECT_EQ(UpdaterState::FAIL, ret); 142 143 cmdstr = "erase"; 144 payload = reinterpret_cast<uint8_t*>(cmdstr.data()); 145 payloadSize = cmdstr.size(); 146 commander->DoCommand(payload, payloadSize); 147 EXPECT_EQ(UpdaterState::FAIL, ret); 148 149 cmdstr = "erase misctest"; 150 payload = reinterpret_cast<uint8_t*>(cmdstr.data()); 151 payloadSize = cmdstr.size() + 1; 152 commander->DoCommand(payload, payloadSize); 153 EXPECT_EQ(UpdaterState::FAIL, ret); 154 } 155 156 HWTEST_F(FLashServiceUnitTest, FlashCommanderDoCommand, TestSize.Level1) 157 { 158 LoadFstab(); 159 std::unique_ptr<Flashd::Commander> commander = nullptr; 160 Flashd::UpdaterState ret = UpdaterState::DOING; __anona39d9bd60502(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 161 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) { 162 ret = state; 163 }; 164 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_FLASH_PARTITION, callbackFail); 165 EXPECT_NE(nullptr, commander); 166 std::string cmdstr = "flash updater updater.img"; 167 uint8_t *payload = nullptr; 168 int payloadSize = cmdstr.size() + 1; 169 commander->DoCommand(payload, payloadSize); 170 EXPECT_EQ(UpdaterState::FAIL, ret); 171 172 payload = reinterpret_cast<uint8_t*>(cmdstr.data()); 173 payloadSize = 0; 174 commander->DoCommand(payload, payloadSize); 175 EXPECT_EQ(UpdaterState::FAIL, ret); 176 177 cmdstr = "flash updatertest updater.img"; 178 payload = reinterpret_cast<uint8_t*>(cmdstr.data()); 179 payloadSize = cmdstr.size() + 1; 180 commander->DoCommand(payload, payloadSize); 181 EXPECT_EQ(UpdaterState::SUCCESS, ret); 182 } 183 184 HWTEST_F(FLashServiceUnitTest, GetFileName, TestSize.Level1) 185 { 186 std::string testStr = "data/test/test.zip"; 187 std::string res = GetFileName(testStr); 188 EXPECT_EQ("test.zip", res); 189 190 testStr = "D:\\test\\test.zip"; 191 res = GetFileName(testStr); 192 EXPECT_EQ("test.zip", res); 193 194 testStr = "test.zip"; 195 res = GetFileName(testStr); 196 EXPECT_EQ("", res); 197 } 198 199 HWTEST_F(FLashServiceUnitTest, GetWriter, TestSize.Level1) 200 { 201 std::string partName = ""; 202 std::string temp = ""; 203 uint8_t *buffer = reinterpret_cast<uint8_t*>(temp.data()); 204 int bufferSize = partName.size(); 205 std::unique_ptr<FlashdWriter> writer = FlashdImageWriter::GetInstance().GetWriter(partName, buffer, bufferSize); 206 if (writer == nullptr) { 207 std::cout << "writer is nullptr"; 208 } 209 EXPECT_NE(nullptr, writer); 210 211 partName = "test"; 212 writer = FlashdImageWriter::GetInstance().GetWriter(partName, buffer, bufferSize); 213 EXPECT_NE(nullptr, writer); 214 } 215 216 HWTEST_F(FLashServiceUnitTest, PartitionDoErase, TestSize.Level1) 217 { 218 std::string partitionName = "test"; 219 Partition partTest(partitionName); 220 int ret = partTest.DoErase(); 221 EXPECT_EQ(FLASHING_OPEN_PART_ERROR, ret); 222 } 223 224 HWTEST_F(FLashServiceUnitTest, PartitionDoFormat, TestSize.Level1) 225 { 226 std::string partitionName = "test"; 227 Partition partTest(partitionName); 228 int ret = partTest.DoFormat(); 229 EXPECT_EQ(-1, ret); 230 } 231 232 HWTEST_F(FLashServiceUnitTest, PartitionDoFlash, TestSize.Level1) 233 { 234 std::string temp = "test.img"; 235 uint8_t *buffer = reinterpret_cast<uint8_t*>(temp.data()); 236 int bufferSize = 0; 237 std::unique_ptr<FlashdWriter> writer = nullptr; 238 std::string partName = "updater"; 239 std::string cmdstr = "flash updater updater.img"; 240 uint8_t *payload = reinterpret_cast<uint8_t*>(cmdstr.data()); 241 int payloadSize = cmdstr.size(); 242 std::unique_ptr<Partition> partition_ = std::make_unique<Partition>(partName, std::move(writer)); 243 EXPECT_NE(nullptr, partition_); 244 int ret = partition_->DoFlash(payload, payloadSize); 245 EXPECT_EQ(FLASHING_ARG_INVALID, ret); 246 writer = FlashdImageWriter::GetInstance().GetWriter(partName, buffer, bufferSize); 247 EXPECT_NE(nullptr, partition_); 248 249 payloadSize = 0; 250 partition_ = std::make_unique<Partition>(partName, std::move(writer)); 251 ret = partition_->DoFlash(payload, payloadSize); 252 EXPECT_EQ(FLASHING_ARG_INVALID, ret); 253 payloadSize = cmdstr.size(); 254 payload = nullptr; 255 ret = partition_->DoFlash(payload, payloadSize); 256 EXPECT_EQ(FLASHING_ARG_INVALID, ret); 257 } 258 259 HWTEST_F(FLashServiceUnitTest, UpdateProgress, TestSize.Level1) 260 { 261 std::string partitionName = "test"; 262 Partition partTest(partitionName); 263 int ret = partTest.DoFormat(); 264 EXPECT_EQ(-1, ret); 265 } 266 267 HWTEST_F(FLashServiceUnitTest, UpdateCommanderDoCommand2, TestSize.Level1) 268 { 269 LoadFstab(); 270 std::unique_ptr<Flashd::Commander> commander = nullptr; 271 Flashd::UpdaterState ret = UpdaterState::DOING; __anona39d9bd60602(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 272 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) { 273 ret = state; 274 }; 275 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_UPDATE_SYSTEM, callbackFail); 276 EXPECT_NE(nullptr, commander); 277 std::string cmd = "update"; 278 size_t size = cmd.size(); 279 commander->DoCommand(cmd, size); 280 EXPECT_EQ(UpdaterState::FAIL, ret); 281 282 cmd = ""; 283 size = cmd.size(); 284 commander->DoCommand(cmd, size); 285 EXPECT_EQ(UpdaterState::FAIL, ret); 286 287 cmd = "update test.zip"; 288 commander->DoCommand(cmd, size); 289 EXPECT_EQ(UpdaterState::FAIL, ret); 290 291 LoadSpecificFstab("/data/updater/updater/etc/fstab.ut.updater"); 292 cmd = "update test.zip"; 293 commander->DoCommand(cmd, size); 294 EXPECT_EQ(UpdaterState::FAIL, ret); 295 } 296 297 HWTEST_F(FLashServiceUnitTest, FlashCommanderDoCommand2, TestSize.Level1) 298 { 299 LoadFstab(); 300 std::unique_ptr<Flashd::Commander> commander = nullptr; 301 Flashd::UpdaterState ret = UpdaterState::DOING; __anona39d9bd60702(Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) 302 auto callbackFail = [&ret](Flashd::CmdType type, Flashd::UpdaterState state, const std::string &msg) { 303 ret = state; 304 }; 305 commander = Flashd::CommanderFactory::GetInstance().CreateCommander(Hdc::CMDSTR_FLASH_PARTITION, callbackFail); 306 EXPECT_NE(nullptr, commander); 307 std::string cmd = "flash"; 308 size_t size = cmd.size(); 309 commander->DoCommand(cmd, size); 310 EXPECT_EQ(UpdaterState::FAIL, ret); 311 312 cmd = "flash test test.img"; 313 size = 20; 314 commander->DoCommand(cmd, size); 315 EXPECT_EQ(UpdaterState::FAIL, ret); 316 } 317 318 } // namespace