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 #define final // disable final keyword 17 #define LOG_TAG "ProfilerServiceTest" 18 19 #include <grpcpp/grpcpp.h> 20 #include <grpcpp/health_check_service_interface.h> 21 #include <hwext/gtest-ext.h> 22 #include <hwext/gtest-tag.h> 23 #include <thread> 24 25 #include "logging.h" 26 #include "plugin_service.h" 27 #include "profiler_capability_manager.h" 28 #include "profiler_data_repeater.h" 29 #include "profiler_service.h" 30 #include "schedule_task_manager.h" 31 32 using namespace testing::ext; 33 34 using ProfilerServicePtr = STD_PTR(shared, ProfilerService); 35 36 namespace { 37 constexpr int ROUND_COUNT = 200; 38 constexpr int FETCH_DATA_DELAY_US = 100 * 1000; 39 constexpr int TEST_SESSION_TIMEOUT_MS = 1000; 40 constexpr int TIMEOUT_US = 3 * 1000 * 1000; 41 42 class Timer { 43 public: 44 using Clock = std::chrono::steady_clock; 45 using TimePoint = Clock::time_point; 46 Timer()47 Timer() : startTime_(Now()) {} 48 ~Timer()49 ~Timer() {} 50 ElapsedUs()51 long ElapsedUs() 52 { 53 auto currentTime = Now(); 54 return std::chrono::duration_cast<std::chrono::microseconds>(currentTime - startTime_).count(); 55 } 56 Reset()57 void Reset() 58 { 59 startTime_ = Now(); 60 } 61 62 protected: Now()63 TimePoint Now() 64 { 65 return Clock::now(); 66 } 67 68 private: 69 TimePoint startTime_; 70 }; 71 72 class ProfilerServiceTest : public ::testing::Test { 73 protected: 74 PluginServicePtr pluginService_; 75 ProfilerServicePtr service_; 76 77 PluginInfo pluginInfo; 78 std::unique_ptr<grpc::ServerContext> context_; 79 std::atomic<int> requestCounter = 0; 80 SetUpTestCase()81 static void SetUpTestCase() {} TearDownTestCase()82 static void TearDownTestCase() {} 83 SetUp()84 void SetUp() override 85 { 86 pluginInfo.name = "test_plugin"; 87 pluginService_ = std::make_shared<PluginService>(); 88 if (pluginService_) { 89 pluginService_->AddPluginInfo(pluginInfo); 90 } 91 service_ = std::make_shared<ProfilerService>(pluginService_); 92 context_ = std::make_unique<grpc::ServerContext>(); 93 } 94 TearDown()95 void TearDown() override 96 { 97 context_.reset(); 98 service_.reset(); 99 if (pluginService_) { 100 pluginService_->RemovePluginInfo(pluginInfo); 101 } 102 pluginService_.reset(); 103 ProfilerCapabilityManager::GetInstance().pluginCapabilities_.clear(); 104 } 105 AddPlugin(const std::string & pluginName)106 void AddPlugin(const std::string& pluginName) 107 { 108 PluginInfo pluginInfo; 109 pluginInfo.name = pluginName; 110 if (pluginService_) { 111 pluginService_->AddPluginInfo(pluginInfo); 112 } 113 } 114 StartSession(uint32_t sessionId)115 grpc::Status StartSession(uint32_t sessionId) 116 { 117 StartSessionRequest request; 118 StartSessionResponse response; 119 120 request.set_session_id(sessionId); 121 request.set_request_id(++requestCounter); 122 return service_->StartSession(context_.get(), &request, &response); 123 } 124 StopSession(uint32_t sessionId)125 grpc::Status StopSession(uint32_t sessionId) 126 { 127 StopSessionRequest request; 128 StopSessionResponse response; 129 130 request.set_session_id(sessionId); 131 request.set_request_id(++requestCounter); 132 return service_->StopSession(context_.get(), &request, &response); 133 } 134 DestroySession(uint32_t sessionId)135 grpc::Status DestroySession(uint32_t sessionId) 136 { 137 DestroySessionRequest request; 138 DestroySessionResponse response; 139 140 request.set_session_id(sessionId); 141 request.set_request_id(++requestCounter); 142 return service_->DestroySession(context_.get(), &request, &response); 143 } 144 CreateOnlineSession()145 uint32_t CreateOnlineSession() 146 { 147 CreateSessionRequest request; 148 CreateSessionResponse response; 149 150 auto sessionConfig = request.mutable_session_config(); 151 CHECK_NOTNULL(sessionConfig, 0, "request.mutable_session_config() return nullptr!"); 152 153 sessionConfig->set_session_mode(ProfilerSessionConfig::ONLINE); 154 auto pluginConfig = request.add_plugin_configs(); 155 CHECK_NOTNULL(pluginConfig, 0, "request.add_plugin_configs() return nullptr!"); 156 157 pluginConfig->set_name(pluginInfo.name); 158 request.set_request_id(++requestCounter); 159 auto status = service_->CreateSession(context_.get(), &request, &response); 160 CHECK_TRUE(status.error_code() == grpc::StatusCode::OK, 0, "create session FAILED!"); 161 162 return response.session_id(); 163 } 164 CreateOfflineSession()165 uint32_t CreateOfflineSession() 166 { 167 CreateSessionRequest request; 168 CreateSessionResponse response; 169 170 auto sessionConfig = request.mutable_session_config(); 171 CHECK_NOTNULL(sessionConfig, 0, "request.mutable_session_config() return nullptr!"); 172 173 sessionConfig->set_session_mode(ProfilerSessionConfig::OFFLINE); 174 sessionConfig->set_result_file("trace.bin"); 175 auto pluginConfig = request.add_plugin_configs(); 176 CHECK_NOTNULL(pluginConfig, 0, "request.add_plugin_configs() return nullptr!"); 177 178 pluginConfig->set_name(pluginInfo.name); 179 request.set_request_id(++requestCounter); 180 auto status = service_->CreateSession(context_.get(), &request, &response); 181 CHECK_TRUE(status.error_code() == grpc::StatusCode::OK, 0, "create session FAILED!"); 182 183 return response.session_id(); 184 } 185 }; 186 187 /** 188 * @tc.name: server 189 * @tc.desc: Abnormal test. 190 * @tc.type: FUNC 191 */ 192 HWTEST_F(ProfilerServiceTest, CtorDtor, TestSize.Level1) 193 { 194 ASSERT_NE(service_, nullptr); 195 } 196 197 /** 198 * @tc.name: server 199 * @tc.desc: get plugin capabilities normal. 200 * @tc.type: FUNC 201 */ 202 HWTEST_F(ProfilerServiceTest, GetCapabilities, TestSize.Level1) 203 { 204 ASSERT_NE(service_, nullptr); 205 ASSERT_NE(context_, nullptr); 206 207 GetCapabilitiesRequest request; 208 auto response = std::make_unique<GetCapabilitiesResponse>(); 209 ASSERT_NE(response, nullptr); 210 211 ProfilerPluginCapability cap; 212 cap.set_name("cap1"); 213 214 request.set_request_id(++requestCounter); 215 auto status = service_->GetCapabilities(context_.get(), &request, response.get()); 216 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 217 EXPECT_EQ(response->capabilities_size(), ProfilerCapabilityManager::GetInstance().GetCapabilities().size()); 218 219 int capSize = response->capabilities_size(); 220 EXPECT_TRUE(ProfilerCapabilityManager::GetInstance().AddCapability(cap)); 221 222 request.set_request_id(++requestCounter); 223 response = std::make_unique<GetCapabilitiesResponse>(); 224 status = service_->GetCapabilities(context_.get(), &request, response.get()); 225 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 226 EXPECT_EQ(response->capabilities_size(), ProfilerCapabilityManager::GetInstance().GetCapabilities().size()); 227 EXPECT_EQ(response->capabilities_size(), capSize + 1); 228 } 229 230 /** 231 * @tc.name: server 232 * @tc.desc: get plugin capabilities normal. 233 * @tc.type: FUNC 234 */ 235 HWTEST_F(ProfilerServiceTest, GetCapabilitiesAfterRemove, TestSize.Level1) 236 { 237 ASSERT_NE(service_, nullptr); 238 ASSERT_NE(context_, nullptr); 239 240 GetCapabilitiesRequest request; 241 auto response = std::make_unique<GetCapabilitiesResponse>(); 242 ASSERT_NE(response, nullptr); 243 244 ProfilerPluginCapability cap; 245 cap.set_name("cap1"); 246 247 request.set_request_id(++requestCounter); 248 auto status = service_->GetCapabilities(context_.get(), &request, response.get()); 249 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 250 EXPECT_EQ(response->capabilities_size(), ProfilerCapabilityManager::GetInstance().GetCapabilities().size()); 251 252 int capSize = response->capabilities_size(); 253 EXPECT_TRUE(ProfilerCapabilityManager::GetInstance().AddCapability(cap)); 254 255 request.set_request_id(++requestCounter); 256 response = std::make_unique<GetCapabilitiesResponse>(); 257 status = service_->GetCapabilities(context_.get(), &request, response.get()); 258 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 259 EXPECT_EQ(response->capabilities_size(), capSize + 1); 260 261 EXPECT_TRUE(ProfilerCapabilityManager::GetInstance().RemoveCapability(cap.name())); 262 response = std::make_unique<GetCapabilitiesResponse>(); 263 status = service_->GetCapabilities(context_.get(), &request, response.get()); 264 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 265 EXPECT_EQ(response->capabilities_size(), ProfilerCapabilityManager::GetInstance().GetCapabilities().size()); 266 EXPECT_EQ(response->capabilities_size(), capSize); 267 } 268 269 /** 270 * @tc.name: server 271 * @tc.desc: get plugin capabilities batch test. 272 * @tc.type: FUNC 273 */ 274 HWTEST_F(ProfilerServiceTest, GetCapabilitiesBatchTest, TestSize.Level1) 275 { 276 ASSERT_NE(service_, nullptr); 277 ASSERT_NE(context_, nullptr); 278 279 GetCapabilitiesRequest request; 280 auto response = std::make_unique<GetCapabilitiesResponse>(); 281 ASSERT_NE(response, nullptr); 282 283 request.set_request_id(++requestCounter); 284 auto status = service_->GetCapabilities(context_.get(), &request, response.get()); 285 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 286 EXPECT_EQ(response->capabilities_size(), ProfilerCapabilityManager::GetInstance().GetCapabilities().size()); 287 288 for (int i = 0; i < ROUND_COUNT; i++) { 289 ProfilerPluginCapability cap; 290 cap.set_name("cap_" + std::to_string(i)); 291 EXPECT_TRUE(ProfilerCapabilityManager::GetInstance().AddCapability(cap)); 292 } 293 294 Timer timer = {}; 295 for (int i = 0; i < ROUND_COUNT; i++) { 296 request.set_request_id(++requestCounter); 297 response = std::make_unique<GetCapabilitiesResponse>(); 298 status = service_->GetCapabilities(context_.get(), &request, response.get()); 299 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 300 } 301 auto timeCost = timer.ElapsedUs(); 302 printf("GetCapabilities %d time cost %ldus.\n", ROUND_COUNT, timeCost); 303 EXPECT_LE(timeCost, TIMEOUT_US); 304 } 305 306 /** 307 * @tc.name: server 308 * @tc.desc: get plugin capabilities with invalid context. 309 * @tc.type: FUNC 310 */ 311 HWTEST_F(ProfilerServiceTest, GetCapabilitiesWithInvalidContext, TestSize.Level1) 312 { 313 ASSERT_NE(service_, nullptr); 314 ASSERT_NE(context_, nullptr); 315 316 GetCapabilitiesRequest request; 317 auto response = std::make_unique<GetCapabilitiesResponse>(); 318 ASSERT_NE(response, nullptr); 319 320 auto status = service_->GetCapabilities(nullptr, &request, response.get()); 321 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 322 } 323 324 /** 325 * @tc.name: server 326 * @tc.desc: get plugin capabilities with invalid arguments. 327 * @tc.type: FUNC 328 */ 329 HWTEST_F(ProfilerServiceTest, GetCapabilitiesWithInvalidArguments, TestSize.Level1) 330 { 331 ASSERT_NE(service_, nullptr); 332 ASSERT_NE(context_, nullptr); 333 334 GetCapabilitiesRequest request; 335 auto response = std::make_unique<GetCapabilitiesResponse>(); 336 ASSERT_NE(response, nullptr); 337 338 auto status = service_->GetCapabilities(context_.get(), nullptr, response.get()); 339 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 340 341 status = service_->GetCapabilities(context_.get(), &request, nullptr); 342 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 343 344 status = service_->GetCapabilities(context_.get(), nullptr, nullptr); 345 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 346 } 347 348 /** 349 * @tc.name: server 350 * @tc.desc: create session without plugin config. 351 * @tc.type: FUNC 352 */ 353 HWTEST_F(ProfilerServiceTest, CreateSessionNoPluginConfig, TestSize.Level1) 354 { 355 ASSERT_NE(service_, nullptr); 356 ASSERT_NE(context_, nullptr); 357 358 CreateSessionRequest request; 359 CreateSessionResponse response; 360 361 auto status = service_->CreateSession(context_.get(), &request, &response); 362 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 363 } 364 365 /** 366 * @tc.name: server 367 * @tc.desc: create session offline test. 368 * @tc.type: FUNC 369 */ 370 HWTEST_F(ProfilerServiceTest, CreateSessionOffline, TestSize.Level1) 371 { 372 ASSERT_NE(service_, nullptr); 373 ASSERT_NE(context_, nullptr); 374 375 CreateSessionRequest request; 376 CreateSessionResponse response; 377 378 auto sessionConfig = request.mutable_session_config(); 379 ASSERT_NE(sessionConfig, nullptr); 380 sessionConfig->set_session_mode(ProfilerSessionConfig::OFFLINE); 381 sessionConfig->set_result_file("trace.bin"); 382 383 auto pluginConfig = request.add_plugin_configs(); 384 ASSERT_NE(pluginConfig, nullptr); 385 pluginConfig->set_name(pluginInfo.name); 386 387 request.set_request_id(++requestCounter); 388 auto status = service_->CreateSession(context_.get(), &request, &response); 389 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 390 } 391 392 /** 393 * @tc.name: server 394 * @tc.desc: create session online test. 395 * @tc.type: FUNC 396 */ 397 HWTEST_F(ProfilerServiceTest, CreateSessionOnline, TestSize.Level1) 398 { 399 ASSERT_NE(service_, nullptr); 400 ASSERT_NE(context_, nullptr); 401 402 CreateSessionRequest request; 403 CreateSessionResponse response; 404 405 auto sessionConfig = request.mutable_session_config(); 406 ASSERT_NE(sessionConfig, nullptr); 407 sessionConfig->set_session_mode(ProfilerSessionConfig::ONLINE); 408 sessionConfig->clear_result_file(); 409 410 auto pluginConfig = request.add_plugin_configs(); 411 ASSERT_NE(pluginConfig, nullptr); 412 pluginConfig->set_name(pluginInfo.name); 413 414 request.set_request_id(++requestCounter); 415 auto status = service_->CreateSession(context_.get(), &request, &response); 416 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 417 } 418 419 /** 420 * @tc.name: server 421 * @tc.desc: create session batch test. 422 * @tc.type: FUNC 423 */ 424 HWTEST_F(ProfilerServiceTest, CreateSessionBatchTest, TestSize.Level1) 425 { 426 ASSERT_NE(service_, nullptr); 427 ASSERT_NE(context_, nullptr); 428 429 Timer timer = {}; 430 for (int i = 0; i < ROUND_COUNT; i++) { 431 CreateSessionRequest request; 432 CreateSessionResponse response; 433 434 auto sessionConfig = request.mutable_session_config(); 435 ASSERT_NE(sessionConfig, nullptr); 436 sessionConfig->set_session_mode(ProfilerSessionConfig::ONLINE); 437 sessionConfig->clear_result_file(); 438 439 auto pluginConfig = request.add_plugin_configs(); 440 ASSERT_NE(pluginConfig, nullptr); 441 std::string pluginName = "create_session_batch_test_" + std::to_string(i); 442 AddPlugin(pluginName); 443 pluginConfig->set_name(pluginName); 444 445 request.set_request_id(++requestCounter); 446 auto status = service_->CreateSession(context_.get(), &request, &response); 447 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 448 } 449 auto timeCost = timer.ElapsedUs(); 450 printf("CreateSession %d time, cost %ldus.\n", ROUND_COUNT, timeCost); 451 EXPECT_LE(timeCost, TIMEOUT_US); 452 } 453 454 /** 455 * @tc.name: server 456 * @tc.desc: create session with invalid arguments. 457 * @tc.type: FUNC 458 */ 459 HWTEST_F(ProfilerServiceTest, CreateSessionInvalidArguments, TestSize.Level1) 460 { 461 ASSERT_NE(service_, nullptr); 462 ASSERT_NE(context_, nullptr); 463 464 CreateSessionRequest request; 465 auto response = std::make_unique<CreateSessionResponse>(); 466 ASSERT_NE(response, nullptr); 467 468 auto status = service_->CreateSession(context_.get(), nullptr, response.get()); 469 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 470 471 status = service_->CreateSession(context_.get(), &request, nullptr); 472 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 473 474 status = service_->CreateSession(context_.get(), nullptr, nullptr); 475 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 476 } 477 478 /** 479 * @tc.name: server 480 * @tc.desc: create session with invalid context. 481 * @tc.type: FUNC 482 */ 483 HWTEST_F(ProfilerServiceTest, CreateSessionWithInvalidContext, TestSize.Level1) 484 { 485 ASSERT_NE(service_, nullptr); 486 ASSERT_NE(context_, nullptr); 487 488 CreateSessionRequest request; 489 auto response = std::make_unique<CreateSessionResponse>(); 490 ASSERT_NE(response, nullptr); 491 492 auto status = service_->CreateSession(nullptr, &request, response.get()); 493 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 494 } 495 496 /** 497 * @tc.name: server 498 * @tc.desc: destroy session with invalid session id. 499 * @tc.type: FUNC 500 */ 501 HWTEST_F(ProfilerServiceTest, DestroySessionInvalidSessionId, TestSize.Level1) 502 { 503 ASSERT_NE(service_, nullptr); 504 505 EXPECT_NE(DestroySession(0).error_code(), grpc::StatusCode::OK); 506 } 507 508 /** 509 * @tc.name: server 510 * @tc.desc: destroy session with offline session. 511 * @tc.type: FUNC 512 */ 513 HWTEST_F(ProfilerServiceTest, DestroySessionOffline, TestSize.Level1) 514 { 515 ASSERT_NE(service_, nullptr); 516 517 uint32_t sessionId = CreateOfflineSession(); 518 EXPECT_NE(sessionId, 0); 519 520 EXPECT_EQ(DestroySession(sessionId).error_code(), grpc::StatusCode::OK); 521 } 522 523 /** 524 * @tc.name: server 525 * @tc.desc: destroy session with online session. 526 * @tc.type: FUNC 527 */ 528 HWTEST_F(ProfilerServiceTest, DestroySessionOnline, TestSize.Level1) 529 { 530 ASSERT_NE(service_, nullptr); 531 532 uint32_t sessionId = CreateOnlineSession(); 533 EXPECT_NE(sessionId, 0); 534 535 EXPECT_EQ(DestroySession(sessionId).error_code(), grpc::StatusCode::OK); 536 } 537 538 /** 539 * @tc.name: server 540 * @tc.desc: destroy session batch test. 541 * @tc.type: FUNC 542 */ 543 HWTEST_F(ProfilerServiceTest, DestroySessionBatchTest, TestSize.Level1) 544 { 545 ASSERT_NE(service_, nullptr); 546 ASSERT_NE(context_, nullptr); 547 548 std::vector<uint32_t> sessionIds; 549 Timer timer = {}; 550 for (int i = 0; i < ROUND_COUNT; i++) { 551 uint32_t sessionId = 0; 552 { 553 CreateSessionRequest request; 554 CreateSessionResponse response; 555 556 auto sessionConfig = request.mutable_session_config(); 557 ASSERT_NE(sessionConfig, nullptr); 558 sessionConfig->set_session_mode(ProfilerSessionConfig::ONLINE); 559 560 auto pluginConfig = request.add_plugin_configs(); 561 ASSERT_NE(pluginConfig, nullptr); 562 563 std::string pluginName = "create_session_batch_test_" + std::to_string(i); 564 AddPlugin(pluginName); 565 pluginConfig->set_name(pluginName); 566 567 request.set_request_id(++requestCounter); 568 auto status = service_->CreateSession(context_.get(), &request, &response); 569 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 570 sessionId = response.session_id(); 571 } 572 if (sessionId) { 573 sessionIds.push_back(sessionId); 574 } 575 } 576 auto timeCost = timer.ElapsedUs(); 577 printf("CreateSession %d time, cost %ldus.\n", ROUND_COUNT, timeCost); 578 EXPECT_LE(timeCost, TIMEOUT_US); 579 580 timer.Reset(); 581 for (auto sessionId : sessionIds) { 582 EXPECT_EQ(DestroySession(sessionId).error_code(), grpc::StatusCode::OK); 583 } 584 timeCost = timer.ElapsedUs(); 585 printf("DestroySession %d time, cost %ldus.\n", ROUND_COUNT, timeCost); 586 EXPECT_LE(timeCost, TIMEOUT_US); 587 } 588 589 /** 590 * @tc.name: server 591 * @tc.desc: destroy session with invalid arguments. 592 * @tc.type: FUNC 593 */ 594 HWTEST_F(ProfilerServiceTest, DestroySessionInvalidArguments, TestSize.Level1) 595 { 596 ASSERT_NE(service_, nullptr); 597 ASSERT_NE(context_, nullptr); 598 599 uint32_t sessionId = CreateOnlineSession(); 600 EXPECT_NE(sessionId, 0); 601 602 DestroySessionRequest request; 603 auto response = std::make_unique<DestroySessionResponse>(); 604 ASSERT_NE(response, nullptr); 605 606 auto status = service_->DestroySession(context_.get(), nullptr, response.get()); 607 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 608 609 status = service_->DestroySession(context_.get(), &request, nullptr); 610 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 611 612 status = service_->DestroySession(context_.get(), nullptr, nullptr); 613 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 614 } 615 616 /** 617 * @tc.name: server 618 * @tc.desc: destroy session with invalid context. 619 * @tc.type: FUNC 620 */ 621 HWTEST_F(ProfilerServiceTest, DestroySessionWithInvalidContext, TestSize.Level1) 622 { 623 ASSERT_NE(service_, nullptr); 624 ASSERT_NE(context_, nullptr); 625 626 uint32_t sessionId = CreateOnlineSession(); 627 EXPECT_NE(sessionId, 0); 628 629 DestroySessionRequest request; 630 auto response = std::make_unique<DestroySessionResponse>(); 631 ASSERT_NE(response, nullptr); 632 633 auto status = service_->DestroySession(nullptr, &request, response.get()); 634 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 635 } 636 637 /** 638 * @tc.name: server 639 * @tc.desc: start session with invalid session id. 640 * @tc.type: FUNC 641 */ 642 HWTEST_F(ProfilerServiceTest, StartSessionInvalidSessionId, TestSize.Level1) 643 { 644 ASSERT_NE(service_, nullptr); 645 ASSERT_NE(context_, nullptr); 646 647 auto status = StartSession(0); 648 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 649 } 650 651 /** 652 * @tc.name: server 653 * @tc.desc: start session with valid offline session. 654 * @tc.type: FUNC 655 */ 656 HWTEST_F(ProfilerServiceTest, StartSessionOffline, TestSize.Level1) 657 { 658 uint32_t sessionId = CreateOfflineSession(); 659 EXPECT_NE(sessionId, 0); 660 661 auto status = StartSession(sessionId); 662 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 663 } 664 665 /** 666 * @tc.name: server 667 * @tc.desc: start session with valid online session. 668 * @tc.type: FUNC 669 */ 670 HWTEST_F(ProfilerServiceTest, StartSessionOnline, TestSize.Level1) 671 { 672 uint32_t sessionId = CreateOnlineSession(); 673 EXPECT_NE(sessionId, 0); 674 675 auto status = StartSession(sessionId); 676 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 677 } 678 679 /** 680 * @tc.name: server 681 * @tc.desc: start session and update configs. 682 * @tc.type: FUNC 683 */ 684 HWTEST_F(ProfilerServiceTest, StartSessionUpdateConfigs, TestSize.Level1) 685 { 686 ASSERT_NE(service_, nullptr); 687 ASSERT_NE(context_, nullptr); 688 689 uint32_t sessionId = CreateOfflineSession(); 690 EXPECT_NE(sessionId, 0); 691 692 StartSessionRequest request; 693 StartSessionResponse response; 694 695 request.set_session_id(sessionId); 696 request.set_request_id(++requestCounter); 697 auto pluginConfig = request.add_update_configs(); 698 ASSERT_NE(pluginConfig, nullptr); 699 700 pluginConfig->set_name(pluginInfo.name); 701 pluginConfig->set_sample_interval(1000); 702 auto status = service_->StartSession(context_.get(), &request, &response); 703 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 704 } 705 706 /** 707 * @tc.name: server 708 * @tc.desc: start session batch test. 709 * @tc.type: FUNC 710 */ 711 HWTEST_F(ProfilerServiceTest, StartSessionBatchTest, TestSize.Level1) 712 { 713 ASSERT_NE(service_, nullptr); 714 ASSERT_NE(context_, nullptr); 715 716 std::vector<uint32_t> sessionIds; 717 Timer timer = {}; 718 for (int i = 0; i < ROUND_COUNT; i++) { 719 uint32_t sessionId = 0; 720 { 721 CreateSessionRequest request; 722 CreateSessionResponse response; 723 724 auto sessionConfig = request.mutable_session_config(); 725 ASSERT_NE(sessionConfig, nullptr); 726 sessionConfig->set_session_mode(ProfilerSessionConfig::ONLINE); 727 728 auto pluginConfig = request.add_plugin_configs(); 729 ASSERT_NE(pluginConfig, nullptr); 730 731 std::string pluginName = "create_session_batch_test_" + std::to_string(i); 732 AddPlugin(pluginName); 733 pluginConfig->set_name(pluginName); 734 735 request.set_request_id(++requestCounter); 736 auto status = service_->CreateSession(context_.get(), &request, &response); 737 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 738 sessionId = response.session_id(); 739 } 740 if (sessionId) { 741 sessionIds.push_back(sessionId); 742 } 743 } 744 auto timeCost = timer.ElapsedUs(); 745 printf("CreateSession %d time, cost %ldus.\n", ROUND_COUNT, timeCost); 746 EXPECT_LE(timeCost, TIMEOUT_US); 747 748 timer.Reset(); 749 for (auto sessionId : sessionIds) { 750 EXPECT_EQ(StartSession(sessionId).error_code(), grpc::StatusCode::OK); 751 } 752 timeCost = timer.ElapsedUs(); 753 printf("StartSession %d time, cost %ldus.\n", ROUND_COUNT, timeCost); 754 EXPECT_LE(timeCost, TIMEOUT_US); 755 } 756 757 /** 758 * @tc.name: server 759 * @tc.desc: start session with invalid arguments. 760 * @tc.type: FUNC 761 */ 762 HWTEST_F(ProfilerServiceTest, StartSessionInvalidArguments, TestSize.Level1) 763 { 764 ASSERT_NE(service_, nullptr); 765 ASSERT_NE(context_, nullptr); 766 767 uint32_t sessionId = CreateOnlineSession(); 768 EXPECT_NE(sessionId, 0); 769 770 StartSessionRequest request; 771 auto response = std::make_unique<StartSessionResponse>(); 772 ASSERT_NE(response, nullptr); 773 774 auto status = service_->StartSession(context_.get(), nullptr, response.get()); 775 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 776 777 status = service_->StartSession(context_.get(), &request, nullptr); 778 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 779 780 status = service_->StartSession(context_.get(), nullptr, nullptr); 781 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 782 } 783 784 /** 785 * @tc.name: server 786 * @tc.desc: start session with invalid context. 787 * @tc.type: FUNC 788 */ 789 HWTEST_F(ProfilerServiceTest, StartSessionWithInvalidContext, TestSize.Level1) 790 { 791 ASSERT_NE(service_, nullptr); 792 ASSERT_NE(context_, nullptr); 793 794 uint32_t sessionId = CreateOnlineSession(); 795 EXPECT_NE(sessionId, 0); 796 797 StartSessionRequest request; 798 auto response = std::make_unique<StartSessionResponse>(); 799 ASSERT_NE(response, nullptr); 800 801 auto status = service_->StartSession(nullptr, &request, response.get()); 802 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 803 } 804 805 /** 806 * @tc.name: server 807 * @tc.desc: stop session with invalid session id. 808 * @tc.type: FUNC 809 */ 810 HWTEST_F(ProfilerServiceTest, StopSessionInvalidSessionId, TestSize.Level1) 811 { 812 ASSERT_NE(service_, nullptr); 813 ASSERT_NE(context_, nullptr); 814 815 auto status = StopSession(0); 816 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 817 } 818 819 /** 820 * @tc.name: server 821 * @tc.desc: stop session with offline session. 822 * @tc.type: FUNC 823 */ 824 HWTEST_F(ProfilerServiceTest, StopSessionOffline, TestSize.Level1) 825 { 826 uint32_t sessionId = CreateOfflineSession(); 827 EXPECT_NE(sessionId, 0); 828 829 auto status = StopSession(sessionId); 830 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 831 } 832 833 /** 834 * @tc.name: server 835 * @tc.desc: stop session with online session. 836 * @tc.type: FUNC 837 */ 838 HWTEST_F(ProfilerServiceTest, StopSessionOnline, TestSize.Level1) 839 { 840 uint32_t sessionId = CreateOnlineSession(); 841 EXPECT_NE(sessionId, 0); 842 { 843 auto status = StartSession(sessionId); 844 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 845 } 846 847 auto status = StopSession(sessionId); 848 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 849 } 850 851 /** 852 * @tc.name: server 853 * @tc.desc: stop session batch test. 854 * @tc.type: FUNC 855 */ 856 HWTEST_F(ProfilerServiceTest, StopSessionBatchTest, TestSize.Level1) 857 { 858 ASSERT_NE(service_, nullptr); 859 ASSERT_NE(context_, nullptr); 860 861 std::vector<uint32_t> sessionIds; 862 Timer timer = {}; 863 for (int i = 0; i < ROUND_COUNT; i++) { 864 uint32_t sessionId = 0; 865 { 866 CreateSessionRequest request; 867 CreateSessionResponse response; 868 869 auto sessionConfig = request.mutable_session_config(); 870 ASSERT_NE(sessionConfig, nullptr); 871 sessionConfig->set_session_mode(ProfilerSessionConfig::ONLINE); 872 873 auto pluginConfig = request.add_plugin_configs(); 874 ASSERT_NE(pluginConfig, nullptr); 875 876 std::string pluginName = "create_session_batch_test_" + std::to_string(i); 877 AddPlugin(pluginName); 878 pluginConfig->set_name(pluginName); 879 880 request.set_request_id(++requestCounter); 881 auto status = service_->CreateSession(context_.get(), &request, &response); 882 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 883 sessionId = response.session_id(); 884 } 885 if (sessionId) { 886 sessionIds.push_back(sessionId); 887 } 888 } 889 auto timeCost = timer.ElapsedUs(); 890 printf("CreateSession %d time, cost %ldus.\n", ROUND_COUNT, timeCost); 891 EXPECT_LE(timeCost, TIMEOUT_US); 892 893 timer.Reset(); 894 for (auto sessionId : sessionIds) { 895 EXPECT_EQ(StartSession(sessionId).error_code(), grpc::StatusCode::OK); 896 } 897 timeCost = timer.ElapsedUs(); 898 printf("StartSession %d time, cost %ldus.\n", ROUND_COUNT, timeCost); 899 EXPECT_LE(timeCost, TIMEOUT_US); 900 901 timer.Reset(); 902 for (auto sessionId : sessionIds) { 903 EXPECT_EQ(StopSession(sessionId).error_code(), grpc::StatusCode::OK); 904 } 905 timeCost = timer.ElapsedUs(); 906 printf("StopSession %d time, cost %ldus.\n", ROUND_COUNT, timeCost); 907 EXPECT_LE(timeCost, TIMEOUT_US); 908 } 909 910 /** 911 * @tc.name: server 912 * @tc.desc: stop session with invalid arguments. 913 * @tc.type: FUNC 914 */ 915 HWTEST_F(ProfilerServiceTest, StopSessionInvalidArguments, TestSize.Level1) 916 { 917 ASSERT_NE(service_, nullptr); 918 ASSERT_NE(context_, nullptr); 919 920 uint32_t sessionId = CreateOnlineSession(); 921 EXPECT_NE(sessionId, 0); 922 EXPECT_EQ(StartSession(sessionId).error_code(), grpc::StatusCode::OK); 923 924 StopSessionRequest request; 925 auto response = std::make_unique<StopSessionResponse>(); 926 ASSERT_NE(response, nullptr); 927 928 auto status = service_->StopSession(context_.get(), nullptr, response.get()); 929 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 930 931 status = service_->StopSession(context_.get(), &request, nullptr); 932 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 933 934 status = service_->StopSession(context_.get(), nullptr, nullptr); 935 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 936 } 937 938 /** 939 * @tc.name: server 940 * @tc.desc: stop session with invalid context. 941 * @tc.type: FUNC 942 */ 943 HWTEST_F(ProfilerServiceTest, StopSessionWithInvalidContext, TestSize.Level1) 944 { 945 ASSERT_NE(service_, nullptr); 946 ASSERT_NE(context_, nullptr); 947 948 uint32_t sessionId = CreateOnlineSession(); 949 EXPECT_NE(sessionId, 0); 950 EXPECT_EQ(StartSession(sessionId).error_code(), grpc::StatusCode::OK); 951 952 StopSessionRequest request; 953 auto response = std::make_unique<StopSessionResponse>(); 954 ASSERT_NE(response, nullptr); 955 956 auto status = service_->StopSession(nullptr, &request, response.get()); 957 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 958 } 959 960 class FakeServerWriter : public ::grpc::ServerWriter<::FetchDataResponse> { 961 public: FakeServerWriter(::grpc::internal::Call * call,grpc::ServerContext * ctx)962 FakeServerWriter(::grpc::internal::Call* call, grpc::ServerContext* ctx) 963 : ::grpc::ServerWriter<::FetchDataResponse>(call, ctx) 964 { 965 } 966 ~FakeServerWriter() = default; 967 GetDataCount() const968 uint32_t GetDataCount() const 969 { 970 return dataCount_; 971 } 972 973 using grpc::internal::WriterInterface<::FetchDataResponse>::Write; Write(const::FetchDataResponse & msg,::grpc::WriteOptions options)974 bool Write(const ::FetchDataResponse& msg, ::grpc::WriteOptions options) override 975 { 976 if (msg.plugin_data_size() > 0) { 977 dataCount_ += msg.plugin_data_size(); 978 } 979 return true; 980 } 981 982 private: 983 std::atomic<uint32_t> dataCount_ = 0; 984 }; 985 986 /** 987 * @tc.name: server 988 * @tc.desc: fetch data with invalid session id. 989 * @tc.type: FUNC 990 */ 991 HWTEST_F(ProfilerServiceTest, FetchDataInvalidSessionId, TestSize.Level1) 992 { 993 ASSERT_NE(service_, nullptr); 994 ASSERT_NE(context_, nullptr); 995 996 FetchDataRequest request; 997 auto writer = std::make_unique<FakeServerWriter>(nullptr, context_.get()); 998 999 request.set_session_id(0); // invalid session id 1000 request.set_request_id(++requestCounter); 1001 auto status = service_->FetchData(context_.get(), &request, writer.get()); 1002 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1003 } 1004 1005 /** 1006 * @tc.name: server 1007 * @tc.desc: fetch data with offline. 1008 * @tc.type: FUNC 1009 */ 1010 HWTEST_F(ProfilerServiceTest, FetchDataOffline, TestSize.Level1) 1011 { 1012 ASSERT_NE(service_, nullptr); 1013 ASSERT_NE(context_, nullptr); 1014 1015 uint32_t sessionId = CreateOfflineSession(); 1016 EXPECT_NE(sessionId, 0); 1017 { 1018 auto status = StartSession(sessionId); 1019 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 1020 } 1021 1022 FetchDataRequest request; 1023 request.set_session_id(sessionId); 1024 request.set_request_id(++requestCounter); 1025 auto writer = std::make_unique<FakeServerWriter>(nullptr, context_.get()); 1026 auto status = service_->FetchData(context_.get(), &request, writer.get()); 1027 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 1028 1029 EXPECT_EQ(StopSession(sessionId).error_code(), grpc::StatusCode::OK); 1030 EXPECT_EQ(DestroySession(sessionId).error_code(), grpc::StatusCode::OK); 1031 } 1032 1033 /** 1034 * @tc.name: server 1035 * @tc.desc: fetch data online. 1036 * @tc.type: FUNC 1037 */ 1038 HWTEST_F(ProfilerServiceTest, FetchDataOnline, TestSize.Level1) 1039 { 1040 ASSERT_NE(service_, nullptr); 1041 ASSERT_NE(context_, nullptr); 1042 1043 uint32_t sessionId = CreateOnlineSession(); 1044 StartSession(sessionId); 1045 1046 auto sessionCtx = service_->GetSessionContext(sessionId); 1047 ASSERT_NE(sessionCtx->dataRepeater, nullptr); 1048 { 1049 auto data = std::make_shared<ProfilerPluginData>(); 1050 ASSERT_NE(data, nullptr); 1051 data->set_name(pluginInfo.name); 1052 sessionCtx->dataRepeater->PutPluginData(data); 1053 } 1054 1055 FetchDataRequest request; 1056 auto writer = std::make_unique<FakeServerWriter>(nullptr, context_.get()); 1057 request.set_session_id(sessionId); 1058 request.set_request_id(++requestCounter); __anone3234ac40202null1059 std::thread bgThread([&] { 1060 auto status = service_->FetchData(context_.get(), &request, writer.get()); 1061 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 1062 }); 1063 1064 usleep(FETCH_DATA_DELAY_US); 1065 sessionCtx->dataRepeater->Close(); 1066 bgThread.join(); 1067 1068 EXPECT_EQ(StopSession(sessionId).error_code(), grpc::StatusCode::OK); 1069 EXPECT_EQ(DestroySession(sessionId).error_code(), grpc::StatusCode::OK); 1070 1071 EXPECT_EQ(writer->GetDataCount(), 1); 1072 } 1073 1074 /** 1075 * @tc.name: server 1076 * @tc.desc: fetch data online batch test. 1077 * @tc.type: FUNC 1078 */ 1079 HWTEST_F(ProfilerServiceTest, FetchDataBatchTest, TestSize.Level1) 1080 { 1081 ASSERT_NE(service_, nullptr); 1082 ASSERT_NE(context_, nullptr); 1083 1084 auto writer = std::make_unique<FakeServerWriter>(nullptr, context_.get()); 1085 1086 uint32_t sessionId = CreateOnlineSession(); 1087 StartSession(sessionId); 1088 1089 auto sessionCtx = service_->GetSessionContext(sessionId); 1090 ASSERT_NE(sessionCtx->dataRepeater, nullptr); 1091 1092 // 只能存入小于maxsize的数据才能确保dataProducer线程正常退出 1093 int size = ProfilerService::DEFAULT_REPEATER_BUFFER_SIZE - 1; __anone3234ac40302() 1094 std::thread dataProducer([&]() { 1095 for (int i = 0; i < size; i++) { 1096 auto data = std::make_shared<ProfilerPluginData>(); 1097 ASSERT_NE(data, nullptr); 1098 data->set_name(pluginInfo.name); 1099 data->set_status(i); 1100 sessionCtx->dataRepeater->PutPluginData(data); 1101 } 1102 }); 1103 dataProducer.join(); 1104 __anone3234ac40402() 1105 std::thread closeDataRepeater([&]() { 1106 while (1) { 1107 if (sessionCtx->dataRepeater->Size() == 0) { 1108 sessionCtx->dataRepeater->Close(); 1109 break; 1110 } 1111 } 1112 }); 1113 1114 Timer timer = {}; __anone3234ac40502() 1115 std::thread dataConsumer([&]() { 1116 FetchDataRequest request; 1117 request.set_session_id(sessionId); 1118 request.set_request_id(++requestCounter); 1119 auto status = service_->FetchData(context_.get(), &request, writer.get()); 1120 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 1121 }); 1122 1123 dataConsumer.join(); 1124 auto timeCost = timer.ElapsedUs(); 1125 printf("FetchData %d time, cost %ldus.\n", size, timeCost); 1126 EXPECT_LE(timeCost, TIMEOUT_US); 1127 1128 EXPECT_EQ(StopSession(sessionId).error_code(), grpc::StatusCode::OK); 1129 EXPECT_EQ(DestroySession(sessionId).error_code(), grpc::StatusCode::OK); 1130 1131 EXPECT_EQ(writer->GetDataCount(), size); 1132 closeDataRepeater.join(); 1133 } 1134 1135 /** 1136 * @tc.name: server 1137 * @tc.desc: fetch data with invalid arguments. 1138 * @tc.type: FUNC 1139 */ 1140 HWTEST_F(ProfilerServiceTest, FetchDataInvalidArguments, TestSize.Level1) 1141 { 1142 ASSERT_NE(service_, nullptr); 1143 ASSERT_NE(context_, nullptr); 1144 1145 FetchDataRequest request; 1146 auto writer = std::make_unique<FakeServerWriter>(nullptr, context_.get()); 1147 request.set_request_id(++requestCounter); 1148 auto status = service_->FetchData(context_.get(), &request, writer.get()); 1149 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1150 1151 uint32_t sessionId = CreateOnlineSession(); 1152 1153 auto sessionCtx = service_->GetSessionContext(sessionId); 1154 ASSERT_NE(sessionCtx->dataRepeater, nullptr); 1155 { 1156 auto data = std::make_shared<ProfilerPluginData>(); 1157 ASSERT_NE(data, nullptr); 1158 data->set_name(pluginInfo.name); 1159 sessionCtx->dataRepeater->PutPluginData(data); 1160 } 1161 1162 status = service_->FetchData(context_.get(), nullptr, writer.get()); 1163 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1164 1165 status = service_->FetchData(context_.get(), &request, nullptr); 1166 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1167 1168 status = service_->FetchData(context_.get(), nullptr, nullptr); 1169 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1170 } 1171 1172 /** 1173 * @tc.name: server 1174 * @tc.desc: fetch data with invalid context. 1175 * @tc.type: FUNC 1176 */ 1177 HWTEST_F(ProfilerServiceTest, FetchDataInvalidContext, TestSize.Level1) 1178 { 1179 ASSERT_NE(service_, nullptr); 1180 ASSERT_NE(context_, nullptr); 1181 1182 FetchDataRequest request; 1183 auto writer = std::make_unique<FakeServerWriter>(nullptr, context_.get()); 1184 request.set_request_id(++requestCounter); 1185 auto status = service_->FetchData(context_.get(), &request, writer.get()); 1186 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1187 1188 uint32_t sessionId = CreateOnlineSession(); 1189 1190 auto sessionCtx = service_->GetSessionContext(sessionId); 1191 ASSERT_NE(sessionCtx->dataRepeater, nullptr); 1192 { 1193 auto data = std::make_shared<ProfilerPluginData>(); 1194 ASSERT_NE(data, nullptr); 1195 data->set_name(pluginInfo.name); 1196 sessionCtx->dataRepeater->PutPluginData(data); 1197 } 1198 1199 status = service_->FetchData(nullptr, &request, writer.get()); 1200 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1201 } 1202 1203 /** 1204 * @tc.name: server 1205 * @tc.desc: keep session with invalid session id. 1206 * @tc.type: FUNC 1207 */ 1208 HWTEST_F(ProfilerServiceTest, KeepSessionInvalidSessionId, TestSize.Level1) 1209 { 1210 ASSERT_NE(service_, nullptr); 1211 ASSERT_NE(context_, nullptr); 1212 1213 KeepSessionRequest request; 1214 KeepSessionResponse response; 1215 1216 request.set_session_id(0); 1217 request.set_request_id(++requestCounter); 1218 auto status = service_->KeepSession(context_.get(), &request, &response); 1219 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1220 } 1221 1222 /** 1223 * @tc.name: server 1224 * @tc.desc: keep session with offline session id. 1225 * @tc.type: FUNC 1226 */ 1227 HWTEST_F(ProfilerServiceTest, KeepSessionWithoutAliveTime, TestSize.Level1) 1228 { 1229 ASSERT_NE(service_, nullptr); 1230 ASSERT_NE(context_, nullptr); 1231 1232 uint32_t sessionId = CreateOfflineSession(); 1233 EXPECT_NE(sessionId, 0); 1234 1235 KeepSessionRequest request; 1236 KeepSessionResponse response; 1237 1238 request.set_session_id(sessionId); 1239 request.set_request_id(++requestCounter); 1240 auto status = service_->KeepSession(context_.get(), &request, &response); 1241 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 1242 } 1243 1244 /** 1245 * @tc.name: server 1246 * @tc.desc: keep session with offline session id. 1247 * @tc.type: FUNC 1248 */ 1249 HWTEST_F(ProfilerServiceTest, KeepSessionOffline, TestSize.Level1) 1250 { 1251 ASSERT_NE(service_, nullptr); 1252 ASSERT_NE(context_, nullptr); 1253 1254 uint32_t sessionId = CreateOfflineSession(); 1255 EXPECT_NE(sessionId, 0); 1256 1257 KeepSessionRequest request; 1258 KeepSessionResponse response; 1259 1260 request.set_session_id(sessionId); 1261 request.set_request_id(++requestCounter); 1262 request.set_keep_alive_time(TEST_SESSION_TIMEOUT_MS); 1263 auto status = service_->KeepSession(context_.get(), &request, &response); 1264 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 1265 1266 // make sure session expired by backgroud task 1267 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SESSION_TIMEOUT_MS)); 1268 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SESSION_TIMEOUT_MS)); 1269 1270 status = DestroySession(sessionId); 1271 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1272 } 1273 1274 /** 1275 * @tc.name: server 1276 * @tc.desc: keep session with batch test. 1277 * @tc.type: FUNC 1278 */ 1279 HWTEST_F(ProfilerServiceTest, KeepSessionBatchTest, TestSize.Level1) 1280 { 1281 ASSERT_NE(service_, nullptr); 1282 ASSERT_NE(context_, nullptr); 1283 1284 uint32_t sessionId = CreateOfflineSession(); 1285 EXPECT_NE(sessionId, 0); 1286 1287 Timer timer = {}; 1288 for (int i = 0; i < ROUND_COUNT; i++) { 1289 KeepSessionRequest request; 1290 KeepSessionResponse response; 1291 1292 request.set_session_id(sessionId); 1293 request.set_request_id(++requestCounter); 1294 request.set_keep_alive_time(TEST_SESSION_TIMEOUT_MS); 1295 auto status = service_->KeepSession(context_.get(), &request, &response); 1296 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 1297 } 1298 auto timeCost = timer.ElapsedUs(); 1299 printf("KeepSession %d time, cost %ldus.\n", ROUND_COUNT, timeCost); 1300 EXPECT_LE(timeCost, TIMEOUT_US); 1301 1302 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SESSION_TIMEOUT_MS)); 1303 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SESSION_TIMEOUT_MS)); 1304 auto status = DestroySession(sessionId); 1305 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1306 } 1307 1308 /** 1309 * @tc.name: server 1310 * @tc.desc: keep session with invalid arguments. 1311 * @tc.type: FUNC 1312 */ 1313 HWTEST_F(ProfilerServiceTest, KeepSessionInvalidArgs, TestSize.Level1) 1314 { 1315 ASSERT_NE(service_, nullptr); 1316 ASSERT_NE(context_, nullptr); 1317 1318 uint32_t sessionId = CreateOfflineSession(); 1319 EXPECT_NE(sessionId, 0); 1320 1321 KeepSessionRequest request; 1322 KeepSessionResponse response; 1323 1324 request.set_session_id(sessionId); 1325 request.set_request_id(++requestCounter); 1326 request.set_keep_alive_time(TEST_SESSION_TIMEOUT_MS); 1327 auto status = service_->KeepSession(context_.get(), nullptr, &response); 1328 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1329 1330 status = service_->KeepSession(context_.get(), &request, nullptr); 1331 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1332 } 1333 1334 /** 1335 * @tc.name: server 1336 * @tc.desc: keep session with invalid context. 1337 * @tc.type: FUNC 1338 */ 1339 HWTEST_F(ProfilerServiceTest, KeepSessionInvalidContext, TestSize.Level1) 1340 { 1341 ASSERT_NE(service_, nullptr); 1342 ASSERT_NE(context_, nullptr); 1343 1344 uint32_t sessionId = CreateOfflineSession(); 1345 EXPECT_NE(sessionId, 0); 1346 1347 KeepSessionRequest request; 1348 KeepSessionResponse response; 1349 1350 request.set_session_id(sessionId); 1351 request.set_request_id(++requestCounter); 1352 request.set_keep_alive_time(TEST_SESSION_TIMEOUT_MS); 1353 auto status = service_->KeepSession(nullptr, &request, &response); 1354 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1355 } 1356 1357 /** 1358 * @tc.name: server 1359 * @tc.desc: start service. 1360 * @tc.type: FUNC 1361 */ 1362 HWTEST_F(ProfilerServiceTest, StartService, TestSize.Level1) 1363 { 1364 auto service = service_; 1365 EXPECT_NE(service, nullptr); 1366 EXPECT_FALSE(service->StartService("")); 1367 1368 std::thread waiterThread(&ProfilerService::WaitServiceDone, service.get()); 1369 sleep(1); 1370 1371 service->StopService(); 1372 waiterThread.join(); 1373 } 1374 } // namespace 1375