1 /* 2 * Copyright (c) 2023 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 "hdf_log.h" 17 #include "idevmgr_hdi.h" 18 #include "v1_0/ipartition_slot.h" 19 #include <gtest/gtest.h> 20 #include <osal_mem.h> 21 #include <unistd.h> 22 23 using namespace testing; 24 using namespace testing::ext; 25 using namespace OHOS::HDI::Partitionslot::V1_0; 26 using OHOS::HDI::DeviceManager::V1_0::IDeviceManager; 27 28 class StartupPartitionSlotTestAdditional : public testing::Test { 29 public: SetUpTestCase()30 static void SetUpTestCase() 31 { 32 auto devmgr = IDeviceManager::Get(); 33 if (devmgr != nullptr) { 34 devmgr->LoadDevice("partition_slot_service"); 35 } else { 36 std::cout << "Get devmgr failed" << std::endl; 37 } 38 } TearDownTestCase()39 static void TearDownTestCase() 40 { 41 auto devmgr = IDeviceManager::Get(); 42 if (devmgr != nullptr) { 43 devmgr->UnloadDevice("partition_slot_service"); 44 } else { 45 std::cout << "Get devmgr failed" << std::endl; 46 } 47 } SetUp()48 void SetUp() {} TearDown()49 void TearDown() {} 50 }; 51 52 /** 53 * @tc.number: SUB_Startup_PartitionSlot_GetCurrentSlot_0100 54 * @tc.name: testPartitionSlotGetCurrentSlot001 55 * @tc.desc: GetCurrentSlot, numOfSlots is 1, currentSlo is 0 56 */ 57 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotGetCurrentSlot001, Function | MediumTest | Level1) 58 { 59 std::cout << "begin get currentslot by service" << std::endl; 60 int numOfSlots = 1; 61 int currentSlot = 0; 62 for (int i = 0; i < 100; i++) { 63 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 64 ASSERT_TRUE(partitionslot != nullptr); 65 ASSERT_TRUE(partitionslot->GetCurrentSlot(currentSlot, numOfSlots) == 0); 66 } 67 } 68 69 /** 70 * @tc.number: SUB_Startup_PartitionSlot_GetCurrentSlot_0200 71 * @tc.name: testPartitionSlotGetCurrentSlot002 72 * @tc.desc: GetCurrentSlot, numOfSlots is 0, currentSlo is 1 73 */ 74 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotGetCurrentSlot002, Function | MediumTest | Level1) 75 { 76 std::cout << "begin get currentslot by service" << std::endl; 77 int numOfSlots = 0; 78 int currentSlot = 1; 79 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 80 ASSERT_TRUE(partitionslot != nullptr); 81 ASSERT_TRUE(partitionslot->GetCurrentSlot(currentSlot, numOfSlots) == 0); 82 } 83 84 /** 85 * @tc.number: SUB_Startup_PartitionSlot_GetCurrentSlot_0300 86 * @tc.name: testPartitionSlotGetCurrentSlot003 87 * @tc.desc: GetCurrentSlot, numOfSlots is 1, currentSlo is -1 88 */ 89 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotGetCurrentSlot003, Function | MediumTest | Level1) 90 { 91 std::cout << "begin get currentslot by service" << std::endl; 92 int numOfSlots = 1; 93 int currentSlot = -1; 94 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 95 ASSERT_TRUE(partitionslot != nullptr); 96 ASSERT_TRUE(partitionslot->GetCurrentSlot(currentSlot, numOfSlots) == 0); 97 } 98 99 /** 100 * @tc.number: SUB_Startup_PartitionSlot_GetCurrentSlot_0400 101 * @tc.name: testPartitionSlotGetCurrentSlot004 102 * @tc.desc: GetCurrentSlot, numOfSlots is 2, currentSlo is -1 103 */ 104 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotGetCurrentSlot004, Function | MediumTest | Level1) 105 { 106 std::cout << "begin get currentslot by service" << std::endl; 107 int numOfSlots = 2; 108 int currentSlot = -1; 109 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 110 ASSERT_TRUE(partitionslot != nullptr); 111 ASSERT_TRUE(partitionslot->GetCurrentSlot(currentSlot, numOfSlots) == 0); 112 } 113 114 /** 115 * @tc.number: SUB_Startup_PartitionSlot_GetCurrentSlot_0500 116 * @tc.name: testPartitionSlotGetCurrentSlot005 117 * @tc.desc: GetCurrentSlot, numOfSlots is 2, currentSlo is 1 118 */ 119 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotGetCurrentSlot005, Function | MediumTest | Level1) 120 { 121 std::cout << "begin get currentslot by service" << std::endl; 122 int numOfSlots = 2; 123 int currentSlot = 1; 124 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 125 ASSERT_TRUE(partitionslot != nullptr); 126 ASSERT_TRUE(partitionslot->GetCurrentSlot(currentSlot, numOfSlots) == 0); 127 } 128 129 /** 130 * @tc.number: SUB_Startup_PartitionSlot_GetCurrentSlot_0600 131 * @tc.name: testPartitionSlotGetCurrentSlot006 132 * @tc.desc: GetCurrentSlot, numOfSlots is 3, currentSlo is -1 133 */ 134 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotGetCurrentSlot006, Function | MediumTest | Level1) 135 { 136 std::cout << "begin get currentslot by service" << std::endl; 137 int numOfSlots = 3; 138 int currentSlot = -1; 139 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 140 ASSERT_TRUE(partitionslot != nullptr); 141 ASSERT_TRUE(partitionslot->GetCurrentSlot(currentSlot, numOfSlots) == 0); 142 } 143 144 /** 145 * @tc.number: SUB_Startup_PartitionSlot_GetCurrentSlot_0700 146 * @tc.name: testPartitionSlotGetCurrentSlot007 147 * @tc.desc: GetCurrentSlot, numOfSlots is 3, currentSlo is 1 148 */ 149 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotGetCurrentSlot007, Function | MediumTest | Level1) 150 { 151 std::cout << "begin get currentslot by service" << std::endl; 152 int numOfSlots = 3; 153 int currentSlot = 1; 154 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 155 ASSERT_TRUE(partitionslot != nullptr); 156 ASSERT_TRUE(partitionslot->GetCurrentSlot(currentSlot, numOfSlots) == 0); 157 } 158 159 /** 160 * @tc.number: SUB_Startup_PartitionSlot_GetCurrentSlot_0800 161 * @tc.name: testPartitionSlotGetCurrentSlot008 162 * @tc.desc: GetCurrentSlot, numOfSlots is 3, currentSlo is 2 163 */ 164 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotGetCurrentSlot008, Function | MediumTest | Level1) 165 { 166 std::cout << "begin get currentslot by service" << std::endl; 167 int numOfSlots = 3; 168 int currentSlot = 2; 169 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 170 ASSERT_TRUE(partitionslot != nullptr); 171 ASSERT_TRUE(partitionslot->GetCurrentSlot(currentSlot, numOfSlots) == 0); 172 } 173 174 /** 175 * @tc.number: SUB_Startup_PartitionSlot_GetCurrentSlot_0900 176 * @tc.name: testPartitionSlotGetCurrentSlot009 177 * @tc.desc: GetCurrentSlot, numOfSlots is 2, currentSlo is 3 178 */ 179 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotGetCurrentSlot009, Function | MediumTest | Level1) 180 { 181 std::cout << "begin get currentslot by service" << std::endl; 182 int numOfSlots = 2; 183 int currentSlot = 3; 184 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 185 ASSERT_TRUE(partitionslot != nullptr); 186 ASSERT_TRUE(partitionslot->GetCurrentSlot(currentSlot, numOfSlots) == 0); 187 } 188 189 /** 190 * @tc.number: SUB_Startup_PartitionSlot_GetSlotSuffix_0100 191 * @tc.name: testPartitionSlotGetSlotSuffix001 192 * @tc.desc: GetSlotSuffix, slot is 2147483647 193 */ 194 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotGetSlotSuffix001, Function | MediumTest | Level1) 195 { 196 std::cout << "begin get suffix by service" << std::endl; 197 std::string suffix = ""; 198 int slot = 2147483647; 199 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 200 ASSERT_TRUE(partitionslot != nullptr); 201 ASSERT_TRUE(partitionslot->GetSlotSuffix(slot, suffix) == 0); 202 } 203 204 /** 205 * @tc.number: SUB_Startup_PartitionSlot_GetSlotSuffix_0200 206 * @tc.name: testPartitionSlotGetSlotSuffix002 207 * @tc.desc: GetSlotSuffix, slot is -2147483648 208 */ 209 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotGetSlotSuffix002, Function | MediumTest | Level1) 210 { 211 std::cout << "begin get suffix by service" << std::endl; 212 std::string suffix = ""; 213 int slot = -2147483648; 214 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 215 ASSERT_TRUE(partitionslot != nullptr); 216 ASSERT_TRUE(partitionslot->GetSlotSuffix(slot, suffix) == 0); 217 } 218 219 /** 220 * @tc.number: SUB_Startup_PartitionSlot_GetSlotSuffix_0300 221 * @tc.name: testPartitionSlotGetSlotSuffix003 222 * @tc.desc: GetSlotSuffix, stability test 223 */ 224 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotGetSlotSuffix003, Function | MediumTest | Level1) 225 { 226 std::cout << "begin get suffix by service" << std::endl; 227 std::string suffix = ""; 228 int slot = 2; 229 for (int i = 0; i < 100; i++) { 230 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 231 ASSERT_TRUE(partitionslot != nullptr); 232 ASSERT_TRUE(partitionslot->GetSlotSuffix(slot, suffix) == 0); 233 } 234 } 235 236 /** 237 * @tc.number: SUB_Startup_PartitionSlot_SetActiveSlot_0100 238 * @tc.name: testPartitionSlotSetActiveSlot001 239 * @tc.desc: SetActiveSlot, slot is 2147483647 240 */ 241 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotSetActiveSlot001, Function | MediumTest | Level1) 242 { 243 std::cout << "begin set active slot by service" << std::endl; 244 int numOfSlots = 2; 245 int currentSlot = 0; 246 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 247 ASSERT_TRUE(partitionslot != nullptr); 248 partitionslot->GetCurrentSlot(currentSlot, numOfSlots); 249 ASSERT_TRUE(partitionslot->SetActiveSlot(2147483647) == 0); 250 partitionslot->SetActiveSlot(currentSlot); 251 } 252 253 /** 254 * @tc.number: SUB_Startup_PartitionSlot_SetActiveSlot_0200 255 * @tc.name: testPartitionSlotSetActiveSlot002 256 * @tc.desc: SetActiveSlot, slot is -2147483648 257 */ 258 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotSetActiveSlot002, Function | MediumTest | Level1) 259 { 260 std::cout << "begin set active slot by service" << std::endl; 261 int numOfSlots = 2; 262 int currentSlot = 0; 263 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 264 ASSERT_TRUE(partitionslot != nullptr); 265 partitionslot->GetCurrentSlot(currentSlot, numOfSlots); 266 ASSERT_TRUE(partitionslot->SetActiveSlot(-2147483648) != 0); 267 partitionslot->SetActiveSlot(currentSlot); 268 } 269 270 /** 271 * @tc.number: SUB_Startup_PartitionSlot_SetActiveSlot_0300 272 * @tc.name: testPartitionSlotSetActiveSlot003 273 * @tc.desc: SetActiveSlot, stability test 274 */ 275 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotSetActiveSlot003, Function | MediumTest | Level1) 276 { 277 int numOfSlots = 2; 278 int currentSlot = 0; 279 for (int i = 0; i < 100; i++) { 280 std::cout << "begin set active slot by service" << std::endl; 281 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 282 ASSERT_TRUE(partitionslot != nullptr); 283 partitionslot->GetCurrentSlot(currentSlot, numOfSlots); 284 ASSERT_TRUE(partitionslot->SetActiveSlot(2) == 0); 285 partitionslot->SetActiveSlot(currentSlot); 286 } 287 } 288 289 /** 290 * @tc.number: SUB_Startup_PartitionSlot_SetSlotUnbootable_0100 291 * @tc.name: testPartitionSlotSetSlotUnbootable001 292 * @tc.desc: SetSlotUnbootable, slot is 2147483647 293 */ 294 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotSetSlotUnbootable001, Function | MediumTest | Level1) 295 { 296 std::cout << "begin set unbootable slot by service" << std::endl; 297 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 298 ASSERT_TRUE(partitionslot != nullptr); 299 ASSERT_TRUE(partitionslot->SetSlotUnbootable(2147483647) == 0); 300 } 301 302 /** 303 * @tc.number: SUB_Startup_PartitionSlot_SetSlotUnbootable_0200 304 * @tc.name: testPartitionSlotSetSlotUnbootable002 305 * @tc.desc: SetSlotUnbootable, slot is -2147483648 306 */ 307 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotSetSlotUnbootable002, Function | MediumTest | Level1) 308 { 309 std::cout << "begin set unbootable slot by service" << std::endl; 310 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 311 ASSERT_TRUE(partitionslot != nullptr); 312 ASSERT_TRUE(partitionslot->SetSlotUnbootable(-2147483648) != 0); 313 } 314 315 /** 316 * @tc.number: SUB_Startup_PartitionSlot_SetSlotUnbootable_0300 317 * @tc.name: testPartitionSlotSetSlotUnbootable003 318 * @tc.desc: SetSlotUnbootable, stability test 319 */ 320 HWTEST_F(StartupPartitionSlotTestAdditional, testPartitionSlotSetSlotUnbootable003, Function | MediumTest | Level1) 321 { 322 for (int i = 0; i < 100; i++) { 323 std::cout << "begin set unbootable slot by service" << std::endl; 324 sptr<IPartitionSlot> partitionslot = IPartitionSlot::Get(); 325 ASSERT_TRUE(partitionslot != nullptr); 326 ASSERT_TRUE(partitionslot->SetSlotUnbootable(2) == 0); 327 } 328 }