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 "storage_daemon_communication/storage_daemon_communication.h" 20 #include "user/multi_user_manager_service.h" 21 #include "storage_service_errno.h" 22 #include "parameters.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 = 10000; 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 if (g_fscryptEnable) { 189 EXPECT_EQ(result, -EFAULT); 190 } else { 191 EXPECT_EQ(result, E_OK); 192 } 193 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_RemoveUser_0001"; 194 } 195 196 /** 197 * @tc.number: SUB_STORAGE_User_manager_service_RemoveUser_0002 198 * @tc.name: User_manager_service_RemoveUser_0002 199 * @tc.desc: Test function of RemoveUser interface for Parameters ERROR which userId<0. 200 * @tc.size: MEDIUM 201 * @tc.type: FUNC 202 * @tc.level Level 1 203 * @tc.require: AR000GK4HB 204 */ 205 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_RemoveUser_0002, testing::ext::TestSize.Level1) 206 { 207 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_RemoveUser_0002"; 208 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 209 int32_t userId = -2; 210 uint32_t flag = 3; 211 int32_t result; 212 if (service != nullptr) { 213 service->PrepareAddUser(userId, flag); 214 result = service->RemoveUser(userId, flag); 215 } 216 EXPECT_NE(result, 0); 217 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_RemoveUser_0002"; 218 } 219 220 /** 221 * @tc.number: SUB_STORAGE_User_manager_service_PrepareStartUser_0000 222 * @tc.name: User_manager_service_PrepareStartUser_0000 223 * @tc.desc: Test function of PrepareStartUser interface for SUCCESS. 224 * @tc.size: MEDIUM 225 * @tc.type: FUNC 226 * @tc.level Level 1 227 * @tc.require: AR000GK4HB 228 */ 229 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareStartUser_0000, testing::ext::TestSize.Level1) 230 { 231 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareStartUser_0000"; 232 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 233 int32_t userId = 105; 234 uint32_t flag = 3; 235 int32_t result; 236 if (service != nullptr) { 237 service->PrepareAddUser(userId, flag); 238 result = service->PrepareStartUser(userId); 239 } 240 EXPECT_EQ(result, 0); 241 service->StopUser(userId); 242 service->RemoveUser(userId, flag); 243 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareStartUser_0000"; 244 } 245 246 /** 247 * @tc.number: SUB_STORAGE_User_manager_service_PrepareStartUser_0001 248 * @tc.name: User_manager_service_PrepareStartUser_0001 249 * @tc.desc: Test function of PrepareStartUser interface for Logic ERROR which start userId not exist. 250 * @tc.size: MEDIUM 251 * @tc.type: FUNC 252 * @tc.level Level 1 253 * @tc.require: AR000GK4HB 254 */ 255 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareStartUser_0001, testing::ext::TestSize.Level1) 256 { 257 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareStartUser_0001"; 258 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 259 int32_t userId = 106; 260 int32_t result; 261 if (service != nullptr) { 262 result = service->PrepareStartUser(userId); 263 } 264 EXPECT_NE(result, 0); 265 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareStartUser_0001"; 266 } 267 268 /** 269 * @tc.number: SUB_STORAGE_User_manager_service_PrepareStartUser_0002 270 * @tc.name: User_manager_service_PrepareStartUser_0002 271 * @tc.desc: Test function of PrepareStartUser interface for Parameters ERROR which userId<0. 272 * @tc.size: MEDIUM 273 * @tc.type: FUNC 274 * @tc.level Level 1 275 * @tc.require: AR000GK4HB 276 */ 277 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareStartUser_0002, testing::ext::TestSize.Level1) 278 { 279 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareStartUser_0002"; 280 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 281 int32_t userId = -4; 282 uint32_t flag = 3; 283 int32_t result; 284 if (service != nullptr) { 285 service->PrepareAddUser(userId, flag); 286 result = service->PrepareStartUser(userId); 287 } 288 EXPECT_NE(result, 0); 289 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareStartUser_0002"; 290 } 291 292 /** 293 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0000 294 * @tc.name: User_manager_service_StopUser_0000 295 * @tc.desc: Test function of StopUser interface for SUCCESS. 296 * @tc.size: MEDIUM 297 * @tc.type: FUNC 298 * @tc.level Level 1 299 * @tc.require: AR000GK4HB 300 */ 301 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_StopUser_0000, testing::ext::TestSize.Level1) 302 { 303 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0000"; 304 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 305 int32_t userId = 108; 306 uint32_t flag = 3; 307 int32_t result; 308 if (service != nullptr) { 309 service->PrepareAddUser(userId, flag); 310 service->PrepareStartUser(userId); 311 result = service->StopUser(userId); 312 } 313 EXPECT_EQ(result, 0); 314 service->RemoveUser(userId, flag); 315 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0000"; 316 } 317 318 /** 319 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0001 320 * @tc.name: User_manager_service_StopUser_0001 321 * @tc.desc: Test function of StopUser interface for Logic ERROR which start userId not exist. 322 * @tc.size: MEDIUM 323 * @tc.type: FUNC 324 * @tc.level Level 1 325 * @tc.require: AR000GK4HB 326 */ 327 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_StopUser_0001, testing::ext::TestSize.Level1) 328 { 329 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0001"; 330 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 331 int32_t userId = 109; 332 int32_t result; 333 if (service != nullptr) { 334 result = service->StopUser(userId); 335 } 336 EXPECT_NE(result, 0); 337 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0001"; 338 } 339 340 /** 341 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0002 342 * @tc.name: User_manager_service_StopUser_0002 343 * @tc.desc: Test function of StopUser interface for Parameters ERROR which userId<0. 344 * @tc.size: MEDIUM 345 * @tc.type: FUNC 346 * @tc.level Level 1 347 * @tc.require: AR000GK4HB 348 */ 349 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_StopUser_0002, testing::ext::TestSize.Level1) 350 { 351 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0002"; 352 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 353 int32_t userId = -6; 354 uint32_t flag = 3; 355 int32_t result; 356 if (service != nullptr) { 357 service->PrepareAddUser(userId, flag); 358 service->PrepareStartUser(userId); 359 result = service->StopUser(userId); 360 } 361 EXPECT_NE(result, 0); 362 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0002"; 363 } 364 365 /** 366 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0003 367 * @tc.name: User_manager_service_StopUser_0003 368 * @tc.desc: Test function of StopUser interface for Logic ERROR which stop userId not start. 369 * @tc.size: MEDIUM 370 * @tc.type: FUNC 371 * @tc.level Level 1 372 * @tc.require: AR000GK4HB 373 */ 374 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_StopUser_0003, testing::ext::TestSize.Level1) 375 { 376 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0003"; 377 std::shared_ptr<MultiUserManagerService> service = DelayedSingleton<MultiUserManagerService>::GetInstance(); 378 int32_t userId = 110; 379 uint32_t flag = 3; 380 int32_t result; 381 if (service != nullptr) { 382 service->PrepareAddUser(userId, flag); 383 result = service->StopUser(userId); 384 } 385 EXPECT_NE(result, 0); 386 service->RemoveUser(userId, flag); 387 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0003"; 388 } 389 } // namespace 390