1 /* 2 * Copyright (c) 2021 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 <cstdio> 17 #include <gtest/gtest.h> 18 19 #include "parameters.h" 20 #include "storage_daemon_communication/storage_daemon_communication.h" 21 #include "storage_service_errno.h" 22 #include "user/multi_user_manager_service.h" 23 24 namespace { 25 using namespace std; 26 using namespace OHOS; 27 using namespace StorageManager; 28 const string FSCRYPT_POLICY_KEY = "fscrypt.policy.config"; 29 bool g_fscryptEnable = false; 30 class MultiUserManagerServiceTest : public testing::Test { 31 public: SetUpTestCase(void)32 static void SetUpTestCase(void) 33 { 34 std::string res = system::GetParameter(FSCRYPT_POLICY_KEY, ""); 35 if (!res.empty()) { 36 g_fscryptEnable = true; 37 } 38 }; TearDownTestCase()39 static void TearDownTestCase() {}; SetUp()40 void SetUp() {}; TearDown()41 void TearDown() {}; 42 }; 43 44 /** 45 * @tc.number: SUB_STORAGE_User_manager_service_PrepareAddUser_0000 46 * @tc.name: User_manager_service_PrepareAddUser_0000 47 * @tc.desc: Test function of PrepareAddUser interface for SUCCESS. 48 * @tc.size: MEDIUM 49 * @tc.type: FUNC 50 * @tc.level Level 1 51 * @tc.require: AR000GK4HB 52 */ 53 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareAddUser_0000, testing::ext::TestSize.Level1) 54 { 55 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareAddUser_0000"; 56 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 57 int32_t userId = 121; 58 uint32_t flag = 3; 59 int32_t result; 60 if (service != nullptr) { 61 result = service->PrepareAddUser(userId, flag); 62 } 63 EXPECT_EQ(result, E_OK); 64 service->RemoveUser(userId, flag); 65 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareAddUser_0000"; 66 } 67 68 /** 69 * @tc.number: SUB_STORAGE_User_manager_service_PrepareAddUser_0001 70 * @tc.name: User_manager_service_PrepareAddUser_0001 71 * @tc.desc: Test function of PrepareAddUser interface for Parameters ERROR which userId<0. 72 * @tc.size: MEDIUM 73 * @tc.type: FUNC 74 * @tc.level Level 1 75 * @tc.require: AR000GK4HB 76 */ 77 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareAddUser_0001, testing::ext::TestSize.Level1) 78 { 79 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareAddUser_0001"; 80 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 81 int32_t userId = -1; 82 uint32_t flag = 3; 83 int32_t result; 84 if (service != nullptr) { 85 result = service->PrepareAddUser(userId, flag); 86 } 87 EXPECT_EQ(result, E_USERID_RANGE); 88 service->RemoveUser(userId, flag); 89 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareAddUser_0001"; 90 } 91 92 /** 93 * @tc.number: SUB_STORAGE_User_manager_service_PrepareAddUser_0002 94 * @tc.name: User_manager_service_PrepareAddUser_0002 95 * @tc.desc: Test function of PrepareAddUser interface for Parameters ERROR which userId not in [101, 1099]. 96 * @tc.size: MEDIUM 97 * @tc.type: FUNC 98 * @tc.level Level 1 99 * @tc.require: AR000GK4HB 100 */ 101 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareAddUser_0002, testing::ext::TestSize.Level1) 102 { 103 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareAddUser_0002"; 104 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 105 int32_t userId = 19999; 106 uint32_t flag = 3; 107 int32_t result; 108 if (service != nullptr) { 109 result = service->PrepareAddUser(userId, flag); 110 } 111 EXPECT_EQ(result, E_USERID_RANGE); 112 service->RemoveUser(userId, flag); 113 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareAddUser_0002"; 114 } 115 116 /** 117 * @tc.number: SUB_STORAGE_User_manager_service_PrepareAddUser_0003 118 * @tc.name: User_manager_service_PrepareAddUser_0003 119 * @tc.desc: Test function of PrepareAddUser interface for SUCCESS which Repeated add. 120 * @tc.size: MEDIUM 121 * @tc.type: FUNC 122 * @tc.level Level 1 123 * @tc.require: AR000GK4HB 124 */ 125 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareAddUser_0003, testing::ext::TestSize.Level1) 126 { 127 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareAddUser_0003"; 128 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 129 int32_t userId = 102; 130 uint32_t flag = 3; 131 int32_t result; 132 if (service != nullptr) { 133 service->PrepareAddUser(userId, flag); 134 result = service->PrepareAddUser(userId, flag); 135 } 136 EXPECT_EQ(result, E_OK); 137 service->RemoveUser(userId, flag); 138 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareAddUser_0003"; 139 } 140 141 /** 142 * @tc.number: SUB_STORAGE_User_manager_service_RemoveUser_0000 143 * @tc.name: User_manager_service_RemoveUser_0000 144 * @tc.desc: Test function of RemoveUser interface for SUCCESS. 145 * @tc.size: MEDIUM 146 * @tc.type: FUNC 147 * @tc.level Level 1 148 * @tc.require: AR000GK4HB 149 */ 150 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_RemoveUser_0000, testing::ext::TestSize.Level1) 151 { 152 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_RemoveUser_0000"; 153 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 154 int32_t userId = 103; 155 uint32_t flag = 3; 156 int32_t result; 157 if (service != nullptr) { 158 service->PrepareAddUser(userId, flag); 159 result = service->RemoveUser(userId, flag); 160 } 161 EXPECT_EQ(result, E_OK); 162 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_RemoveUser_0000"; 163 } 164 165 /** 166 * @tc.number: SUB_STORAGE_User_manager_service_RemoveUser_0001 167 * @tc.name: User_manager_service_RemoveUser_0001 168 * @tc.desc: Test function of RemoveUser interface for SUCCESS which remove userId not exist. 169 * @tc.size: MEDIUM 170 * @tc.type: FUNC 171 * @tc.level Level 1 172 * @tc.require: AR000GK4HB 173 */ 174 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_RemoveUser_0001, testing::ext::TestSize.Level1) 175 { 176 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_RemoveUser_0001"; 177 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 178 int32_t userId = 104; 179 uint32_t flag = 3; 180 int32_t result; 181 if (service != nullptr) { 182 result = service->RemoveUser(userId, flag); 183 } 184 EXPECT_EQ(result, E_OK); 185 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_RemoveUser_0001"; 186 } 187 188 /** 189 * @tc.number: SUB_STORAGE_User_manager_service_RemoveUser_0002 190 * @tc.name: User_manager_service_RemoveUser_0002 191 * @tc.desc: Test function of RemoveUser interface for Parameters ERROR which userId<0. 192 * @tc.size: MEDIUM 193 * @tc.type: FUNC 194 * @tc.level Level 1 195 * @tc.require: AR000GK4HB 196 */ 197 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_RemoveUser_0002, testing::ext::TestSize.Level1) 198 { 199 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_RemoveUser_0002"; 200 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 201 int32_t userId = -2; 202 uint32_t flag = 3; 203 int32_t result; 204 if (service != nullptr) { 205 service->PrepareAddUser(userId, flag); 206 result = service->RemoveUser(userId, flag); 207 } 208 EXPECT_EQ(result, E_USERID_RANGE); 209 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_RemoveUser_0002"; 210 } 211 212 /** 213 * @tc.number: SUB_STORAGE_User_manager_service_PrepareStartUser_0000 214 * @tc.name: User_manager_service_PrepareStartUser_0000 215 * @tc.desc: Test function of PrepareStartUser interface for SUCCESS. 216 * @tc.size: MEDIUM 217 * @tc.type: FUNC 218 * @tc.level Level 1 219 * @tc.require: AR000GK4HB 220 */ 221 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareStartUser_0000, testing::ext::TestSize.Level1) 222 { 223 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareStartUser_0000"; 224 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 225 int32_t userId = 105; 226 uint32_t flag = 3; 227 int32_t result; 228 if (service != nullptr) { 229 service->PrepareAddUser(userId, flag); 230 result = service->PrepareStartUser(userId); 231 } 232 EXPECT_EQ(result, E_OK); 233 service->StopUser(userId); 234 service->RemoveUser(userId, flag); 235 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareStartUser_0000"; 236 } 237 238 /** 239 * @tc.number: SUB_STORAGE_User_manager_service_PrepareStartUser_0001 240 * @tc.name: User_manager_service_PrepareStartUser_0001 241 * @tc.desc: Test function of PrepareStartUser interface for Logic ERROR which start userId not exist. 242 * @tc.size: MEDIUM 243 * @tc.type: FUNC 244 * @tc.level Level 1 245 * @tc.require: AR000GK4HB 246 */ 247 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareStartUser_0001, testing::ext::TestSize.Level1) 248 { 249 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareStartUser_0001"; 250 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 251 int32_t userId = 106; 252 int32_t result; 253 if (service != nullptr) { 254 result = service->PrepareStartUser(userId); 255 } 256 EXPECT_EQ(result, E_OK); 257 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareStartUser_0001"; 258 } 259 260 /** 261 * @tc.number: SUB_STORAGE_User_manager_service_PrepareStartUser_0002 262 * @tc.name: User_manager_service_PrepareStartUser_0002 263 * @tc.desc: Test function of PrepareStartUser interface for Parameters ERROR which userId<0. 264 * @tc.size: MEDIUM 265 * @tc.type: FUNC 266 * @tc.level Level 1 267 * @tc.require: AR000GK4HB 268 */ 269 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareStartUser_0002, testing::ext::TestSize.Level1) 270 { 271 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareStartUser_0002"; 272 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 273 int32_t userId = -4; 274 uint32_t flag = 3; 275 int32_t result; 276 if (service != nullptr) { 277 service->PrepareAddUser(userId, flag); 278 result = service->PrepareStartUser(userId); 279 } 280 EXPECT_EQ(result, E_USERID_RANGE); 281 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareStartUser_0002"; 282 } 283 284 /** 285 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0000 286 * @tc.name: User_manager_service_StopUser_0000 287 * @tc.desc: Test function of StopUser interface for SUCCESS. 288 * @tc.size: MEDIUM 289 * @tc.type: FUNC 290 * @tc.level Level 1 291 * @tc.require: AR000GK4HB 292 */ 293 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_StopUser_0000, testing::ext::TestSize.Level1) 294 { 295 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0000"; 296 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 297 int32_t userId = 108; 298 uint32_t flag = 3; 299 int32_t result; 300 if (service != nullptr) { 301 service->PrepareAddUser(userId, flag); 302 service->PrepareStartUser(userId); 303 result = service->StopUser(userId); 304 } 305 EXPECT_EQ(result, E_OK); 306 service->RemoveUser(userId, flag); 307 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0000"; 308 } 309 310 /** 311 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0001 312 * @tc.name: User_manager_service_StopUser_0001 313 * @tc.desc: Test function of StopUser interface for Logic ERROR which start userId not exist. 314 * @tc.size: MEDIUM 315 * @tc.type: FUNC 316 * @tc.level Level 1 317 * @tc.require: AR000GK4HB 318 */ 319 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_StopUser_0001, testing::ext::TestSize.Level1) 320 { 321 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0001"; 322 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 323 int32_t userId = 109; 324 int32_t result; 325 if (service != nullptr) { 326 result = service->StopUser(userId); 327 } 328 EXPECT_EQ(result, E_OK); 329 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0001"; 330 } 331 332 /** 333 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0002 334 * @tc.name: User_manager_service_StopUser_0002 335 * @tc.desc: Test function of StopUser interface for Parameters ERROR which userId<0. 336 * @tc.size: MEDIUM 337 * @tc.type: FUNC 338 * @tc.level Level 1 339 * @tc.require: AR000GK4HB 340 */ 341 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_StopUser_0002, testing::ext::TestSize.Level1) 342 { 343 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0002"; 344 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 345 int32_t userId = -6; 346 uint32_t flag = 3; 347 int32_t result; 348 if (service != nullptr) { 349 service->PrepareAddUser(userId, flag); 350 service->PrepareStartUser(userId); 351 result = service->StopUser(userId); 352 } 353 EXPECT_EQ(result, E_USERID_RANGE); 354 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0002"; 355 } 356 357 /** 358 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0003 359 * @tc.name: User_manager_service_StopUser_0003 360 * @tc.desc: Test function of StopUser interface for Logic ERROR which stop userId not start. 361 * @tc.size: MEDIUM 362 * @tc.type: FUNC 363 * @tc.level Level 1 364 * @tc.require: AR000GK4HB 365 */ 366 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_StopUser_0003, testing::ext::TestSize.Level1) 367 { 368 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0003"; 369 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 370 int32_t userId = 110; 371 uint32_t flag = 3; 372 int32_t result; 373 if (service != nullptr) { 374 service->PrepareAddUser(userId, flag); 375 result = service->StopUser(userId); 376 } 377 EXPECT_EQ(result, E_OK); 378 service->RemoveUser(userId, flag); 379 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0003"; 380 } 381 } // namespace 382