1 /* 2 * Copyright (c) 2024 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 /** 17 * @tc.number: SUB_backup_sa_session_GetLastIncrementalTime_0100 18 * @tc.name: SUB_backup_sa_session_GetLastIncrementalTime_0100 19 * @tc.desc: 测试 GetLastIncrementalTime 20 * @tc.size: MEDIUM 21 * @tc.type: FUNC 22 * @tc.level Level 1 23 * @tc.require: I6F3GV 24 */ 25 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetLastIncrementalTime_0100, testing::ext::TestSize.Level1) 26 { 27 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetLastIncrementalTime_0100"; 28 try { 29 EXPECT_TRUE(sessionManagerPtr_ != nullptr); 30 sessionManagerPtr_->impl_.clientToken = 0; 31 sessionManagerPtr_->GetLastIncrementalTime(BUNDLE_NAME); 32 EXPECT_TRUE(true); 33 34 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; 35 sessionManagerPtr_->impl_.backupExtNameMap.clear(); 36 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; 37 sessionManagerPtr_->GetLastIncrementalTime(BUNDLE_NAME); 38 EXPECT_TRUE(true); 39 } catch (...) { 40 EXPECT_TRUE(false); 41 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetLastIncrementalTime."; 42 } 43 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetLastIncrementalTime_0100"; 44 } 45 46 /** 47 * @tc.number: SUB_backup_sa_session_DecreaseSessionCnt_0100 48 * @tc.name: SUB_backup_sa_session_DecreaseSessionCnt_0100 49 * @tc.desc: 测试 DecreaseSessionCnt 50 * @tc.size: MEDIUM 51 * @tc.type: FUNC 52 * @tc.level Level 1 53 * @tc.require: I6F3GV 54 */ 55 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_DecreaseSessionCnt_0100, testing::ext::TestSize.Level1) 56 { 57 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_DecreaseSessionCnt_0100"; 58 try { 59 sessionManagerPtr_->DecreaseSessionCnt(__PRETTY_FUNCTION__); 60 EXPECT_TRUE(true); 61 } catch (...) { 62 EXPECT_TRUE(false); 63 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by DecreaseSessionCnt."; 64 } 65 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_DecreaseSessionCnt_0100"; 66 } 67 68 /** 69 * @tc.number: SUB_backup_sa_session_DecreaseSessionCnt_0101 70 * @tc.name: SUB_backup_sa_session_DecreaseSessionCnt_0101 71 * @tc.desc: 测试 DecreaseSessionCnt 72 * @tc.size: MEDIUM 73 * @tc.type: FUNC 74 * @tc.level Level 1 75 * @tc.require: I6F3GV 76 */ 77 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_DecreaseSessionCnt_0101, testing::ext::TestSize.Level1) 78 { 79 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_DecreaseSessionCnt_0101"; 80 try { 81 sessionManagerPtr_->IncreaseSessionCnt(__PRETTY_FUNCTION__); 82 sessionManagerPtr_->DecreaseSessionCnt(__PRETTY_FUNCTION__); 83 EXPECT_TRUE(true); 84 } catch (...) { 85 EXPECT_TRUE(false); 86 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by DecreaseSessionCnt."; 87 } 88 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_DecreaseSessionCnt_0101"; 89 } 90 91 /** 92 * @tc.number: SUB_backup_sa_session_GetServiceSchedAction_0104 93 * @tc.name: SUB_backup_sa_session_GetServiceSchedAction_0104 94 * @tc.desc: 测试 GetServiceSchedAction 获取状态 95 * @tc.size: MEDIUM 96 * @tc.type: FUNC 97 * @tc.level Level 1 98 * @tc.require: I6F3GV 99 */ 100 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceSchedAction_0104, testing::ext::TestSize.Level1) 101 { 102 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetServiceSchedAction_0104"; 103 try { 104 try { 105 EXPECT_TRUE(sessionManagerPtr_ != nullptr); 106 sessionManagerPtr_->impl_.clientToken = 0; 107 sessionManagerPtr_->GetServiceSchedAction(BUNDLE_NAME); 108 EXPECT_TRUE(true); 109 } catch (BError &err) { 110 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); 111 } 112 } catch (...) { 113 EXPECT_TRUE(false); 114 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetServiceSchedAction."; 115 } 116 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetServiceSchedAction_0104"; 117 } 118 119 /** 120 * @tc.number: SUB_backup_sa_session_GetServiceSchedAction_0105 121 * @tc.name: SUB_backup_sa_session_GetServiceSchedAction_0105 122 * @tc.desc: 测试 GetServiceSchedAction 获取状态 123 * @tc.size: MEDIUM 124 * @tc.type: FUNC 125 * @tc.level Level 1 126 * @tc.require: I6F3GV 127 */ 128 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceSchedAction_0105, testing::ext::TestSize.Level1) 129 { 130 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetServiceSchedAction_0105"; 131 try { 132 try { 133 EXPECT_TRUE(sessionManagerPtr_ != nullptr); 134 sessionManagerPtr_->impl_.clientToken = 0; 135 sessionManagerPtr_->SetServiceSchedAction(BUNDLE_NAME, BConstants::ServiceSchedAction::RUNNING); 136 EXPECT_TRUE(true); 137 } catch (BError &err) { 138 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); 139 } 140 } catch (...) { 141 EXPECT_TRUE(false); 142 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetServiceSchedAction."; 143 } 144 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetServiceSchedAction_0105"; 145 } 146 147 /** 148 * @tc.number: SUB_backup_sa_session_CleanAndCheckIfNeedWait_0100 149 * @tc.name: SUB_backup_sa_session_CleanAndCheckIfNeedWait_0100 150 * @tc.desc: 测试 CleanAndCheckIfNeedWait 151 * @tc.size: MEDIUM 152 * @tc.type: FUNC 153 * @tc.level Level 1 154 * @tc.require: I6F3GV 155 */ 156 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_CleanAndCheckIfNeedWait_0100, testing::ext::TestSize.Level1) 157 { 158 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_CleanAndCheckIfNeedWait_0100"; 159 try { 160 ErrCode err; 161 std::vector<std::string> bundleNameList; 162 bundleNameList.push_back(BUNDLE_NAME); 163 164 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; 165 sessionManagerPtr_->impl_.backupExtNameMap.clear(); 166 167 auto ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList); 168 EXPECT_FALSE(ret); 169 170 sessionManagerPtr_->impl_.backupExtNameMap.clear(); 171 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; 172 sessionManagerPtr_->impl_.restoreDataType = RestoreTypeEnum::RESTORE_DATA_READDY; 173 ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList); 174 EXPECT_FALSE(ret); 175 176 sessionManagerPtr_->impl_.backupExtNameMap.clear(); 177 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; 178 sessionManagerPtr_->impl_.restoreDataType = RestoreTypeEnum::RESTORE_DATA_WAIT_SEND; 179 ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList); 180 EXPECT_FALSE(ret); 181 } catch (...) { 182 EXPECT_TRUE(false); 183 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by CleanAndCheckIfNeedWait."; 184 } 185 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_CleanAndCheckIfNeedWait_0100"; 186 } 187 188 /** 189 * @tc.number: SUB_backup_sa_session_CleanAndCheckIfNeedWait_0200 190 * @tc.name: SUB_backup_sa_session_CleanAndCheckIfNeedWait_0200 191 * @tc.desc: 测试 CleanAndCheckIfNeedWait 192 * @tc.size: MEDIUM 193 * @tc.type: FUNC 194 * @tc.level Level 1 195 * @tc.require: I6F3GV 196 */ 197 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_CleanAndCheckIfNeedWait_0200, testing::ext::TestSize.Level1) 198 { 199 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_CleanAndCheckIfNeedWait_0200"; 200 try { 201 ErrCode err; 202 std::vector<std::string> bundleNameList; 203 bundleNameList.push_back(BUNDLE_NAME); 204 205 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; 206 207 BackupExtInfo extInfo {}; 208 extInfo.schedAction = BConstants::ServiceSchedAction::WAIT; 209 extInfo.backUpConnection = nullptr; 210 sessionManagerPtr_->impl_.backupExtNameMap.clear(); 211 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = extInfo; 212 auto ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList); 213 EXPECT_FALSE(ret); 214 215 BackupExtInfo extInfo2 {}; 216 extInfo2.schedAction = BConstants::ServiceSchedAction::RUNNING; 217 extInfo2.isInPublishFile = true; 218 extInfo2.backUpConnection = nullptr; 219 extInfo2.fwkTimerStatus = true; 220 extInfo2.extTimerStatus = false; 221 sessionManagerPtr_->impl_.backupExtNameMap.clear(); 222 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = extInfo2; 223 ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList); 224 EXPECT_TRUE(ret); 225 226 BackupExtInfo extInfo3 {}; 227 extInfo3.schedAction = BConstants::ServiceSchedAction::START; 228 extInfo3.isInPublishFile = true; 229 extInfo3.backUpConnection = nullptr; 230 extInfo3.fwkTimerStatus = true; 231 extInfo3.extTimerStatus = false; 232 sessionManagerPtr_->impl_.backupExtNameMap.clear(); 233 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = extInfo3; 234 ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList); 235 EXPECT_FALSE(ret); 236 } catch (...) { 237 EXPECT_TRUE(false); 238 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by CleanAndCheckIfNeedWait."; 239 } 240 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_CleanAndCheckIfNeedWait_0200"; 241 } 242 243 /** 244 * @tc.number: SUB_backup_sa_session_CleanAndCheckIfNeedWait_0300 245 * @tc.name: SUB_backup_sa_session_CleanAndCheckIfNeedWait_0300 246 * @tc.desc: 测试 CleanAndCheckIfNeedWait 247 * @tc.size: MEDIUM 248 * @tc.type: FUNC 249 * @tc.level Level 1 250 * @tc.require: I6F3GV 251 */ 252 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_CleanAndCheckIfNeedWait_0300, testing::ext::TestSize.Level1) 253 { 254 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_CleanAndCheckIfNeedWait_0300"; 255 try { 256 ErrCode err; 257 std::vector<std::string> bundleNameList; 258 bundleNameList.push_back(BUNDLE_NAME); 259 260 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; 261 262 BackupExtInfo extInfo {}; 263 extInfo.schedAction = BConstants::ServiceSchedAction::WAIT; 264 extInfo.backUpConnection = sptr(new SvcBackupConnection(nullptr, nullptr, BUNDLE_NAME));; 265 sessionManagerPtr_->impl_.backupExtNameMap.clear(); 266 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = extInfo; 267 auto ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList); 268 EXPECT_FALSE(ret); 269 270 BackupExtInfo extInfo2 {}; 271 extInfo2.schedAction = BConstants::ServiceSchedAction::RUNNING; 272 extInfo2.isInPublishFile = true; 273 extInfo2.backUpConnection = sptr(new SvcBackupConnection(nullptr, nullptr, BUNDLE_NAME));; 274 extInfo2.fwkTimerStatus = true; 275 extInfo2.extTimerStatus = false; 276 sessionManagerPtr_->impl_.backupExtNameMap.clear(); 277 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = extInfo2; 278 ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList); 279 EXPECT_TRUE(ret); 280 281 BackupExtInfo extInfo3 {}; 282 extInfo3.schedAction = BConstants::ServiceSchedAction::START; 283 extInfo3.isInPublishFile = true; 284 extInfo3.backUpConnection = sptr(new SvcBackupConnection(nullptr, nullptr, BUNDLE_NAME));; 285 extInfo3.fwkTimerStatus = true; 286 extInfo3.extTimerStatus = false; 287 sessionManagerPtr_->impl_.backupExtNameMap.clear(); 288 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = extInfo3; 289 ret = sessionManagerPtr_->CleanAndCheckIfNeedWait(err, bundleNameList); 290 EXPECT_FALSE(ret); 291 } catch (...) { 292 EXPECT_TRUE(false); 293 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by CleanAndCheckIfNeedWait."; 294 } 295 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_CleanAndCheckIfNeedWait_0300"; 296 }