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 auto &service = MultiUserManagerService::GetInstance(); 57 int32_t userId = 121; 58 uint32_t flag = 3; 59 int32_t result; 60 result = service.PrepareAddUser(userId, flag); 61 EXPECT_EQ(result, E_OK); 62 service.RemoveUser(userId, flag); 63 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareAddUser_0000"; 64 } 65 66 /** 67 * @tc.number: SUB_STORAGE_User_manager_service_PrepareAddUser_0001 68 * @tc.name: User_manager_service_PrepareAddUser_0001 69 * @tc.desc: Test function of PrepareAddUser interface for Parameters ERROR which userId<0. 70 * @tc.size: MEDIUM 71 * @tc.type: FUNC 72 * @tc.level Level 1 73 * @tc.require: AR000GK4HB 74 */ 75 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareAddUser_0001, testing::ext::TestSize.Level1) 76 { 77 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareAddUser_0001"; 78 auto &service = MultiUserManagerService::GetInstance(); 79 int32_t userId = -1; 80 uint32_t flag = 3; 81 int32_t result; 82 result = service.PrepareAddUser(userId, flag); 83 EXPECT_EQ(result, E_USERID_RANGE); 84 service.RemoveUser(userId, flag); 85 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareAddUser_0001"; 86 } 87 88 /** 89 * @tc.number: SUB_STORAGE_User_manager_service_PrepareAddUser_0002 90 * @tc.name: User_manager_service_PrepareAddUser_0002 91 * @tc.desc: Test function of PrepareAddUser interface for Parameters ERROR which userId not in [101, 1099]. 92 * @tc.size: MEDIUM 93 * @tc.type: FUNC 94 * @tc.level Level 1 95 * @tc.require: AR000GK4HB 96 */ 97 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareAddUser_0002, testing::ext::TestSize.Level1) 98 { 99 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareAddUser_0002"; 100 auto &service = MultiUserManagerService::GetInstance(); 101 int32_t userId = 19999; 102 uint32_t flag = 3; 103 int32_t result; 104 result = service.PrepareAddUser(userId, flag); 105 EXPECT_EQ(result, E_USERID_RANGE); 106 service.RemoveUser(userId, flag); 107 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareAddUser_0002"; 108 } 109 110 /** 111 * @tc.number: SUB_STORAGE_User_manager_service_PrepareAddUser_0003 112 * @tc.name: User_manager_service_PrepareAddUser_0003 113 * @tc.desc: Test function of PrepareAddUser interface for SUCCESS which Repeated add. 114 * @tc.size: MEDIUM 115 * @tc.type: FUNC 116 * @tc.level Level 1 117 * @tc.require: AR000GK4HB 118 */ 119 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareAddUser_0003, testing::ext::TestSize.Level1) 120 { 121 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareAddUser_0003"; 122 auto &service = MultiUserManagerService::GetInstance(); 123 int32_t userId = 102; 124 uint32_t flag = 3; 125 int32_t result; 126 service.PrepareAddUser(userId, flag); 127 result = service.PrepareAddUser(userId, flag); 128 EXPECT_EQ(result, E_OK); 129 service.RemoveUser(userId, flag); 130 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareAddUser_0003"; 131 } 132 133 /** 134 * @tc.number: SUB_STORAGE_User_manager_service_RemoveUser_0000 135 * @tc.name: User_manager_service_RemoveUser_0000 136 * @tc.desc: Test function of RemoveUser interface for SUCCESS. 137 * @tc.size: MEDIUM 138 * @tc.type: FUNC 139 * @tc.level Level 1 140 * @tc.require: AR000GK4HB 141 */ 142 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_RemoveUser_0000, testing::ext::TestSize.Level1) 143 { 144 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_RemoveUser_0000"; 145 auto &service = MultiUserManagerService::GetInstance(); 146 int32_t userId = 103; 147 uint32_t flag = 3; 148 int32_t result; 149 service.PrepareAddUser(userId, flag); 150 result = service.RemoveUser(userId, flag); 151 EXPECT_EQ(result, E_OK); 152 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_RemoveUser_0000"; 153 } 154 155 /** 156 * @tc.number: SUB_STORAGE_User_manager_service_RemoveUser_0001 157 * @tc.name: User_manager_service_RemoveUser_0001 158 * @tc.desc: Test function of RemoveUser interface for SUCCESS which remove userId not exist. 159 * @tc.size: MEDIUM 160 * @tc.type: FUNC 161 * @tc.level Level 1 162 * @tc.require: AR000GK4HB 163 */ 164 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_RemoveUser_0001, testing::ext::TestSize.Level1) 165 { 166 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_RemoveUser_0001"; 167 auto &service = MultiUserManagerService::GetInstance(); 168 int32_t userId = 104; 169 uint32_t flag = 3; 170 int32_t result; 171 result = service.RemoveUser(userId, flag); 172 EXPECT_EQ(result, E_OK); 173 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_RemoveUser_0001"; 174 } 175 176 /** 177 * @tc.number: SUB_STORAGE_User_manager_service_RemoveUser_0002 178 * @tc.name: User_manager_service_RemoveUser_0002 179 * @tc.desc: Test function of RemoveUser interface for Parameters ERROR which userId<0. 180 * @tc.size: MEDIUM 181 * @tc.type: FUNC 182 * @tc.level Level 1 183 * @tc.require: AR000GK4HB 184 */ 185 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_RemoveUser_0002, testing::ext::TestSize.Level1) 186 { 187 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_RemoveUser_0002"; 188 auto &service = MultiUserManagerService::GetInstance(); 189 int32_t userId = -2; 190 uint32_t flag = 3; 191 int32_t result; 192 service.PrepareAddUser(userId, flag); 193 result = service.RemoveUser(userId, flag); 194 EXPECT_EQ(result, E_USERID_RANGE); 195 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_RemoveUser_0002"; 196 } 197 198 /** 199 * @tc.number: SUB_STORAGE_User_manager_service_PrepareStartUser_0000 200 * @tc.name: User_manager_service_PrepareStartUser_0000 201 * @tc.desc: Test function of PrepareStartUser interface for SUCCESS. 202 * @tc.size: MEDIUM 203 * @tc.type: FUNC 204 * @tc.level Level 1 205 * @tc.require: AR000GK4HB 206 */ 207 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareStartUser_0000, testing::ext::TestSize.Level1) 208 { 209 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareStartUser_0000"; 210 auto &service = MultiUserManagerService::GetInstance(); 211 int32_t userId = 105; 212 uint32_t flag = 3; 213 int32_t result; 214 service.PrepareAddUser(userId, flag); 215 result = service.PrepareStartUser(userId); 216 EXPECT_EQ(result, E_OK); 217 service.StopUser(userId); 218 service.RemoveUser(userId, flag); 219 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareStartUser_0000"; 220 } 221 222 /** 223 * @tc.number: SUB_STORAGE_User_manager_service_PrepareStartUser_0001 224 * @tc.name: User_manager_service_PrepareStartUser_0001 225 * @tc.desc: Test function of PrepareStartUser interface for Logic ERROR which start userId not exist. 226 * @tc.size: MEDIUM 227 * @tc.type: FUNC 228 * @tc.level Level 1 229 * @tc.require: AR000GK4HB 230 */ 231 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_PrepareStartUser_0001, testing::ext::TestSize.Level1) 232 { 233 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareStartUser_0001"; 234 auto &service = MultiUserManagerService::GetInstance(); 235 int32_t userId = 106; 236 int32_t result; 237 result = service.PrepareStartUser(userId); 238 EXPECT_EQ(result, E_OK); 239 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareStartUser_0001"; 240 } 241 242 /** 243 * @tc.number: SUB_STORAGE_User_manager_service_PrepareStartUser_0002 244 * @tc.name: User_manager_service_PrepareStartUser_0002 245 * @tc.desc: Test function of PrepareStartUser interface for Parameters ERROR which userId<0. 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_0002, testing::ext::TestSize.Level1) 252 { 253 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_PrepareStartUser_0002"; 254 auto &service = MultiUserManagerService::GetInstance(); 255 int32_t userId = -4; 256 uint32_t flag = 3; 257 int32_t result; 258 service.PrepareAddUser(userId, flag); 259 result = service.PrepareStartUser(userId); 260 EXPECT_EQ(result, E_USERID_RANGE); 261 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_PrepareStartUser_0002"; 262 } 263 264 /** 265 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0000 266 * @tc.name: User_manager_service_StopUser_0000 267 * @tc.desc: Test function of StopUser interface for SUCCESS. 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_StopUser_0000, testing::ext::TestSize.Level1) 274 { 275 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0000"; 276 auto &service = MultiUserManagerService::GetInstance(); 277 int32_t userId = 108; 278 uint32_t flag = 3; 279 int32_t result; 280 service.PrepareAddUser(userId, flag); 281 service.PrepareStartUser(userId); 282 result = service.StopUser(userId); 283 284 EXPECT_EQ(result, E_OK); 285 service.RemoveUser(userId, flag); 286 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0000"; 287 } 288 289 /** 290 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0001 291 * @tc.name: User_manager_service_StopUser_0001 292 * @tc.desc: Test function of StopUser interface for Logic ERROR which start userId not exist. 293 * @tc.size: MEDIUM 294 * @tc.type: FUNC 295 * @tc.level Level 1 296 * @tc.require: AR000GK4HB 297 */ 298 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_StopUser_0001, testing::ext::TestSize.Level1) 299 { 300 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0001"; 301 auto &service = MultiUserManagerService::GetInstance(); 302 int32_t userId = 109; 303 int32_t result; 304 result = service.StopUser(userId); 305 EXPECT_EQ(result, E_OK); 306 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0001"; 307 } 308 309 /** 310 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0002 311 * @tc.name: User_manager_service_StopUser_0002 312 * @tc.desc: Test function of StopUser interface for Parameters ERROR which userId<0. 313 * @tc.size: MEDIUM 314 * @tc.type: FUNC 315 * @tc.level Level 1 316 * @tc.require: AR000GK4HB 317 */ 318 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_StopUser_0002, testing::ext::TestSize.Level1) 319 { 320 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0002"; 321 auto &service = MultiUserManagerService::GetInstance(); 322 int32_t userId = -6; 323 uint32_t flag = 3; 324 int32_t result; 325 service.PrepareAddUser(userId, flag); 326 service.PrepareStartUser(userId); 327 result = service.StopUser(userId); 328 EXPECT_EQ(result, E_USERID_RANGE); 329 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0002"; 330 } 331 332 /** 333 * @tc.number: SUB_STORAGE_User_manager_service_StopUser_0003 334 * @tc.name: User_manager_service_StopUser_0003 335 * @tc.desc: Test function of StopUser interface for Logic ERROR which stop userId not start. 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_0003, testing::ext::TestSize.Level1) 342 { 343 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_StopUser_0003"; 344 auto &service = MultiUserManagerService::GetInstance(); 345 int32_t userId = 110; 346 uint32_t flag = 3; 347 int32_t result; 348 service.PrepareAddUser(userId, flag); 349 result = service.StopUser(userId); 350 EXPECT_EQ(result, E_OK); 351 service.RemoveUser(userId, flag); 352 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_StopUser_0003"; 353 } 354 355 /** 356 * @tc.number: SUB_STORAGE_User_manager_service_CompleteAddUser_0000 357 * @tc.name: User_manager_service_CompleteAddUser_0000 358 * @tc.desc: Test function of CompleteAddUser success. 359 * @tc.size: MEDIUM 360 * @tc.type: FUNC 361 * @tc.level Level 1 362 * @tc.require: AR000GK4HB 363 */ 364 HWTEST_F(MultiUserManagerServiceTest, User_manager_service_CompleteAddUser_0000, testing::ext::TestSize.Level1) 365 { 366 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-begin User_manager_service_CompleteAddUser_0000"; 367 auto &service = MultiUserManagerService::GetInstance(); 368 int32_t userId = -1; 369 int32_t result; 370 result = service.CompleteAddUser(userId); 371 EXPECT_EQ(result, E_USERID_RANGE); 372 373 userId = 100; 374 result = service.CompleteAddUser(userId); 375 EXPECT_EQ(result, E_OK); 376 GTEST_LOG_(INFO) << "MultiUserManagerServiceTest-end User_manager_service_CompleteAddUser_0000"; 377 } 378 } // namespace 379