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 <cstring> 18 #include <fcntl.h> 19 #include <iostream> 20 #include <sys/mman.h> 21 #include <sys/stat.h> 22 #include <unistd.h> 23 #include "client_stub.h" 24 #include "gmock/gmock.h" 25 #include "gtest/gtest.h" 26 #include "iupdate_service.h" 27 #include "log.h" 28 #include "napi/native_api.h" 29 #include "napi/native_node_api.h" 30 #include "node_api.h" 31 #include "node_api_types.h" 32 #include "unittest_comm.h" 33 #include "update_helper.h" 34 #include "update_service.h" 35 #include "update_session.h" 36 37 using namespace std; 38 using namespace updateClient; 39 using namespace testing::ext; 40 using namespace OHOS::update_engine; 41 static constexpr int PERCENT_20 = 20; 42 static constexpr int PERCENT_40 = 40; 43 static constexpr int PERCENT_60 = 60; 44 static constexpr int PERCENT_100 = 100; 45 static constexpr int NUMBER_2 = 2; 46 47 extern TestNApiEnv g_testEnv; 48 extern uint32_t g_testSessionId; 49 extern bool g_callbackFuncationCalled; 50 extern UpdateClient* g_testClient; 51 52 namespace { 53 #define CHECK_RESULT_EQ(ret, value) EXPECT_EQ(((TestNApiValue*)(ret))->intValue, (value)); 54 const int32_t JSON_MAX_SIZE = 4096; 55 56 class UpdateClientTest : public ::testing::Test { 57 public: UpdateClientTest()58 UpdateClientTest() {} ~UpdateClientTest()59 virtual ~UpdateClientTest() {} 60 SetUp()61 void SetUp() {} TearDown()62 void TearDown() {} TestBody()63 void TestBody() {} 64 GetJsonInfo(VersionInfo & info) const65 int GetJsonInfo(VersionInfo &info) const 66 { 67 std::string jsonFileName = TEST_PATH_FROM; 68 jsonFileName += "packageInfos.json"; 69 70 std::vector<char> buffer(JSON_MAX_SIZE); 71 FILE *fp = fopen(jsonFileName.c_str(), "r"); 72 CLIENT_CHECK(fp != nullptr, return -1, "parse json error %s", jsonFileName.c_str()); 73 size_t bytes = fread(buffer.data(), 1, JSON_MAX_SIZE, fp); 74 if (bytes > 0) { 75 int32_t ret = UpdateService::ParseJsonFile(buffer, info); 76 CLIENT_CHECK(ret == 0, return 0, "parse json error"); 77 } 78 return 0; 79 } 80 TestGetUpdate(bool noneClient)81 int TestGetUpdate(bool noneClient) 82 { 83 g_testEnv.testStage = SESSION_GET_UPDATER; 84 g_testEnv.engineType = 0; 85 g_testEnv.noneClient = noneClient; 86 g_testEnv.eventType = "/data/updater/updater/updater.zip"; 87 napi_value value = GetUpdater((napi_env)&g_testEnv, nullptr); 88 CLIENT_CHECK(value == nullptr, return -1, "TestGetUpdate"); 89 return 0; 90 } 91 TestGetUpdaterForOther(bool noneClient)92 int TestGetUpdaterForOther(bool noneClient) 93 { 94 g_testEnv.testStage = SESSION_GET_UPDATER; 95 g_testEnv.engineType = 1; 96 g_testEnv.noneClient = noneClient; 97 g_testEnv.eventType = "OTA"; 98 napi_value value = GetUpdaterForOther((napi_env)&g_testEnv, nullptr); 99 CLIENT_CHECK(value == nullptr, return -1, "TestGetUpdate"); 100 return 0; 101 } 102 TestGetUpdaterFromOther(bool noneClient)103 int TestGetUpdaterFromOther(bool noneClient) 104 { 105 g_testEnv.testStage = SESSION_GET_UPDATER; 106 g_testEnv.engineType = NUMBER_2; 107 g_testEnv.noneClient = noneClient; 108 g_testEnv.eventType = "OTA"; 109 napi_value value = GetUpdaterFromOther((napi_env)&g_testEnv, nullptr); 110 CLIENT_CHECK(value == nullptr, return -1, "TestGetUpdate"); 111 return 0; 112 } 113 TestCheckNewVersion(bool isPormise)114 int TestCheckNewVersion(bool isPormise) 115 { 116 g_testEnv.testStage = SESSION_CHECK_VERSION; 117 g_testEnv.testAsyncorPermose = isPormise; 118 napi_value value = CheckNewVersion((napi_env)&g_testEnv, nullptr); 119 EXPECT_NE(value, nullptr); 120 121 // Trigger thread execution 122 UpdateSession *sess = TestGetUpdateSession(); 123 CLIENT_CHECK(sess != nullptr, return -1, "TestCheckNewVersion"); 124 UpdateResult result = {}; 125 sess->NotifyJS((napi_env)&g_testEnv, nullptr, 0, result); 126 UpdateSession::ExecuteWork((napi_env)&g_testEnv, (void*)sess); 127 128 // Call back the search result and save the result information 129 VersionInfo info; 130 int ret = GetJsonInfo(info); 131 EXPECT_EQ(ret, 0); 132 g_testClient->NotifyCheckVersionDone(info); 133 134 // end of execution 135 UpdateSession::CompleteWork((napi_env)&g_testEnv, napi_status::napi_ok, (void*)sess); 136 137 // Check the data 138 CLIENT_LOGI("g_testEnv.pakcageInfo.versionCode %s \n", g_testEnv.pakcageInfo.result[0].versionCode.c_str()); 139 CLIENT_LOGI("info.result[0].versionCode %s \n", info.result[0].versionCode.c_str()); 140 141 FreeAllNapiValues(); 142 return 0; 143 } 144 TestDownloadVersion(bool isPormise)145 int TestDownloadVersion(bool isPormise) 146 { 147 g_testEnv.testStage = SESSION_DOWNLOAD; 148 g_testEnv.testAsyncorPermose = isPormise; 149 napi_value value = DownloadVersion((napi_env)&g_testEnv, nullptr); 150 EXPECT_NE(value, nullptr); 151 152 // Trigger thread execution 153 UpdateSession *sess = TestGetUpdateSession(); 154 CLIENT_CHECK(sess != nullptr, return -1, "TestDownloadVersion"); 155 UpdateSession::ExecuteWork((napi_env)&g_testEnv, (void*)sess); 156 157 // Call back the download result and save the result information 158 Progress info; 159 info.percent = PERCENT_20; 160 info.status = UPDATE_STATE_DOWNLOAD_ON; 161 g_testClient->NotifyDownloadProgress(info); 162 163 info.percent = PERCENT_40; 164 info.status = UPDATE_STATE_DOWNLOAD_ON; 165 g_testClient->NotifyDownloadProgress(info); 166 167 info.percent = PERCENT_60; 168 info.status = UPDATE_STATE_DOWNLOAD_ON; 169 g_testClient->NotifyDownloadProgress(info); 170 171 info.percent = PERCENT_100; 172 info.status = UPDATE_STATE_DOWNLOAD_SUCCESS; 173 g_testClient->NotifyDownloadProgress(info); 174 175 // end of execution 176 UpdateSession::CompleteWork((napi_env)&g_testEnv, napi_status::napi_ok, (void*)sess); 177 178 FreeAllNapiValues(); 179 return 0; 180 } 181 TestUpgradeVersion(bool isPormise)182 int TestUpgradeVersion(bool isPormise) 183 { 184 g_testEnv.testStage = SESSION_UPGRADE; 185 g_testEnv.testAsyncorPermose = isPormise; 186 napi_value value = UpgradeVersion((napi_env)&g_testEnv, nullptr); 187 CLIENT_CHECK(value != nullptr, return -1, "UpgradeVersion"); 188 189 // Trigger thread execution 190 UpdateSession *sess = TestGetUpdateSession(); 191 CLIENT_CHECK(sess != nullptr, return -1, "UpgradeVersion"); 192 UpdateSession::ExecuteWork((napi_env)&g_testEnv, (void*)sess); 193 194 // Call back the download result and save the result information 195 Progress info; 196 info.percent = PERCENT_20; 197 info.status = UPDATE_STATE_DOWNLOAD_ON; 198 g_testClient->NotifyUpgradeProgresss(info); 199 200 info.percent = PERCENT_40; 201 info.status = UPDATE_STATE_DOWNLOAD_ON; 202 g_testClient->NotifyUpgradeProgresss(info); 203 204 info.percent = PERCENT_60; 205 info.status = UPDATE_STATE_DOWNLOAD_ON; 206 g_testClient->NotifyUpgradeProgresss(info); 207 208 info.percent = PERCENT_100; 209 info.status = UPDATE_STATE_DOWNLOAD_SUCCESS; 210 g_testClient->NotifyUpgradeProgresss(info); 211 212 // end of execution 213 UpdateSession::CompleteWork((napi_env)&g_testEnv, napi_status::napi_ok, (void*)sess); 214 215 FreeAllNapiValues(); 216 return 0; 217 } 218 TestSetUpdatePolicy(bool isPormise)219 int TestSetUpdatePolicy(bool isPormise) 220 { 221 g_testEnv.testStage = SESSION_SET_POLICY; 222 g_testEnv.testAsyncorPermose = isPormise; 223 napi_value value = SetUpdatePolicy((napi_env)&g_testEnv, nullptr); 224 EXPECT_NE(value, nullptr); 225 226 printf("TestSetUpdatePolicy \n"); 227 // Trigger thread execution 228 UpdateSession *sess = TestGetUpdateSession(); 229 CLIENT_CHECK(sess != nullptr, return -1, "TestSetUpdatePolicy"); 230 UpdateSession::ExecuteWork((napi_env)&g_testEnv, (void*)sess); 231 // end of execution 232 UpdateSession::CompleteWork((napi_env)&g_testEnv, napi_status::napi_ok, (void*)sess); 233 234 FreeAllNapiValues(); 235 return 0; 236 } 237 TestGetUpdatePolicy(bool isPormise)238 int TestGetUpdatePolicy(bool isPormise) 239 { 240 g_testEnv.testStage = SESSION_GET_POLICY; 241 g_testEnv.testAsyncorPermose = isPormise; 242 napi_value value = GetUpdatePolicy((napi_env)&g_testEnv, nullptr); 243 EXPECT_NE(value, nullptr); 244 245 // Trigger thread execution 246 UpdateSession *sess = TestGetUpdateSession(); 247 CLIENT_CHECK(sess != nullptr, return -1, "TestGetUpdatePolicy"); 248 UpdateSession::ExecuteWork((napi_env)&g_testEnv, (void*)sess); 249 // end of execution 250 UpdateSession::CompleteWork((napi_env)&g_testEnv, napi_status::napi_ok, (void*)sess); 251 252 FreeAllNapiValues(); 253 return 0; 254 } 255 TestGetNewVersionInfo(bool isPormise)256 int TestGetNewVersionInfo(bool isPormise) 257 { 258 g_testEnv.testStage = SESSION_GET_NEW_VERSION; 259 g_testEnv.testAsyncorPermose = isPormise; 260 napi_value value = GetNewVersionInfo((napi_env)&g_testEnv, nullptr); 261 EXPECT_NE(value, nullptr); 262 // Trigger thread execution 263 UpdateSession *sess = TestGetUpdateSession(); 264 CLIENT_CHECK(sess != nullptr, return -1, "TestGetNewVersionInfo"); 265 UpdateSession::ExecuteWork((napi_env)&g_testEnv, (void*)sess); 266 // end of execution 267 UpdateSession::CompleteWork((napi_env)&g_testEnv, napi_status::napi_ok, (void*)sess); 268 269 FreeAllNapiValues(); 270 return 0; 271 } 272 TestGetUpgradeStatus(bool isPormise)273 int TestGetUpgradeStatus(bool isPormise) 274 { 275 g_testEnv.testStage = SESSION_GET_STATUS; 276 g_testEnv.testAsyncorPermose = isPormise; 277 napi_value value = GetUpgradeStatus((napi_env)&g_testEnv, nullptr); 278 EXPECT_NE(value, nullptr); 279 280 // Trigger thread execution 281 UpdateSession *sess = TestGetUpdateSession(); 282 CLIENT_CHECK(sess != nullptr, return -1, "TestGetUpgradeStatus"); 283 UpdateSession::ExecuteWork((napi_env)&g_testEnv, (void*)sess); 284 // end of execution 285 UpdateSession::CompleteWork((napi_env)&g_testEnv, napi_status::napi_ok, (void*)sess); 286 287 FreeAllNapiValues(); 288 return 0; 289 } 290 TestApplyNewVersion(bool isPormise)291 int TestApplyNewVersion(bool isPormise) 292 { 293 g_testEnv.testStage = SESSION_APPLY_NEW_VERSION; 294 g_testEnv.testAsyncorPermose = isPormise; 295 napi_value value = ApplyNewVersion((napi_env)&g_testEnv, nullptr); 296 EXPECT_NE(value, nullptr); 297 298 // Trigger thread execution 299 UpdateSession *sess = TestGetUpdateSession(); 300 CLIENT_CHECK(sess != nullptr, return -1, "TestApplyNewVersion"); 301 UpdateSession::ExecuteWork((napi_env)&g_testEnv, (void*)sess); 302 // end of execution 303 UpdateSession::CompleteWork((napi_env)&g_testEnv, napi_status::napi_ok, (void*)sess); 304 305 FreeAllNapiValues(); 306 return 0; 307 } 308 TestRebootAndClean(bool isPormise)309 int TestRebootAndClean(bool isPormise) 310 { 311 g_testEnv.testStage = SESSION_REBOOT_AND_CLEAN; 312 g_testEnv.testAsyncorPermose = isPormise; 313 napi_value value = RebootAndClean((napi_env)&g_testEnv, nullptr); 314 EXPECT_NE(value, nullptr); 315 316 // Trigger thread execution 317 UpdateSession *sess = TestGetUpdateSession(); 318 CLIENT_CHECK(sess != nullptr, return -1, "TestRebootAndClean"); 319 UpdateSession::ExecuteWork((napi_env)&g_testEnv, (void*)sess); 320 // end of execution 321 UpdateSession::CompleteWork((napi_env)&g_testEnv, napi_status::napi_ok, (void*)sess); 322 323 FreeAllNapiValues(); 324 return 0; 325 } 326 TestVerifyUpdatePackage(bool isPormise)327 int TestVerifyUpdatePackage(bool isPormise) 328 { 329 g_testEnv.testStage = SESSION_VERIFY_PACKAGE; 330 g_testEnv.testAsyncorPermose = isPormise; 331 napi_value value = VerifyUpdatePackage((napi_env)&g_testEnv, nullptr); 332 EXPECT_NE(value, nullptr); 333 // Trigger thread execution 334 UpdateSession *sess = TestGetUpdateSession(); 335 CLIENT_CHECK(sess != nullptr, return -1, "TestVerifyUpdatePackage"); 336 UpdateSession *sess1 = static_cast<UpdateSession*>(sess); 337 EXPECT_NE(sess1, nullptr); 338 sess1->UpdateSession::CompleteWork((napi_env)&g_testEnv, napi_status::napi_ok); 339 UpdateSession::ExecuteWork((napi_env)&g_testEnv, (void*)sess); 340 341 // Call back the download result and save the result information 342 g_testClient->NotifyVerifyProgresss(0, PERCENT_60); 343 g_testClient->NotifyVerifyProgresss(0, PERCENT_100); 344 345 // end of execution 346 UpdateSession::CompleteWork((napi_env)&g_testEnv, napi_status::napi_ok, (void*)sess); 347 FreeAllNapiValues(); 348 return 0; 349 } 350 TestSubscribeEvent(const std::string & eventType)351 int TestSubscribeEvent(const std::string &eventType) 352 { 353 g_testEnv.testStage = SESSION_SUBSCRIBE; 354 g_testEnv.testAsyncorPermose = false; 355 g_testEnv.eventType = eventType; 356 napi_value value = SubscribeEvent((napi_env)&g_testEnv, nullptr); 357 CLIENT_CHECK(value != nullptr, return -1, "TestSubscribeEvent"); 358 359 Progress info; 360 info.percent = PERCENT_20; 361 info.status = UPDATE_STATE_DOWNLOAD_ON; 362 g_testClient->NotifyUpgradeProgresss(info); 363 364 info.percent = PERCENT_40; 365 info.status = UPDATE_STATE_DOWNLOAD_ON; 366 g_testClient->NotifyUpgradeProgresss(info); 367 368 info.percent = PERCENT_60; 369 info.status = UPDATE_STATE_DOWNLOAD_ON; 370 g_testClient->NotifyDownloadProgress(info); 371 372 info.percent = PERCENT_100; 373 info.status = UPDATE_STATE_DOWNLOAD_SUCCESS; 374 g_testClient->NotifyDownloadProgress(info); 375 FreeAllNapiValues(); 376 return 0; 377 } 378 TestUnsubscribeEvent(bool isPormise,const std::string & eventType)379 int TestUnsubscribeEvent(bool isPormise, const std::string &eventType) 380 { 381 g_testEnv.testStage = SESSION_UNSUBSCRIBE; 382 g_testEnv.testAsyncorPermose = isPormise; 383 g_testEnv.eventType = eventType; 384 napi_value value = UnsubscribeEvent((napi_env)&g_testEnv, nullptr); 385 CLIENT_CHECK(value != nullptr, return -1, "TestUnsubscribeEvent"); 386 387 FreeAllNapiValues(); 388 return 0; 389 } 390 TestCancelUpgrade(int type)391 int TestCancelUpgrade(int type) 392 { 393 g_testEnv.testStage = SESSION_CANCEL_UPGRADE; 394 g_testEnv.testAsyncorPermose = true; 395 napi_value value = CancelUpgrade((napi_env)&g_testEnv, nullptr); 396 CLIENT_CHECK(value != nullptr, return -1, "TestCancelUpgrade"); 397 398 // Trigger thread execution 399 UpdateSession *sess = TestGetUpdateSession(); 400 CLIENT_CHECK(sess != nullptr, return -1, "TestCancelUpgrade"); 401 UpdateSession::ExecuteWork((napi_env)&g_testEnv, (void*)sess); 402 // end of execution 403 UpdateSession::CompleteWork((napi_env)&g_testEnv, napi_status::napi_ok, (void*)sess); 404 405 FreeAllNapiValues(); 406 return 0; 407 } 408 }; 409 410 HWTEST_F(UpdateClientTest, TestGetUpdate, TestSize.Level1) 411 { 412 napi_value exports = nullptr; 413 UpdateClientInit((napi_env)&g_testEnv, exports); 414 UpdateClientTest test; 415 test.TestGetUpdate(false); 416 test.TestGetUpdaterFromOther(false); 417 test.TestGetUpdaterForOther(false); 418 } 419 420 HWTEST_F(UpdateClientTest, TestGetUpdate2, TestSize.Level1) 421 { 422 UpdateClientTest test; 423 test.TestGetUpdate(true); 424 test.TestGetUpdaterFromOther(true); 425 test.TestGetUpdaterForOther(true); 426 } 427 428 HWTEST_F(UpdateClientTest, TestCheckNewVersion, TestSize.Level1) 429 { 430 UpdateClientTest test; 431 test.TestGetUpdate(false); 432 EXPECT_EQ(0, test.TestCheckNewVersion(false)); 433 EXPECT_EQ(0, test.TestCheckNewVersion(true)); 434 } 435 436 HWTEST_F(UpdateClientTest, TestDownloadVersion, TestSize.Level1) 437 { 438 UpdateClientTest test; 439 EXPECT_EQ(0, test.TestDownloadVersion(false)); 440 EXPECT_EQ(0, test.TestDownloadVersion(true)); 441 } 442 443 HWTEST_F(UpdateClientTest, TestUpgradeVersion, TestSize.Level1) 444 { 445 UpdateClientTest test; 446 EXPECT_EQ(0, test.TestUpgradeVersion(false)); 447 EXPECT_EQ(0, test.TestUpgradeVersion(true)); 448 } 449 450 HWTEST_F(UpdateClientTest, TestSetUpdatePolicy, TestSize.Level1) 451 { 452 UpdateClientTest test; 453 EXPECT_EQ(0, test.TestSetUpdatePolicy(false)); 454 EXPECT_EQ(0, test.TestSetUpdatePolicy(true)); 455 } 456 457 HWTEST_F(UpdateClientTest, TestGetUpdatePolicy, TestSize.Level1) 458 { 459 UpdateClientTest test; 460 EXPECT_EQ(0, test.TestGetUpdatePolicy(false)); 461 EXPECT_EQ(0, test.TestGetUpdatePolicy(true)); 462 } 463 464 HWTEST_F(UpdateClientTest, TestGetUpgradeStatus, TestSize.Level1) 465 { 466 UpdateClientTest test; 467 EXPECT_EQ(0, test.TestGetUpgradeStatus(false)); 468 EXPECT_EQ(0, test.TestGetUpgradeStatus(true)); 469 } 470 471 HWTEST_F(UpdateClientTest, TestGetNewVersionInfo, TestSize.Level1) 472 { 473 UpdateClientTest test; 474 EXPECT_EQ(0, test.TestGetNewVersionInfo(false)); 475 EXPECT_EQ(0, test.TestGetNewVersionInfo(true)); 476 } 477 478 HWTEST_F(UpdateClientTest, TestApplyNewVersion, TestSize.Level1) 479 { 480 UpdateClientTest test; 481 EXPECT_EQ(0, test.TestApplyNewVersion(false)); 482 EXPECT_EQ(0, test.TestApplyNewVersion(true)); 483 } 484 485 HWTEST_F(UpdateClientTest, TestRebootAndClean, TestSize.Level1) 486 { 487 UpdateClientTest test; 488 EXPECT_EQ(0, test.TestRebootAndClean(false)); 489 EXPECT_EQ(0, test.TestRebootAndClean(true)); 490 } 491 492 HWTEST_F(UpdateClientTest, TestVerifyUpdatePackage, TestSize.Level1) 493 { 494 UpdateClientTest test; 495 EXPECT_EQ(0, test.TestVerifyUpdatePackage(false)); 496 EXPECT_EQ(0, test.TestVerifyUpdatePackage(true)); 497 } 498 499 HWTEST_F(UpdateClientTest, TestSubscribeEvent, TestSize.Level1) 500 { 501 UpdateClientTest test; 502 EXPECT_EQ(0, test.TestSubscribeEvent("downloadProgress")); 503 EXPECT_EQ(0, test.TestUnsubscribeEvent(false, "downloadProgress")); 504 } 505 506 HWTEST_F(UpdateClientTest, TestSubscribeEvent2, TestSize.Level1) 507 { 508 UpdateClientTest test; 509 EXPECT_EQ(0, test.TestSubscribeEvent("downloadProgress")); 510 EXPECT_EQ(0, test.TestUnsubscribeEvent(true, "downloadProgress")); 511 } 512 513 HWTEST_F(UpdateClientTest, TestSubscribeEvent3, TestSize.Level1) 514 { 515 UpdateClientTest test; 516 EXPECT_EQ(0, test.TestSubscribeEvent("upgradeProgress")); 517 EXPECT_EQ(0, test.TestUnsubscribeEvent(false, "upgradeProgress")); 518 } 519 520 HWTEST_F(UpdateClientTest, TestSubscribeEvent4, TestSize.Level1) 521 { 522 UpdateClientTest test; 523 EXPECT_EQ(0, test.TestSubscribeEvent("upgradeProgress")); 524 EXPECT_EQ(0, test.TestUnsubscribeEvent(true, "upgradeProgress")); 525 } 526 527 HWTEST_F(UpdateClientTest, TestCancelUpgrade, TestSize.Level1) 528 { 529 UpdateClientTest test; 530 EXPECT_EQ(0, test.TestCancelUpgrade(2)); 531 EXPECT_EQ(0, test.TestCancelUpgrade(3)); 532 } 533 534 HWTEST_F(UpdateClientTest, TestNewClient, TestSize.Level1) 535 { 536 napi_value thisVar = nullptr; 537 UpdateClient *client = new UpdateClient((napi_env)&g_testEnv, thisVar); 538 delete client; 539 } 540 541 HWTEST_F(UpdateClientTest, TestUpdateAsyncessionNoCallback, TestSize.Level1) 542 { 543 UpdateSession *sess = new UpdateAsyncessionNoCallback(g_testClient, 2, 1, 0); 544 EXPECT_NE(sess, nullptr); 545 delete sess; 546 } 547 548 HWTEST_F(UpdateClientTest, TestUpdatePromiseSession, TestSize.Level1) 549 { 550 UpdateSession *sess = new UpdatePromiseSession (g_testClient, 2, 1, 0); 551 EXPECT_NE(sess, nullptr); 552 delete sess; 553 } 554 } // namespace 555