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 #include <dlfcn.h>
17 #include <iostream>
18 #include <gtest/gtest.h>
19 #include <thread>
20 #include <vector>
21 #include <memory>
22 #include <sys/syscall.h>
23
24 #include "command_poller.h"
25 #include "init_param.h"
26 #include "network_profiler_socker_client.h"
27 #include "network_profiler.h"
28 #include "network_profiler_manager.h"
29 #include "grpc/impl/codegen/log.h"
30 #include "plugin_service.h"
31 #include "plugin_service.ipc.h"
32 #include "socket_context.h"
33 #include "network_profiler_config.pb.h"
34
35 using namespace testing::ext;
36 using namespace OHOS::Developtools::Profiler;
37
38 namespace {
39 const std::string OUTPUT_PATH = "/data/local/tmp/hiprofiler_data.htrace";
40 const std::string NETWORK_TEST_EXE = "/data/local/tmp/network_profiler_test_exe";
41 const std::string PARAM_KAY = "hiviewdfx.hiprofiler.networkprofiler.target";
42 constexpr uint32_t BUFFER_SIZE = 1024;
43 constexpr uint32_t SMB1_SIZE = 10 * 4096;
44 constexpr int FILE_SIZE = 2000;
45 constexpr int MOBILE_BIT = 32;
46 constexpr int SLEEP_TIME = 3;
47 const std::string WRITER_NAME = "NetworkProfilerWriterTest";
48 void* g_smbAddr = nullptr;
49 int g_smbFd1 = 0;
50
InitShareMemory()51 int InitShareMemory()
52 {
53 int fd = syscall(SYS_memfd_create, WRITER_NAME.c_str(), 0);
54 CHECK_TRUE(fd >= 0, -1, "CreateBlock FAIL SYS_memfd_create");
55
56 int check = ftruncate(fd, SMB1_SIZE);
57 if (check < 0) {
58 close(fd);
59 const int bufSize = 256;
60 char buf[bufSize] = { 0 };
61 strerror_r(errno, buf, bufSize);
62 PROFILER_LOG_ERROR(LOG_CORE, "CreateBlock ftruncate ERR : %s", buf);
63 return -1;
64 }
65
66 g_smbAddr = mmap(nullptr, SMB1_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
67 if (g_smbAddr == (reinterpret_cast<void *>(-1))) {
68 close(fd);
69 const int bufSize = 256;
70 char buf[bufSize] = { 0 };
71 strerror_r(errno, buf, bufSize);
72 PROFILER_LOG_ERROR(LOG_CORE, "CreateBlock g_smbAddr mmap ERR : %s", buf);
73 return -1;
74 }
75
76 ShareMemoryBlock::BlockHeader* header_ = reinterpret_cast<ShareMemoryBlock::BlockHeader*>(g_smbAddr);
77
78 // initialize header infos
79 header_->info.readOffset_ = 0;
80 header_->info.writeOffset_ = 0;
81 header_->info.memorySize_ = SMB1_SIZE - sizeof(ShareMemoryBlock::BlockHeader);
82 header_->info.bytesCount_ = 0;
83 header_->info.chunkCount_ = 0;
84
85 return fd;
86 }
87
88 class NetworkProfilerTest : public ::testing::Test {
89 public:
SetUpTestCase()90 static void SetUpTestCase()
91 {
92 };
93
TearDownTestCase()94 static void TearDownTestCase()
95 {
96 }
CreateCommand(const std::string & outputFile,int32_t time,const std::string & model,const std::string & procedure) const97 std::string CreateCommand(const std::string& outputFile, int32_t time, const std::string& model,
98 const std::string& procedure) const
99 {
100 std::string cmdStr =
101 "hiprofiler_cmd \\\n"
102 "-c - \\\n";
103 cmdStr += "-o " + outputFile + " \\\n";
104 cmdStr += "-t " + std::to_string(time) + " \\\n";
105 cmdStr += "-s \\\n";
106 cmdStr += "-k \\\n"
107 "<<CONFIG\n"
108 "request_id: 1\n"
109 "session_config {\n"
110 " buffers {\n"
111 " pages: 32768\n"
112 " }\n"
113 " result_file: \"/data/local/tmp/hiprofiler_data.htrace\"\n"
114 " sample_duration: 30000\n"
115 "}\n"
116 "plugin_configs {\n"
117 " plugin_name: \"ffrt-profiler\"\n"
118 " config_data {\n";
119 cmdStr += model + ": " + procedure + '\n';
120 cmdStr += "smb_pages: 16384\n"
121 "flush_interval: 5\n"
122 "block: true\n"
123 "clock_id: BOOTTIME\n"
124 " }\n"
125 "}\n"
126 "CONFIG\n";
127 return cmdStr;
128 }
StartProcess(const std::string & name,const std::string & args)129 void StartProcess(const std::string& name, const std::string& args)
130 {
131 if (signal(SIGCHLD, SIG_IGN) == SIG_ERR) {
132 return;
133 }
134
135 int processNum = fork();
136 if (processNum == 0) {
137 sleep(SLEEP_TIME);
138 execl(name.c_str(), name.c_str(), args.c_str(), NULL);
139 _exit(1);
140 } else if (processNum < 0) {
141 PROFILER_LOG_ERROR(LOG_CORE, "Failed to fork process");
142 } else {
143 PROFILER_LOG_ERROR(LOG_CORE, "sub process PID: %d", processNum);
144 prfolerExePid = processNum;
145 }
146 }
SetUp()147 void SetUp()
148 {
149 g_smbFd1 = InitShareMemory();
150 }
TearDown()151 void TearDown()
152 {
153 g_smbFd1 = 0;
154 }
155 int prfolerExePid{0};
156 };
157
CallBackFunc()158 void CallBackFunc()
159 {
160 return;
161 }
162
RandData(uint8_t * data,int size)163 void RandData(uint8_t* data, int size)
164 {
165 time_t tv = time(nullptr);
166 if (tv == -1) {
167 tv = 1;
168 }
169 unsigned int seed = static_cast<unsigned int>(tv);
170 while (--size) {
171 data[size] = rand_r(&seed) / static_cast<uint8_t>(-1);
172 }
173 }
174
175 /**
176 * @tc.name: NetworkProfilerTest001
177 * @tc.desc: Test NetworkProfilerSocketClient IsProfilerEnable without SystemSetParameter
178 * @tc.type: FUNC
179 */
180 HWTEST_F(NetworkProfilerTest, NetworkProfilerTest001, TestSize.Level1)
181 {
182 auto networkProfilerMgr = std::make_shared<NetworkProfilerManager>();
183 auto networkProfilerService = std::make_unique<NetworkProfilerSocketService>(networkProfilerMgr);
184 ASSERT_TRUE(networkProfilerService != nullptr);
185 networkProfilerMgr->Init();
186 auto networkProfiler = NetworkProfiler::GetInstance();
187 auto ret = networkProfiler->IsProfilerEnable();
188 ASSERT_FALSE(ret);
189 NetworkProfilerSocketClient client(1, networkProfiler, CallBackFunc);
190 client.SendNetworkProfilerData(nullptr, 0, nullptr, 0);
191 }
192
193 /**
194 * @tc.name: NetworkProfilerTest002
195 * @tc.desc: Test NetworkProfilerSocketClient send empty data to server
196 * @tc.type: FUNC
197 */
198 HWTEST_F(NetworkProfilerTest, NetworkProfilerTest002, TestSize.Level1)
199 {
200 SystemSetParameter("hiviewdfx.hiprofiler.plugins.start", "1");
201 auto networkProfiler = NetworkProfiler::GetInstance();
202 NetworkProfilerSocketClient client(1, networkProfiler, CallBackFunc);
203 sleep(2);
204 auto ret = client.SendNetworkProfilerData(nullptr, 0, nullptr, 0);
205 ASSERT_FALSE(ret);
206 NetworkConfig config;
207 SocketContext ctx;
208 ret = client.ProtocolProc(ctx, 0, reinterpret_cast<int8_t*>(&config), sizeof(config));
209 ASSERT_TRUE(ret);
210 SystemSetParameter("hiviewdfx.hiprofiler.plugins.start", "0");
211 }
212
213 /**
214 * @tc.name: NetworkProfilerTest003
215 * @tc.desc: Test NetworkProfilerSocketClient send empty data to server
216 * @tc.type: FUNC
217 */
218 HWTEST_F(NetworkProfilerTest, NetworkProfilerTest003, TestSize.Level1)
219 {
220 SystemSetParameter("hiviewdfx.hiprofiler.plugins.start", "1");
221 auto networkProfiler = NetworkProfiler::GetInstance();
222 NetworkProfilerSocketClient client(1, networkProfiler, CallBackFunc);
223 sleep(2);
224 auto ret = client.SendNetworkProfilerData(nullptr, 0, nullptr, 0);
225 ASSERT_FALSE(ret);
226 networkProfiler->Enable();
227 networkProfiler->ServiceCloseCallback();
228 networkProfiler->Disable();
229 SystemSetParameter("hiviewdfx.hiprofiler.plugins.start", "0");
230 }
231
232 /**
233 * @tc.name: NetworkProfilerTest004
234 * @tc.desc: Test NetworkProfilerSocketClient IsProfilerEnable without SystemSetParameter
235 * @tc.type: FUNC
236 */
237 HWTEST_F(NetworkProfilerTest, NetworkProfilerTest004, TestSize.Level1)
238 {
239 auto networkProfilerMgr = std::make_shared<NetworkProfilerManager>();
240 auto networkProfilerService = std::make_unique<NetworkProfilerSocketService>(networkProfilerMgr);
241 ASSERT_TRUE(networkProfilerService != nullptr);
242 networkProfilerMgr->Init();
243 auto networkProfiler = NetworkProfiler::GetInstance();
244 auto ret = networkProfiler->IsProfilerEnable();
245 ASSERT_FALSE(ret);
246 networkProfiler->Enable();
247 networkProfiler->SetEnableFlag(true);
248 networkProfiler->Enable();
249 networkProfiler->~NetworkProfiler();
250 }
251
252 /**
253 * @tc.name: NetworkProfilerWriterTest001
254 * @tc.desc: Write data to shared memory through writer.
255 * @tc.type: FUNC
256 */
257 HWTEST_F(NetworkProfilerTest, NetworkProfilerWriterTest001, TestSize.Level1)
258 {
259 auto write = std::make_shared<NetworkProfilerWriter>(WRITER_NAME, SMB1_SIZE, g_smbFd1, -1, false);
260 EXPECT_NE(write->shareMemoryBlock_, nullptr);
261
262 uint8_t data[] = {0x55, 0xAA, 0x55, 0xAA};
__anon214a08910202() 263 auto myCallback = []() -> bool {
264 return true;
265 };
266 EXPECT_TRUE(write->WriteTimeout(static_cast<void*>(data), sizeof(data), myCallback));
267 EXPECT_FALSE(write->WriteTimeout(static_cast<void*>(data), 0, myCallback));
268 EXPECT_FALSE(write->WriteTimeout(nullptr, 0, myCallback));
269
270 uint8_t payload[] = {0x11, 0x22, 0x33, 0x44};
271 EXPECT_TRUE(write->WriteWithPayloadTimeout(static_cast<void*>(data), sizeof(data),
272 static_cast<void*>(payload), sizeof(payload), myCallback));
273 EXPECT_FALSE(write->WriteWithPayloadTimeout(static_cast<void*>(data), 0, nullptr, 0, myCallback));
274 EXPECT_FALSE(write->WriteWithPayloadTimeout(nullptr, 0, nullptr, 0, myCallback));
275 write->block_ = true;
276 EXPECT_TRUE(write->WriteWithPayloadTimeout(static_cast<void*>(data), sizeof(data),
277 static_cast<void*>(payload), sizeof(payload), myCallback));
278 }
279
280 /**
281 * @tc.name: NetworkProfilerWriterTest002
282 * @tc.desc: Write data to shared memory through writer.
283 * @tc.type: FUNC
284 */
285 HWTEST_F(NetworkProfilerTest, NetworkProfilerWriterTest002, TestSize.Level1)
286 {
287 uint8_t data[BUFFER_SIZE];
288 RandData(data, BUFFER_SIZE);
289 auto write = std::make_shared<NetworkProfilerWriter>(WRITER_NAME, SMB1_SIZE, g_smbFd1, -1, false);
290 EXPECT_NE(write->shareMemoryBlock_, nullptr);
291 long bytes = BUFFER_SIZE;
292
293 EXPECT_TRUE(write->Flush());
294 write->DoStats(bytes);
295 write->Report();
296 }
297
298 /**
299 * @tc.name: NetworkProfilerWriterTest003
300 * @tc.desc: Write data to shared memory through writer.
301 * @tc.type: FUNC
302 */
303 HWTEST_F(NetworkProfilerTest, NetworkProfilerWriterTest003, TestSize.Level1)
304 {
305 auto write = std::make_shared<NetworkProfilerWriter>(WRITER_NAME, SMB1_SIZE, g_smbFd1, -1, false);
306 EXPECT_NE(write->shareMemoryBlock_, nullptr);
307 uint8_t buffer1[] = {0x55, 0xAA, 0x55, 0xAA};
308 uint8_t buffer2[] = {0x11, 0x22, 0x33, 0x44};
309 uint8_t buffer3[] = {0xAA, 0xBB, 0xCC, 0xDD};
310
311 EXPECT_TRUE(write->Write((const void*)buffer1, sizeof(buffer1)));
312 EXPECT_TRUE(write->Write((const void*)buffer2, sizeof(buffer2)));
313 EXPECT_TRUE(write->Write((const void*)buffer3, sizeof(buffer3)));
314
315 EXPECT_FALSE(write->Write((const void*)buffer3, 0));
316 EXPECT_FALSE(write->Write(nullptr, 0));
317 }
318
319 /**
320 * @tc.name: NetworkProfilerSockerClientTest004
321 * @tc.desc: test NetworkProfilerSockerClient::NetworkProfilerSockerClientTest004 with normal case.
322 * @tc.type: FUNC
323 */
324 HWTEST_F(NetworkProfilerTest, NetworkProfilerSockerClientTest004, TestSize.Level1)
325 {
326 auto write = std::make_shared<NetworkProfilerWriter>(WRITER_NAME, SMB1_SIZE, g_smbFd1, -1, false);
327 EXPECT_NE(write->shareMemoryBlock_, nullptr);
328
329 auto networkProfiler = NetworkProfiler::GetInstance();
330 NetworkProfilerSocketClient client(1, networkProfiler, CallBackFunc);
331 NetworkConfig config;
332 SocketContext ctx;
333 auto ret = client.ProtocolProc(ctx, 0, reinterpret_cast<int8_t*>(&config), sizeof(config));
334 ASSERT_TRUE(ret);
335 client.unixSocketClient_ = std::make_shared<UnixSocketClient>();
336 sleep(2);
337 uint8_t data[] = {0x55, 0xAA, 0x55, 0xAA};
338 uint8_t payload[] = {0x11, 0x22, 0x33, 0x44};
339 ASSERT_FALSE(client.SendNetworkProfilerData(static_cast<void*>(data), sizeof(data),
340 static_cast<void*>(payload), sizeof(payload)));
341 }
342
343 /**
344 * @tc.name: NetworkProfilerSockerClientTest005
345 * @tc.desc: test NetworkProfilerSockerClient::NetworkProfilerSockerClientTest005 with normal case.
346 * @tc.type: FUNC
347 */
348 HWTEST_F(NetworkProfilerTest, NetworkProfilerSockerClientTest005, TestSize.Level1)
349 {
350 auto write = std::make_shared<NetworkProfilerWriter>(WRITER_NAME, SMB1_SIZE, g_smbFd1, -1, false);
351 EXPECT_NE(write->shareMemoryBlock_, nullptr);
352
353 auto networkProfiler = NetworkProfiler::GetInstance();
354 NetworkProfilerSocketClient client(1, networkProfiler, CallBackFunc);
355 ASSERT_FALSE(client.PeerIsConnected());
356 client.unixSocketClient_ = std::make_shared<UnixSocketClient>();
357 ASSERT_TRUE(client.PeerIsConnected());
358 client.Flush();
359
360 NetworkConfig config;
361 SocketContext ctx;
362 auto ret = client.ProtocolProc(ctx, 0, reinterpret_cast<int8_t*>(&config), sizeof(config));
363 ASSERT_TRUE(ret);
364 client.Flush();
365 }
366
367 /**
368 * @tc.name: NetworkProfilerSockerClientTest006
369 * @tc.desc: test NetworkProfilerSockerClient::NetworkProfilerSockerClientTest006 with normal case.
370 * @tc.type: FUNC
371 */
372 HWTEST_F(NetworkProfilerTest, NetworkProfilerSockerClientTest006, TestSize.Level1)
373 {
374 auto write = std::make_shared<NetworkProfilerWriter>(WRITER_NAME, SMB1_SIZE, g_smbFd1, -1, false);
375 EXPECT_NE(write->shareMemoryBlock_, nullptr);
376
377 auto networkProfiler = NetworkProfiler::GetInstance();
378 NetworkProfilerSocketClient client(1, networkProfiler, CallBackFunc);
379 client.unixSocketClient_ = std::make_shared<UnixSocketClient>();
380 ASSERT_FALSE(client.Connect(NETWORK_PROFILER_UNIX_SOCKET_FULL_PATH, nullptr));
381 }
382
383 /**
384 * @tc.name: NetworkProfilerServiceTest001
385 * @tc.desc: test NetworkProfilerService::NetworkProfilerServiceTest001 with normal case.
386 * @tc.type: FUNC
387 */
388 HWTEST_F(NetworkProfilerTest, NetworkProfilerServiceTest001, TestSize.Level1)
389 {
390 StartProcess(NETWORK_TEST_EXE, "100");
391 std::string cmd = CreateCommand(OUTPUT_PATH, 10, "pid", std::to_string(prfolerExePid));
392 string str = "network_plugin_test_string";
393 string seq = "_";
394 std::vector<string> ret;
395 SplitParamValue(str, seq, ret);
396 EXPECT_EQ(ret.size(), 4);
397 }
398
399 /**
400 * @tc.name: NetworkProfilerServiceTest002
401 * @tc.desc: test NetworkProfilerService::NetworkProfilerServiceTest002 with normal case.
402 * @tc.type: FUNC
403 */
404 HWTEST_F(NetworkProfilerTest, NetworkProfilerServiceTest002, TestSize.Level1)
405 {
406 StartProcess(NETWORK_TEST_EXE, "100");
407 std::string cmd = CreateCommand(OUTPUT_PATH, 10, "pid", std::to_string(prfolerExePid));
408 string str = "";
409 string seq = "_";
410 std::vector<string> ret;
411 SplitParamValue(str, seq, ret);
412 EXPECT_EQ(ret.size(), 0);
413 }
414
415 /**
416 * @tc.name: NetworkProfilerServiceTest003
417 * @tc.desc: test NetworkProfilerService::NetworkProfilerServiceTest003 with normal case.
418 * @tc.type: FUNC
419 */
420 HWTEST_F(NetworkProfilerTest, NetworkProfilerServiceTest003, TestSize.Level1)
421 {
422 StartProcess(NETWORK_TEST_EXE, "100");
423 std::string cmd = CreateCommand(OUTPUT_PATH, 10, "pid", std::to_string(prfolerExePid));
424 auto res = GetProcessNameByPid(prfolerExePid);
425 EXPECT_EQ(res, "networkprofiler_ut");
426 }
427
428 /**
429 * @tc.name: NetworkProfilerManagerTest001
430 * @tc.desc: test NetworkProfilerManager::NetworkProfilerManagerTest001 with normal case.
431 * @tc.type: FUNC
432 */
433 HWTEST_F(NetworkProfilerTest, NetworkProfilerManagerTest001, TestSize.Level1)
434 {
435 auto networkProfilerMgr = std::make_shared<NetworkProfilerManager>();
436 ASSERT_TRUE(networkProfilerMgr != nullptr);
437 networkProfilerMgr->Init();
438
439 std::vector<uint32_t> pluginIds(1);
440 ProfilerPluginConfig config;
441 config.set_name("network");
442 config.set_plugin_sha256("");
443 config.set_sample_interval(20);
444
445 PluginResult result;
446 std::vector<ProfilerPluginConfig> configVec;
447 configVec.push_back(config);
448
449 EXPECT_TRUE(networkProfilerMgr->CreatePluginSession(configVec));
450 EXPECT_FALSE(networkProfilerMgr->StartPluginSession(pluginIds, configVec, result));
451 EXPECT_TRUE(networkProfilerMgr->CreateWriter("name", 0, 0, 0));
452 EXPECT_TRUE(networkProfilerMgr->ResetWriter(0));
453 EXPECT_TRUE(networkProfilerMgr->StopPluginSession(pluginIds));
454 EXPECT_TRUE(networkProfilerMgr->DestroyPluginSession(pluginIds));
455 }
456
457 /**
458 * @tc.name: NetworkProfilerManagerTest002
459 * @tc.desc: test NetworkProfilerManager::NetworkProfilerManagerTest002 with normal case.
460 * @tc.type: FUNC
461 */
462 HWTEST_F(NetworkProfilerTest, NetworkProfilerManagerTest002, TestSize.Level1)
463 {
464 auto networkProfilerMgr = std::make_shared<NetworkProfilerManager>();
465 ASSERT_TRUE(networkProfilerMgr != nullptr);
466 auto commandPoller = std::make_shared<CommandPoller>(networkProfilerMgr);
467 ASSERT_TRUE(commandPoller != nullptr);
468 EXPECT_FALSE(commandPoller->OnConnect());
469 networkProfilerMgr->SetCommandPoller(commandPoller);
470
471 std::vector<uint32_t> pluginIds = {1, 2, 3};
472 EXPECT_FALSE(networkProfilerMgr->RegisterAgentPlugin("network"));
473 EXPECT_TRUE(networkProfilerMgr->ReportPluginBasicData(pluginIds));
474 }
475
476 /**
477 * @tc.name: NetworkProfilerManagerTest003
478 * @tc.desc: test NetworkProfilerManager::NetworkProfilerManagerTest003 with normal case.
479 * @tc.type: FUNC
480 */
481 HWTEST_F(NetworkProfilerTest, NetworkProfilerManagerTest003, TestSize.Level1)
482 {
483 SystemSetParameter("hiviewdfx.hiprofiler.plugins.start", "1");
484 auto networkProfilerMgr = std::make_shared<NetworkProfilerManager>();
485 ASSERT_TRUE(networkProfilerMgr != nullptr);
486
487 auto commandPoller = std::make_shared<CommandPoller>(networkProfilerMgr);
488 ASSERT_TRUE(commandPoller != nullptr);
489 EXPECT_FALSE(commandPoller->OnConnect());
490 networkProfilerMgr->SetCommandPoller(commandPoller);
491
492 EXPECT_FALSE(networkProfilerMgr->RegisterAgentPlugin("network"));
493 ASSERT_TRUE(networkProfilerMgr->LoadPlugin("network"));
494 ASSERT_TRUE(networkProfilerMgr->UnloadPlugin("network"));
495 SystemSetParameter("hiviewdfx.hiprofiler.plugins.start", "0");
496 }
497
498 /**
499 * @tc.name: NetworkProfilerManagerTest004
500 * @tc.desc: test NetworkProfilerManager::NetworkProfilerManagerTest004 with normal case.
501 * @tc.type: FUNC
502 */
503 HWTEST_F(NetworkProfilerTest, NetworkProfilerManagerTest004, TestSize.Level1)
504 {
505 auto networkProfilerMgr = std::make_shared<NetworkProfilerManager>();
506 ASSERT_TRUE(networkProfilerMgr != nullptr);
507 auto commandPoller = std::make_shared<CommandPoller>(networkProfilerMgr);
508 ASSERT_TRUE(commandPoller != nullptr);
509 EXPECT_FALSE(commandPoller->OnConnect());
510 networkProfilerMgr->SetCommandPoller(commandPoller);
511
512 EXPECT_FALSE(networkProfilerMgr->RegisterAgentPlugin("network"));
513 ASSERT_TRUE(networkProfilerMgr->LoadPlugin("network"));
514 ASSERT_TRUE(networkProfilerMgr->UnloadPlugin(commandPoller->GetRequestId()));
515 }
516
517 /**
518 * @tc.name: NetworkProfilerHandleTest001
519 * @tc.desc: test NetworkProfilerHandle::NetworkProfilerHandleTest001 with normal case.
520 * @tc.type: FUNC
521 */
522 HWTEST_F(NetworkProfilerTest, NetworkProfilerHandleTest001, TestSize.Level1)
523 {
524 std::shared_ptr<NetworkProfilerManager> networkProfilerMgr = std::make_shared<NetworkProfilerManager>();
525 NetworkProfilerConfig config;
526 int32_t pid = -1;
527 config.add_pid(pid);
528 config.add_pid(prfolerExePid);
529 config.add_startup_process_name("");
530 config.add_startup_process_name("test_name002");
531 config.add_restart_process_name("");
532 config.set_clock_id(NetworkProfilerConfig::MONOTONIC);
533 networkProfilerMgr->SetConfig(config);
534 EXPECT_TRUE(networkProfilerMgr->CheckConfig());
535
536 auto handle = std::make_shared<NetworkProfilerHandle>(BUFFER_SIZE, true);
537 const int8_t data[] = {1, 2, 3};
538 handle->SerializeData(data, FILE_SIZE);
539 handle->StopHandle();
540 }
541
542 /**
543 * @tc.name: NetworkProfilerHandleTest002
544 * @tc.desc: test NetworkProfilerHandle::NetworkProfilerHandleTest002 with normal case.
545 * @tc.type: FUNC
546 */
547 #ifdef __aarch64__
548 HWTEST_F(NetworkProfilerTest, NetworkProfilerHandleTest002, TestSize.Level1)
549 {
550 auto write = std::make_shared<NetworkProfilerWriter>(WRITER_NAME, SMB1_SIZE, g_smbFd1, -1, false);
551 EXPECT_NE(write->shareMemoryBlock_, nullptr);
552 uint8_t buffer1[] = {0x55, 0xAA, 0x55, 0xAA};
553 std::shared_ptr<NetworkProfilerManager> networkProfilerMgr = std::make_shared<NetworkProfilerManager>();
554 NetworkProfilerConfig config;
555 int32_t pid = 1;
556 config.add_pid(pid);
557 config.add_pid(prfolerExePid);
558 config.add_startup_process_name("");
559 config.add_startup_process_name("test_name003");
560 config.add_restart_process_name("");
561 config.set_clock_id(NetworkProfilerConfig::MONOTONIC);
562 networkProfilerMgr->SetConfig(config);
563 EXPECT_TRUE(networkProfilerMgr->CheckConfig());
564 EXPECT_FALSE(networkProfilerMgr->StartNetworkProfiler());
565 EXPECT_TRUE(networkProfilerMgr->CreateWriter("name", 0, 0, 0, false));
566 auto handle = std::make_shared<NetworkProfilerHandle>(BUFFER_SIZE, true);
567 const int8_t data[] = {1, 2, 3};
568 handle->SerializeData(data, FILE_SIZE);
569
570 EXPECT_TRUE(write->Write((const void*)buffer1, sizeof(buffer1)));
571 handle->SetWriter(write);
572 handle->StopHandle();
573 }
574 #endif
575
576 /**
577 * @tc.name: NetworkProfilerHandleTest003
578 * @tc.desc: test NetworkProfilerHandle::NetworkProfilerHandleTest003 with normal case.
579 * @tc.type: FUNC
580 */
581 HWTEST_F(NetworkProfilerTest, NetworkProfilerHandleTest003, TestSize.Level1)
582 {
583 std::shared_ptr<NetworkProfilerManager> networkProfilerMgr = std::make_shared<NetworkProfilerManager>();
584 NetworkProfilerConfig config;
585 int32_t pid = 1;
586 config.add_pid(pid);
587 config.add_pid(prfolerExePid);
588 config.add_startup_process_name("network");
589 config.set_clock_id(NetworkProfilerConfig::MONOTONIC);
590 networkProfilerMgr->SetConfig(config);
591 EXPECT_TRUE(networkProfilerMgr->CheckConfig());
592 EXPECT_FALSE(networkProfilerMgr->StartNetworkProfiler());
593 EXPECT_TRUE(networkProfilerMgr->CreateWriter("name", 0, 0, 0, true));
594
595 auto handle = std::make_shared<NetworkProfilerHandle>(BUFFER_SIZE, true);
596 const int8_t data[] = {};
597 handle->SerializeData(data, 0);
598
599 handle->StopHandle();
600 ASSERT_TRUE(networkProfilerMgr->UnloadPlugin("network"));
601 }
602
603 /**
604 * @tc.name: NetworkProfilerSocketServiceTest004
605 * @tc.desc: test NetworkProfilerSocketService::NetworkProfilerSocketServiceTest004 with normal case.
606 * @tc.type: FUNC
607 */
608 HWTEST_F(NetworkProfilerTest, NetworkProfilerSocketServiceTest004, TestSize.Level1)
609 {
610 uint64_t config = FILE_SIZE;
611 config <<= MOBILE_BIT;
612 config |= SMB1_SIZE;
613 auto networkProfilerMgr = std::make_shared<NetworkProfilerManager>();
614 auto socketService_ = std::make_shared<NetworkProfilerSocketService>(networkProfilerMgr);
615
616 SocketContext socketContext;
617 auto ptr = reinterpret_cast<const int8_t*>(&config);
618 auto size = sizeof(uint64_t);
619 ASSERT_FALSE(socketService_->ProtocolProc(socketContext, 0, ptr, size));
620 }
621
622 /**
623 * @tc.name: NetworkProfilerSocketServiceTest005
624 * @tc.desc: test NetworkProfilerSocketService::NetworkProfilerSocketServiceTest005 with normal case.
625 * @tc.type: FUNC
626 */
627 HWTEST_F(NetworkProfilerTest, NetworkProfilerSocketServiceTest005, TestSize.Level1)
628 {
629 uint64_t config = FILE_SIZE;
630 config <<= MOBILE_BIT;
631 config |= SMB1_SIZE;
632 auto networkProfilerMgr = std::make_shared<NetworkProfilerManager>();
633 auto socketService = std::make_shared<NetworkProfilerSocketService>(networkProfilerMgr);
634
635 SocketContext socketContext;
636 auto ptr = reinterpret_cast<const int8_t*>(&config);
637 auto size = sizeof(int);
638 socketService->SetConfig(sizeof(uint64_t), sizeof(uint64_t), true, 0);
639 ASSERT_FALSE(socketService->ProtocolProc(socketContext, 0, ptr, size));
640 }
641
642 /**
643 * @tc.name: NetworkProfilerSocketServiceTest006
644 * @tc.desc: test NetworkProfilerSocketService::NetworkProfilerSocketServiceTest006 with normal case.
645 * @tc.type: FUNC
646 */
647 HWTEST_F(NetworkProfilerTest, NetworkProfilerSocketServiceTest006, TestSize.Level1)
648 {
649 auto networkProfilerMgr = std::make_shared<NetworkProfilerManager>();
650 auto socketService = std::make_shared<NetworkProfilerSocketService>(networkProfilerMgr);
651
652 SocketContext socketContext;
653 int pid = -1;
654 const int8_t* ptr = reinterpret_cast<const int8_t*>(&pid);
655 socketService->SetConfig(sizeof(uint64_t), sizeof(uint64_t), true, 0);
656 ASSERT_FALSE(socketService->ProtocolProc(socketContext, 0, ptr, sizeof(pid)));
657 }
658
659 } // namespace
660