1 /* 2 * Copyright (c) Huawei Technologies Co., Ltd. 2021. All rights reserved. 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 <gtest/gtest.h> 22 #include <thread> 23 24 #include "logging.h" 25 #include "plugin_service.h" 26 #include "profiler_capability_manager.h" 27 #include "profiler_data_repeater.h" 28 #include "profiler_service.h" 29 #include "schedule_task_manager.h" 30 #include "common.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); __anonbe4c8fc10202null1059 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; __anonbe4c8fc10302() 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 __anonbe4c8fc10402() 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 = {}; __anonbe4c8fc10502() 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 class FakeSubscribeWriter : public ::grpc::ServerWriter<::SubscribeProfilerEvtResponse> { 1205 public: FakeSubscribeWriter(::grpc::internal::Call * call,grpc::ServerContext * ctx)1206 FakeSubscribeWriter(::grpc::internal::Call* call, grpc::ServerContext* ctx) 1207 : ::grpc::ServerWriter<::SubscribeProfilerEvtResponse>(call, ctx) 1208 { 1209 } 1210 ~FakeSubscribeWriter() = default; 1211 GetDataCount() const1212 uint32_t GetDataCount() const 1213 { 1214 return dataCount_; 1215 } 1216 1217 using grpc::internal::WriterInterface<::SubscribeProfilerEvtResponse>::Write; Write(const::SubscribeProfilerEvtResponse & msg,::grpc::WriteOptions options)1218 bool Write(const ::SubscribeProfilerEvtResponse& msg, ::grpc::WriteOptions options) override 1219 { 1220 if (msg.plugin_state_size() > 0) { 1221 dataCount_ += msg.plugin_state_size(); 1222 } 1223 return true; 1224 } 1225 1226 private: 1227 std::atomic<uint32_t> dataCount_ = 0; 1228 }; 1229 1230 /** 1231 * @tc.name: server 1232 * @tc.desc: subscribe profiler with invalid session id. 1233 * @tc.type: FUNC 1234 */ 1235 HWTEST_F(ProfilerServiceTest, SubscribeProfilerEvtInvalidSessionId, TestSize.Level1) 1236 { 1237 ASSERT_NE(service_, nullptr); 1238 ASSERT_NE(context_, nullptr); 1239 1240 SubscribeProfilerEvtRequest request; 1241 auto writer = std::make_unique<FakeSubscribeWriter>(nullptr, context_.get()); 1242 1243 request.set_session_id(0); // invalid session id 1244 request.set_request_id(++requestCounter); 1245 auto status = service_->SubscribeProfilerEvt(context_.get(), &request, writer.get()); 1246 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1247 } 1248 1249 /** 1250 * @tc.name: server 1251 * @tc.desc: subscribe profiler with offline. 1252 * @tc.type: FUNC 1253 */ 1254 HWTEST_F(ProfilerServiceTest, SubscribeProfilerEvtOffline, TestSize.Level1) 1255 { 1256 ASSERT_NE(service_, nullptr); 1257 ASSERT_NE(context_, nullptr); 1258 1259 uint32_t sessionId = CreateOfflineSession(); 1260 EXPECT_NE(sessionId, 0); 1261 { 1262 auto status = StartSession(sessionId); 1263 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 1264 } 1265 1266 SubscribeProfilerEvtRequest request; 1267 request.set_session_id(sessionId); 1268 request.set_request_id(++requestCounter); 1269 auto writer = std::make_unique<FakeSubscribeWriter>(nullptr, context_.get()); 1270 auto status = service_->SubscribeProfilerEvt(context_.get(), &request, writer.get()); 1271 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 1272 1273 EXPECT_EQ(StopSession(sessionId).error_code(), grpc::StatusCode::OK); 1274 EXPECT_EQ(DestroySession(sessionId).error_code(), grpc::StatusCode::OK); 1275 } 1276 1277 /** 1278 * @tc.name: server 1279 * @tc.desc: subscribe profiler online. 1280 * @tc.type: FUNC 1281 */ 1282 HWTEST_F(ProfilerServiceTest, SubscribeProfilerEvtOnline, TestSize.Level1) 1283 { 1284 ASSERT_NE(service_, nullptr); 1285 ASSERT_NE(context_, nullptr); 1286 1287 uint32_t sessionId = CreateOnlineSession(); 1288 StartSession(sessionId); 1289 1290 auto sessionCtx = service_->GetSessionContext(sessionId); 1291 ASSERT_NE(sessionCtx->stateRepeater, nullptr); 1292 { 1293 auto data = std::make_shared<ProfilerPluginState>(); 1294 ASSERT_NE(data, nullptr); 1295 data->set_name(pluginInfo.name); 1296 sessionCtx->stateRepeater->PutPluginData(data); 1297 } 1298 1299 SubscribeProfilerEvtRequest request; 1300 auto writer = std::make_unique<FakeSubscribeWriter>(nullptr, context_.get()); 1301 request.set_session_id(sessionId); 1302 request.set_request_id(++requestCounter); __anonbe4c8fc10602null1303 std::thread bgThread([this, &request, &writer] { 1304 auto status = service_->SubscribeProfilerEvt(context_.get(), &request, writer.get()); 1305 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 1306 }); 1307 1308 usleep(FETCH_DATA_DELAY_US); 1309 sessionCtx->stateRepeater->Close(); 1310 bgThread.join(); 1311 1312 EXPECT_EQ(StopSession(sessionId).error_code(), grpc::StatusCode::OK); 1313 EXPECT_EQ(DestroySession(sessionId).error_code(), grpc::StatusCode::OK); 1314 1315 EXPECT_GE(writer->GetDataCount(), 1); 1316 } 1317 1318 /** 1319 * @tc.name: server 1320 * @tc.desc: subscribe profiler online batch test. 1321 * @tc.type: FUNC 1322 */ 1323 HWTEST_F(ProfilerServiceTest, SubscribeProfilerEvtBatchTest, TestSize.Level1) 1324 { 1325 ASSERT_NE(service_, nullptr); 1326 ASSERT_NE(context_, nullptr); 1327 1328 auto writer = std::make_unique<FakeSubscribeWriter>(nullptr, context_.get()); 1329 1330 uint32_t sessionId = CreateOnlineSession(); 1331 StartSession(sessionId); 1332 1333 auto sessionCtx = service_->GetSessionContext(sessionId); 1334 ASSERT_NE(sessionCtx->stateRepeater, nullptr); 1335 1336 // 只能存入小于maxsize的数据才能确保dataProducer线程正常退出 1337 int size = ProfilerService::DEFAULT_REPEATER_BUFFER_SIZE - 1; __anonbe4c8fc10702() 1338 std::thread dataProducer([this, &sessionCtx, &size]() { 1339 for (int i = 0; i < size; i++) { 1340 auto data = std::make_shared<ProfilerPluginState>(); 1341 ASSERT_NE(data, nullptr); 1342 data->set_name(pluginInfo.name); 1343 sessionCtx->stateRepeater->PutPluginData(data); 1344 } 1345 }); 1346 dataProducer.join(); 1347 __anonbe4c8fc10802() 1348 std::thread closeStateRepeater([&sessionCtx]() { 1349 while (1) { 1350 if (sessionCtx->stateRepeater->Size() == 0) { 1351 sessionCtx->stateRepeater->Close(); 1352 break; 1353 } 1354 } 1355 }); 1356 1357 Timer timer = {}; __anonbe4c8fc10902() 1358 std::thread dataConsumer([this, &sessionId, &writer]() { 1359 SubscribeProfilerEvtRequest request; 1360 request.set_session_id(sessionId); 1361 request.set_request_id(++requestCounter); 1362 auto status = service_->SubscribeProfilerEvt(context_.get(), &request, writer.get()); 1363 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 1364 }); 1365 1366 dataConsumer.join(); 1367 auto timeCost = timer.ElapsedUs(); 1368 printf("SubscribeProfilerEvt %d time, cost %ldus.\n", size, timeCost); 1369 EXPECT_LE(timeCost, TIMEOUT_US); 1370 1371 EXPECT_EQ(StopSession(sessionId).error_code(), grpc::StatusCode::OK); 1372 EXPECT_EQ(DestroySession(sessionId).error_code(), grpc::StatusCode::OK); 1373 1374 EXPECT_EQ(writer->GetDataCount(), size); 1375 closeStateRepeater.join(); 1376 } 1377 1378 /** 1379 * @tc.name: server 1380 * @tc.desc: subscribe profiler with invalid arguments. 1381 * @tc.type: FUNC 1382 */ 1383 HWTEST_F(ProfilerServiceTest, SubscribeProfilerEvtInvalidArguments, TestSize.Level1) 1384 { 1385 ASSERT_NE(service_, nullptr); 1386 ASSERT_NE(context_, nullptr); 1387 1388 SubscribeProfilerEvtRequest request; 1389 auto writer = std::make_unique<FakeSubscribeWriter>(nullptr, context_.get()); 1390 request.set_request_id(++requestCounter); 1391 auto status = service_->SubscribeProfilerEvt(context_.get(), &request, writer.get()); 1392 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1393 1394 uint32_t sessionId = CreateOnlineSession(); 1395 1396 auto sessionCtx = service_->GetSessionContext(sessionId); 1397 ASSERT_NE(sessionCtx->stateRepeater, nullptr); 1398 { 1399 auto data = std::make_shared<ProfilerPluginState>(); 1400 ASSERT_NE(data, nullptr); 1401 data->set_name(pluginInfo.name); 1402 sessionCtx->stateRepeater->PutPluginData(data); 1403 } 1404 1405 status = service_->SubscribeProfilerEvt(context_.get(), nullptr, writer.get()); 1406 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1407 1408 status = service_->SubscribeProfilerEvt(context_.get(), &request, nullptr); 1409 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1410 1411 status = service_->SubscribeProfilerEvt(context_.get(), nullptr, nullptr); 1412 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1413 } 1414 1415 /** 1416 * @tc.name: server 1417 * @tc.desc: subscribe profiler with invalid context. 1418 * @tc.type: FUNC 1419 */ 1420 HWTEST_F(ProfilerServiceTest, SubscribeProfilerEvtInvalidContext, TestSize.Level1) 1421 { 1422 ASSERT_NE(service_, nullptr); 1423 ASSERT_NE(context_, nullptr); 1424 1425 SubscribeProfilerEvtRequest request; 1426 auto writer = std::make_unique<FakeSubscribeWriter>(nullptr, context_.get()); 1427 request.set_request_id(++requestCounter); 1428 auto status = service_->SubscribeProfilerEvt(context_.get(), &request, writer.get()); 1429 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1430 1431 uint32_t sessionId = CreateOnlineSession(); 1432 1433 auto sessionCtx = service_->GetSessionContext(sessionId); 1434 ASSERT_NE(sessionCtx->stateRepeater, nullptr); 1435 { 1436 auto data = std::make_shared<ProfilerPluginState>(); 1437 ASSERT_NE(data, nullptr); 1438 data->set_name(pluginInfo.name); 1439 sessionCtx->stateRepeater->PutPluginData(data); 1440 } 1441 1442 status = service_->SubscribeProfilerEvt(nullptr, &request, writer.get()); 1443 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1444 } 1445 1446 /** 1447 * @tc.name: server 1448 * @tc.desc: keep session with invalid session id. 1449 * @tc.type: FUNC 1450 */ 1451 HWTEST_F(ProfilerServiceTest, KeepSessionInvalidSessionId, TestSize.Level1) 1452 { 1453 ASSERT_NE(service_, nullptr); 1454 ASSERT_NE(context_, nullptr); 1455 1456 KeepSessionRequest request; 1457 KeepSessionResponse response; 1458 1459 request.set_session_id(0); 1460 request.set_request_id(++requestCounter); 1461 auto status = service_->KeepSession(context_.get(), &request, &response); 1462 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1463 } 1464 1465 /** 1466 * @tc.name: server 1467 * @tc.desc: keep session with offline session id. 1468 * @tc.type: FUNC 1469 */ 1470 HWTEST_F(ProfilerServiceTest, KeepSessionWithoutAliveTime, TestSize.Level1) 1471 { 1472 ASSERT_NE(service_, nullptr); 1473 ASSERT_NE(context_, nullptr); 1474 1475 uint32_t sessionId = CreateOfflineSession(); 1476 EXPECT_NE(sessionId, 0); 1477 1478 KeepSessionRequest request; 1479 KeepSessionResponse response; 1480 1481 request.set_session_id(sessionId); 1482 request.set_request_id(++requestCounter); 1483 auto status = service_->KeepSession(context_.get(), &request, &response); 1484 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 1485 } 1486 1487 /** 1488 * @tc.name: server 1489 * @tc.desc: keep session with offline session id. 1490 * @tc.type: FUNC 1491 */ 1492 HWTEST_F(ProfilerServiceTest, KeepSessionOffline, TestSize.Level1) 1493 { 1494 ASSERT_NE(service_, nullptr); 1495 ASSERT_NE(context_, nullptr); 1496 1497 uint32_t sessionId = CreateOfflineSession(); 1498 EXPECT_NE(sessionId, 0); 1499 1500 KeepSessionRequest request; 1501 KeepSessionResponse response; 1502 1503 request.set_session_id(sessionId); 1504 request.set_request_id(++requestCounter); 1505 request.set_keep_alive_time(TEST_SESSION_TIMEOUT_MS); 1506 auto status = service_->KeepSession(context_.get(), &request, &response); 1507 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 1508 1509 // make sure session expired by backgroud task 1510 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SESSION_TIMEOUT_MS)); 1511 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SESSION_TIMEOUT_MS)); 1512 1513 status = DestroySession(sessionId); 1514 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1515 } 1516 1517 /** 1518 * @tc.name: server 1519 * @tc.desc: keep session with batch test. 1520 * @tc.type: FUNC 1521 */ 1522 HWTEST_F(ProfilerServiceTest, KeepSessionBatchTest, TestSize.Level1) 1523 { 1524 ASSERT_NE(service_, nullptr); 1525 ASSERT_NE(context_, nullptr); 1526 1527 uint32_t sessionId = CreateOfflineSession(); 1528 EXPECT_NE(sessionId, 0); 1529 1530 Timer timer = {}; 1531 for (int i = 0; i < ROUND_COUNT; i++) { 1532 KeepSessionRequest request; 1533 KeepSessionResponse response; 1534 1535 request.set_session_id(sessionId); 1536 request.set_request_id(++requestCounter); 1537 request.set_keep_alive_time(TEST_SESSION_TIMEOUT_MS); 1538 auto status = service_->KeepSession(context_.get(), &request, &response); 1539 EXPECT_EQ(status.error_code(), grpc::StatusCode::OK); 1540 } 1541 auto timeCost = timer.ElapsedUs(); 1542 printf("KeepSession %d time, cost %ldus.\n", ROUND_COUNT, timeCost); 1543 EXPECT_LE(timeCost, TIMEOUT_US); 1544 1545 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SESSION_TIMEOUT_MS)); 1546 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SESSION_TIMEOUT_MS)); 1547 auto status = DestroySession(sessionId); 1548 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1549 } 1550 1551 /** 1552 * @tc.name: server 1553 * @tc.desc: keep session with invalid arguments. 1554 * @tc.type: FUNC 1555 */ 1556 HWTEST_F(ProfilerServiceTest, KeepSessionInvalidArgs, TestSize.Level1) 1557 { 1558 ASSERT_NE(service_, nullptr); 1559 ASSERT_NE(context_, nullptr); 1560 1561 uint32_t sessionId = CreateOfflineSession(); 1562 EXPECT_NE(sessionId, 0); 1563 1564 KeepSessionRequest request; 1565 KeepSessionResponse response; 1566 1567 request.set_session_id(sessionId); 1568 request.set_request_id(++requestCounter); 1569 request.set_keep_alive_time(TEST_SESSION_TIMEOUT_MS); 1570 auto status = service_->KeepSession(context_.get(), nullptr, &response); 1571 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1572 1573 status = service_->KeepSession(context_.get(), &request, nullptr); 1574 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1575 } 1576 1577 /** 1578 * @tc.name: server 1579 * @tc.desc: keep session with invalid context. 1580 * @tc.type: FUNC 1581 */ 1582 HWTEST_F(ProfilerServiceTest, KeepSessionInvalidContext, TestSize.Level1) 1583 { 1584 ASSERT_NE(service_, nullptr); 1585 ASSERT_NE(context_, nullptr); 1586 1587 uint32_t sessionId = CreateOfflineSession(); 1588 EXPECT_NE(sessionId, 0); 1589 1590 KeepSessionRequest request; 1591 KeepSessionResponse response; 1592 1593 request.set_session_id(sessionId); 1594 request.set_request_id(++requestCounter); 1595 request.set_keep_alive_time(TEST_SESSION_TIMEOUT_MS); 1596 auto status = service_->KeepSession(nullptr, &request, &response); 1597 EXPECT_NE(status.error_code(), grpc::StatusCode::OK); 1598 } 1599 1600 /** 1601 * @tc.name: server 1602 * @tc.desc: start service. 1603 * @tc.type: FUNC 1604 */ 1605 HWTEST_F(ProfilerServiceTest, StartService, TestSize.Level1) 1606 { 1607 auto service = service_; 1608 EXPECT_NE(service, nullptr); 1609 EXPECT_FALSE(service->StartService("")); 1610 std::string listenUri = std::string("0.0.0.0:") + std::to_string(COMMON::GetServicePort()); 1611 EXPECT_TRUE(service->StartService(listenUri)); 1612 std::thread waiterThread(&ProfilerService::WaitServiceDone, service.get()); 1613 sleep(1); 1614 service->StopService(); 1615 waiterThread.join(); 1616 } 1617 1618 /** 1619 * @tc.name: server 1620 * @tc.desc: MergeStandaloneFile test. 1621 * @tc.type: FUNC 1622 */ 1623 HWTEST_F(ProfilerServiceTest, MergeStandaloneFile, TestSize.Level1) 1624 { 1625 std::string testPath = "testFile.bin"; 1626 std::string targetPath = "target.trace.bin"; 1627 auto writer = std::make_shared<TraceFileWriter>(testPath, false, 0, 0); 1628 auto writerTarget = std::make_shared<TraceFileWriter>(targetPath, false, 0, 0); 1629 EXPECT_NE(writer, nullptr); 1630 EXPECT_NE(writerTarget, nullptr); 1631 std::string testData = "this is a test case!this is a test case!"; 1632 std::string traceData = "test"; 1633 EXPECT_EQ(writer->Write(testData.data(), testData.size()), sizeof(uint32_t) + testData.size()); 1634 EXPECT_EQ(writerTarget->Write(traceData.data(), traceData.size()), sizeof(uint32_t) + traceData.size()); 1635 std::string pluginName = "destroy_session_standalone_test"; 1636 service_->MergeStandaloneFile(targetPath, pluginName, testPath, "1.02"); 1637 service_->MergeStandaloneFile(targetPath, "", testPath, "1.02"); 1638 service_->MergeStandaloneFile(targetPath, pluginName, "", "1.02"); 1639 service_->MergeStandaloneFile("", pluginName, testPath, "1.02"); 1640 service_->MergeStandaloneFile(targetPath, "hiperf-plugin", testPath, "1.02"); 1641 } 1642 1643 } // namespace 1644