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, 0); 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_NE(result, 0); 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_NE(result, 0); 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 if (g_fscryptEnable) { 137 EXPECT_EQ(result, -EEXIST); 138 } else { 139 EXPECT_EQ(result, E_OK); 140 } 141 service->RemoveUser(userId, flag); 142 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareAddUser_0003"; 143 } 144 145 /** 146 * @tc.number: SUB_STORAGE_User_manager_service_RemoveUser_0000 147 * @tc.name: User_manager_service_RemoveUser_0000 148 * @tc.desc: Test function of RemoveUser interface for SUCCESS. 149 * @tc.size: MEDIUM 150 * @tc.type: FUNC 151 * @tc.level Level 1 152 * @tc.require: AR000GK4HB 153 */ 154 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_RemoveUser_0000, testing::ext::TestSize.Level1) 155 { 156 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_RemoveUser_0000"; 157 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 158 int32_t userId = 103; 159 uint32_t flag = 3; 160 int32_t result; 161 if (service != nullptr) { 162 service->PrepareAddUser(userId, flag); 163 result = service->RemoveUser(userId, flag); 164 } 165 EXPECT_EQ(result, 0); 166 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_RemoveUser_0000"; 167 } 168 169 /** 170 * @tc.number: SUB_STORAGE_User_manager_service_RemoveUser_0001 171 * @tc.name: User_manager_service_RemoveUser_0001 172 * @tc.desc: Test function of RemoveUser interface for SUCCESS which remove userId not exist. 173 * @tc.size: MEDIUM 174 * @tc.type: FUNC 175 * @tc.level Level 1 176 * @tc.require: AR000GK4HB 177 */ 178 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_RemoveUser_0001, testing::ext::TestSize.Level1) 179 { 180 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_RemoveUser_0001"; 181 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 182 int32_t userId = 104; 183 uint32_t flag = 3; 184 int32_t result; 185 if (service != nullptr) { 186 result = service->RemoveUser(userId, flag); 187 } 188 EXPECT_EQ(result, E_OK); 189 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_RemoveUser_0001"; 190 } 191 192 /** 193 * @tc.number: SUB_STORAGE_User_manager_service_RemoveUser_0002 194 * @tc.name: User_manager_service_RemoveUser_0002 195 * @tc.desc: Test function of RemoveUser interface for Parameters ERROR which userId<0. 196 * @tc.size: MEDIUM 197 * @tc.type: FUNC 198 * @tc.level Level 1 199 * @tc.require: AR000GK4HB 200 */ 201 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_RemoveUser_0002, testing::ext::TestSize.Level1) 202 { 203 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_RemoveUser_0002"; 204 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 205 int32_t userId = -2; 206 uint32_t flag = 3; 207 int32_t result; 208 if (service != nullptr) { 209 service->PrepareAddUser(userId, flag); 210 result = service->RemoveUser(userId, flag); 211 } 212 EXPECT_NE(result, 0); 213 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_RemoveUser_0002"; 214 } 215 216 /** 217 * @tc.number: SUB_STORAGE_User_manager_service_PrepareStartUser_0000 218 * @tc.name: User_manager_service_PrepareStartUser_0000 219 * @tc.desc: Test function of PrepareStartUser interface for SUCCESS. 220 * @tc.size: MEDIUM 221 * @tc.type: FUNC 222 * @tc.level Level 1 223 * @tc.require: AR000GK4HB 224 */ 225 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareStartUser_0000, testing::ext::TestSize.Level1) 226 { 227 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareStartUser_0000"; 228 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 229 int32_t userId = 105; 230 uint32_t flag = 3; 231 int32_t result; 232 if (service != nullptr) { 233 service->PrepareAddUser(userId, flag); 234 result = service->PrepareStartUser(userId); 235 } 236 EXPECT_EQ(result, 0); 237 service->StopUser(userId); 238 service->RemoveUser(userId, flag); 239 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareStartUser_0000"; 240 } 241 242 /** 243 * @tc.number: SUB_STORAGE_User_manager_service_PrepareStartUser_0001 244 * @tc.name: User_manager_service_PrepareStartUser_0001 245 * @tc.desc: Test function of PrepareStartUser interface for Logic ERROR which start userId not exist. 246 * @tc.size: MEDIUM 247 * @tc.type: FUNC 248 * @tc.level Level 1 249 * @tc.require: AR000GK4HB 250 */ 251 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareStartUser_0001, testing::ext::TestSize.Level1) 252 { 253 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareStartUser_0001"; 254 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 255 int32_t userId = 106; 256 int32_t result; 257 if (service != nullptr) { 258 result = service->PrepareStartUser(userId); 259 } 260 EXPECT_NE(result, 0); 261 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareStartUser_0001"; 262 } 263 264 /** 265 * @tc.number: SUB_STORAGE_User_manager_service_PrepareStartUser_0002 266 * @tc.name: User_manager_service_PrepareStartUser_0002 267 * @tc.desc: Test function of PrepareStartUser interface for Parameters ERROR which userId<0. 268 * @tc.size: MEDIUM 269 * @tc.type: FUNC 270 * @tc.level Level 1 271 * @tc.require: AR000GK4HB 272 */ 273 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareStartUser_0002, testing::ext::TestSize.Level1) 274 { 275 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareStartUser_0002"; 276 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 277 int32_t userId = -4; 278 uint32_t flag = 3; 279 int32_t result; 280 if (service != nullptr) { 281 service->PrepareAddUser(userId, flag); 282 result = service->PrepareStartUser(userId); 283 } 284 EXPECT_NE(result, 0); 285 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareStartUser_0002"; 286 } 287 288 /** 289 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0000 290 * @tc.name: User_manager_service_StopUser_0000 291 * @tc.desc: Test function of StopUser interface for SUCCESS. 292 * @tc.size: MEDIUM 293 * @tc.type: FUNC 294 * @tc.level Level 1 295 * @tc.require: AR000GK4HB 296 */ 297 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_StopUser_0000, testing::ext::TestSize.Level1) 298 { 299 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0000"; 300 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 301 int32_t userId = 108; 302 uint32_t flag = 3; 303 int32_t result; 304 if (service != nullptr) { 305 service->PrepareAddUser(userId, flag); 306 service->PrepareStartUser(userId); 307 result = service->StopUser(userId); 308 } 309 EXPECT_EQ(result, E_UMOUNT); 310 service->RemoveUser(userId, flag); 311 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0000"; 312 } 313 314 /** 315 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0001 316 * @tc.name: User_manager_service_StopUser_0001 317 * @tc.desc: Test function of StopUser interface for Logic ERROR which start userId not exist. 318 * @tc.size: MEDIUM 319 * @tc.type: FUNC 320 * @tc.level Level 1 321 * @tc.require: AR000GK4HB 322 */ 323 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_StopUser_0001, testing::ext::TestSize.Level1) 324 { 325 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0001"; 326 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 327 int32_t userId = 109; 328 int32_t result; 329 if (service != nullptr) { 330 result = service->StopUser(userId); 331 } 332 EXPECT_NE(result, 0); 333 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0001"; 334 } 335 336 /** 337 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0002 338 * @tc.name: User_manager_service_StopUser_0002 339 * @tc.desc: Test function of StopUser interface for Parameters ERROR which userId<0. 340 * @tc.size: MEDIUM 341 * @tc.type: FUNC 342 * @tc.level Level 1 343 * @tc.require: AR000GK4HB 344 */ 345 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_StopUser_0002, testing::ext::TestSize.Level1) 346 { 347 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0002"; 348 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 349 int32_t userId = -6; 350 uint32_t flag = 3; 351 int32_t result; 352 if (service != nullptr) { 353 service->PrepareAddUser(userId, flag); 354 service->PrepareStartUser(userId); 355 result = service->StopUser(userId); 356 } 357 EXPECT_NE(result, 0); 358 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0002"; 359 } 360 361 /** 362 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0003 363 * @tc.name: User_manager_service_StopUser_0003 364 * @tc.desc: Test function of StopUser interface for Logic ERROR which stop userId not start. 365 * @tc.size: MEDIUM 366 * @tc.type: FUNC 367 * @tc.level Level 1 368 * @tc.require: AR000GK4HB 369 */ 370 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_StopUser_0003, testing::ext::TestSize.Level1) 371 { 372 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0003"; 373 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 374 int32_t userId = 110; 375 uint32_t flag = 3; 376 int32_t result; 377 if (service != nullptr) { 378 service->PrepareAddUser(userId, flag); 379 result = service->StopUser(userId); 380 } 381 EXPECT_NE(result, 0); 382 service->RemoveUser(userId, flag); 383 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0003"; 384 } 385 } // namespace 386