1 /*
2  * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 
18 #include <securec.h>
19 #include <sys/socket.h>
20 #include <sys/un.h>
21 #include <unistd.h>
22 #include "dfx_exception.h"
23 #include "dfx_util.h"
24 #include "faultloggerd_client.h"
25 #include "fault_logger_config.h"
26 #include "faultloggerd_socket.h"
27 
28 #define private public
29 #include "fault_logger_daemon.h"
30 #undef private
31 
32 using namespace OHOS::HiviewDFX;
33 using namespace testing::ext;
34 using namespace std;
35 
36 namespace OHOS {
37 namespace HiviewDFX {
38 class FaultLoggerDaemonTest : public testing::Test {
39 public:
SetUpTestCase(void)40     static void SetUpTestCase(void) {}
TearDownTestCase(void)41     static void TearDownTestCase(void) {}
SetUp()42     void SetUp() {}
TearDown()43     void TearDown() {}
44 };
45 } // namespace HiviewDFX
46 } // namespace OHOS
47 
48 namespace {
49 /**
50  * @tc.name: FaultLoggerDaemonTest001
51  * @tc.desc: test HandleDefaultClientRequest/HandleLogFileDesClientRequest func
52  * @tc.type: FUNC
53  */
54 HWTEST_F (FaultLoggerDaemonTest, FaultLoggerDaemonTest001, TestSize.Level2)
55 {
56     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest001: start.";
57     std::shared_ptr<FaultLoggerDaemon> daemon = std::make_shared<FaultLoggerDaemon>();
58     bool ret = daemon->InitEnvironment();
59     ASSERT_TRUE(ret);
60     struct FaultLoggerdRequest faultloggerdRequest;
61     if (memset_s(&faultloggerdRequest, sizeof(faultloggerdRequest), 0, sizeof(struct FaultLoggerdRequest)) != 0) {
62         GTEST_LOG_(ERROR) << "memset_s failed" ;
63         ASSERT_TRUE(false);
64     }
65     faultloggerdRequest.type = 0;
66     faultloggerdRequest.pid = getpid();
67     faultloggerdRequest.tid = gettid();
68     faultloggerdRequest.uid = getuid();
69     daemon->HandleDefaultClientRequest(-1, &faultloggerdRequest);
70     faultloggerdRequest.type = 2; // 2 : CPP_CRASH
71     daemon->HandleDefaultClientRequest(-1, &faultloggerdRequest);
72     daemon->HandleLogFileDesClientRequest(-1, &faultloggerdRequest);
73     faultloggerdRequest.type = 101; // 101 : CPP_STACKTRACE
74     daemon->HandleDefaultClientRequest(-1, &faultloggerdRequest);
75     faultloggerdRequest.type = 102; // 102 : JS_STACKTRACE
76     daemon->HandleDefaultClientRequest(-1, &faultloggerdRequest);
77     faultloggerdRequest.type = 103; // 103 : JS_HEAP_SNAPSHOT
78     daemon->HandleDefaultClientRequest(-1, &faultloggerdRequest);
79     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest001: end.";
80 }
81 
82 /**
83  * @tc.name: FaultLoggerDaemonTest002
84  * @tc.desc: test HandleSdkDumpRequest/HandlePipeFdClientRequest func
85  * @tc.type: FUNC
86  */
87 HWTEST_F (FaultLoggerDaemonTest, FaultLoggerDaemonTest002, TestSize.Level2)
88 {
89     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest002: start.";
90     std::shared_ptr<FaultLoggerDaemon> daemon = std::make_shared<FaultLoggerDaemon>();
91     bool ret = daemon->InitEnvironment();
92     ASSERT_TRUE(ret);
93     struct FaultLoggerdRequest faultloggerdRequest;
94     if (memset_s(&faultloggerdRequest, sizeof(faultloggerdRequest), 0, sizeof(struct FaultLoggerdRequest)) != 0) {
95         GTEST_LOG_(ERROR) << "memset_s failed" ;
96         ASSERT_TRUE(false);
97     }
98     faultloggerdRequest.type = 2; // 2 : CPP_CRASH
99     faultloggerdRequest.pid = getpid();
100     faultloggerdRequest.tid = gettid();
101     faultloggerdRequest.uid = getuid();
102     daemon->HandleSdkDumpRequest(-1, &faultloggerdRequest);
103     faultloggerdRequest.pipeType = FaultLoggerPipeType::PIPE_FD_READ_BUF;
104     daemon->HandlePipeFdClientRequest(-1, &faultloggerdRequest);
105     faultloggerdRequest.pipeType = FaultLoggerPipeType::PIPE_FD_WRITE_BUF;
106     daemon->HandlePipeFdClientRequest(-1, &faultloggerdRequest);
107     faultloggerdRequest.pipeType = FaultLoggerPipeType::PIPE_FD_READ_RES;
108     daemon->HandlePipeFdClientRequest(-1, &faultloggerdRequest);
109     faultloggerdRequest.pipeType = FaultLoggerPipeType::PIPE_FD_WRITE_RES;
110     daemon->HandlePipeFdClientRequest(-1, &faultloggerdRequest);
111     faultloggerdRequest.pipeType = FaultLoggerPipeType::PIPE_FD_DELETE;
112     daemon->HandlePipeFdClientRequest(-1, &faultloggerdRequest);
113     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest002: end.";
114 }
115 
116 /**
117  * @tc.name: FaultLoggerDaemonTest003
118  * @tc.desc: test HandleSdkDumpRequest func
119  * @tc.type: FUNC
120  */
121 HWTEST_F (FaultLoggerDaemonTest, FaultLoggerDaemonTest003, TestSize.Level2)
122 {
123     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest003: start.";
124     std::shared_ptr<FaultLoggerDaemon> daemon = std::make_shared<FaultLoggerDaemon>();
125     bool ret = daemon->InitEnvironment();
126     ASSERT_TRUE(ret);
127     struct FaultLoggerdRequest faultloggerdRequest;
128     if (memset_s(&faultloggerdRequest, sizeof(faultloggerdRequest), 0, sizeof(struct FaultLoggerdRequest)) != 0) {
129         GTEST_LOG_(ERROR) << "memset_s failed" ;
130         ASSERT_TRUE(false);
131     }
132     faultloggerdRequest.type = 2; // 2 : CPP_CRASH
133     faultloggerdRequest.pid = getpid();
134     faultloggerdRequest.tid = gettid();
135     faultloggerdRequest.uid = getuid();
136     daemon->HandleSdkDumpRequest(-1, &faultloggerdRequest);
137     faultloggerdRequest.tid = 0;
138     daemon->HandleSdkDumpRequest(-1, &faultloggerdRequest);
139     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest003: end.";
140 }
141 
142 /**
143  * @tc.name: FaultLoggerDaemonTest004
144  * @tc.desc: test CreateFileForRequest func
145  * @tc.type: FUNC
146  */
147 HWTEST_F (FaultLoggerDaemonTest, FaultLoggerDaemonTest004, TestSize.Level2)
148 {
149     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest004: start.";
150     std::shared_ptr<FaultLoggerDaemon> daemon = std::make_shared<FaultLoggerDaemon>();
151     int32_t type = (int32_t)FaultLoggerType::CPP_CRASH;
152     int32_t pid = getpid();
153     uint64_t time = GetTimeMilliSeconds();
154     int fd = daemon->CreateFileForRequest(type, pid, 0, time, false);
155     ASSERT_NE(fd, -1);
156     close(fd);
157     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest004: end.";
158 }
159 
160 /**
161  * @tc.name: FaultLoggerDaemonTest005
162  * @tc.desc: test CreateFileForRequest JIT_CODE_LOG and FFRT_CRASH_LOG branch
163  * @tc.type: FUNC
164  */
165 HWTEST_F (FaultLoggerDaemonTest, FaultLoggerDaemonTest005, TestSize.Level2)
166 {
167     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest005: start.";
168     std::shared_ptr<FaultLoggerDaemon> daemon = std::make_shared<FaultLoggerDaemon>();
169     bool ret = daemon->InitEnvironment();
170     ASSERT_TRUE(ret);
171 
172     int32_t pid = getpid();
173     uint64_t time = GetTimeMilliSeconds();
174     int32_t type = static_cast<int32_t>(FaultLoggerType::JIT_CODE_LOG);
175     int fd = daemon->CreateFileForRequest(type, pid, 0, time, false);
176     ASSERT_NE(fd, -1);
177     type = static_cast<int32_t>(FaultLoggerType::FFRT_CRASH_LOG);
178     fd = daemon->CreateFileForRequest(type, pid, 0, time, false);
179     ASSERT_NE(fd, -1);
180     close(fd);
181     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest005: end.";
182 }
183 
DoClientProcess(const std::string & socketFileName)184 void DoClientProcess(const std::string& socketFileName)
185 {
186     sleep(2); // 2 : wait 2 seconds, waiting for the service to be ready
187     int clientSocketFd = -1;
188     bool ret = StartConnect(clientSocketFd, socketFileName.c_str(), 10); // 10 : socket connect time out 10 second
189     ASSERT_TRUE(ret);
190     ASSERT_NE(clientSocketFd, -1);
191     GTEST_LOG_(INFO) << "child connect finished, client fd:" << clientSocketFd;
192 
193     int data = 12345; // 12345 is for server Cred test
194     ret = SendMsgIovToSocket(clientSocketFd, reinterpret_cast<void *>(&data), sizeof(data));
195     ASSERT_TRUE(ret);
196 
197     GTEST_LOG_(INFO) << "Start read file desc";
198     int testFd = ReadFileDescriptorFromSocket(clientSocketFd);
199     GTEST_LOG_(INFO) << "recv testFd:" << testFd;
200     ASSERT_NE(testFd, -1);
201     close(clientSocketFd);
202     close(testFd);
203 }
204 
TestSecurityCheck(const std::string & socketFileName)205 void TestSecurityCheck(const std::string& socketFileName)
206 {
207     int32_t serverSocketFd = -1;
208     bool ret = StartListen(serverSocketFd, socketFileName.c_str(), 5); // 5: means max connection count is 5
209     ASSERT_TRUE(ret);
210     ASSERT_NE(serverSocketFd, -1);
211     GTEST_LOG_(INFO) << "server start listen fd:" << serverSocketFd;
212 
213     struct timeval timev = {
214         20, // 20 : recv timeout 20 seconds
215         0
216     };
217     void* pTimev = &timev;
218     int retOpt = OHOS_TEMP_FAILURE_RETRY(setsockopt(serverSocketFd, SOL_SOCKET, SO_RCVTIMEO,
219         static_cast<const char*>(pTimev), sizeof(struct timeval)));
220     ASSERT_NE(retOpt, -1);
221 
222     struct sockaddr_un clientAddr;
223     socklen_t clientAddrSize = static_cast<socklen_t>(sizeof(clientAddr));
224     int32_t connectionFd = OHOS_TEMP_FAILURE_RETRY(accept(serverSocketFd,
225         reinterpret_cast<struct sockaddr *>(&clientAddr), &clientAddrSize));
226     ASSERT_GT(connectionFd, 0);
227 
228     std::shared_ptr<FaultLoggerDaemon> daemon = std::make_shared<FaultLoggerDaemon>();
229     struct FaultLoggerdRequest faultloggerdRequest;
230     if (memset_s(&faultloggerdRequest, sizeof(faultloggerdRequest), 0, sizeof(struct FaultLoggerdRequest)) != 0) {
231         GTEST_LOG_(ERROR) << "memset_s failed" ;
232         ASSERT_TRUE(false);
233     }
234     faultloggerdRequest.type = 2; // 2 : CPP_CRASH
235     faultloggerdRequest.pid = getpid();
236     faultloggerdRequest.tid = gettid();
237     faultloggerdRequest.uid = getuid();
238 
239     FaultLoggerCheckPermissionResp resp = daemon->SecurityCheck(connectionFd, &faultloggerdRequest);
240     ASSERT_EQ(resp, FaultLoggerCheckPermissionResp::CHECK_PERMISSION_REJECT);
241 
242     close(connectionFd);
243     close(serverSocketFd);
244 }
245 
246 /**
247  * @tc.name: FaultLoggerDaemonTest006
248  * @tc.desc: test SecurityCheck abnormal branch
249  * @tc.type: FUNC
250  */
251 HWTEST_F (FaultLoggerDaemonTest, FaultLoggerDaemonTest006, TestSize.Level2)
252 {
253     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest006: start.";
254     std::string testSocketName = "faultloggerd.server.test";
255     int32_t pid = fork();
256     if (pid == 0) {
257         DoClientProcess(testSocketName);
258         GTEST_LOG_(INFO) << "client exit";
259         exit(0);
260     } else if (pid > 0) {
261         TestSecurityCheck(testSocketName);
262 
263         int status;
264         if (waitpid(pid, &status, 0) == -1) {
265             return;
266         }
267 
268         int exitCode = -1;
269         if (WIFEXITED(status)) {
270             exitCode = WEXITSTATUS(status);
271             GTEST_LOG_(INFO) << "Exit status was " << exitCode;
272         }
273         ASSERT_EQ(exitCode, 0);
274     }
275     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest006: end.";
276 }
277 
TestCheckRequestCredential(const std::string & socketFileName)278 void TestCheckRequestCredential(const std::string& socketFileName)
279 {
280     int32_t serverSocketFd = -1;
281     bool ret = StartListen(serverSocketFd, socketFileName.c_str(), 5); // 5: means max connection count is 5
282     ASSERT_TRUE(ret);
283     ASSERT_NE(serverSocketFd, -1);
284     GTEST_LOG_(INFO) << "server start listen fd:" << serverSocketFd;
285 
286     struct timeval timev = {
287         20, // 20 : recv timeout 20 seconds
288         0
289     };
290     void* pTimev = &timev;
291     int retOpt = OHOS_TEMP_FAILURE_RETRY(setsockopt(serverSocketFd, SOL_SOCKET, SO_RCVTIMEO,
292         static_cast<const char*>(pTimev), sizeof(struct timeval)));
293     ASSERT_NE(retOpt, -1);
294 
295     struct sockaddr_un clientAddr;
296     socklen_t clientAddrSize = static_cast<socklen_t>(sizeof(clientAddr));
297     int32_t connectionFd = OHOS_TEMP_FAILURE_RETRY(accept(serverSocketFd,
298         reinterpret_cast<struct sockaddr *>(&clientAddr), &clientAddrSize));
299     ASSERT_GT(connectionFd, 0);
300 
301     std::shared_ptr<FaultLoggerDaemon> daemon = std::make_shared<FaultLoggerDaemon>();
302     struct FaultLoggerdRequest faultloggerdRequest;
303     if (memset_s(&faultloggerdRequest, sizeof(faultloggerdRequest), 0, sizeof(struct FaultLoggerdRequest)) != 0) {
304         GTEST_LOG_(ERROR) << "memset_s failed" ;
305         ASSERT_TRUE(false);
306     }
307     faultloggerdRequest.type = 2; // 2 : CPP_CRASH
308     faultloggerdRequest.pid = getpid();
309     faultloggerdRequest.tid = gettid();
310     faultloggerdRequest.uid = getuid();
311 
312     bool result = daemon->CheckRequestCredential(connectionFd, nullptr);
313     ASSERT_EQ(result, false);
314     result = daemon->CheckRequestCredential(connectionFd, &faultloggerdRequest);
315     ASSERT_EQ(result, false);
316 
317     close(connectionFd);
318     close(serverSocketFd);
319 }
320 
321 /**
322  * @tc.name: FaultLoggerDaemonTest007
323  * @tc.desc: test CheckRequestCredential abnormal branch
324  * @tc.type: FUNC
325  */
326 HWTEST_F (FaultLoggerDaemonTest, FaultLoggerDaemonTest007, TestSize.Level2)
327 {
328     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest007: start.";
329     std::string testSocketName = "faultloggerd.server.test";
330     int32_t pid = fork();
331     if (pid == 0) {
332         DoClientProcess(testSocketName);
333         GTEST_LOG_(INFO) << "client exit";
334         exit(0);
335     } else if (pid > 0) {
336         TestCheckRequestCredential(testSocketName);
337 
338         int status;
339         if (waitpid(pid, &status, 0) == -1) {
340             return;
341         }
342 
343         int exitCode = -1;
344         if (WIFEXITED(status)) {
345             exitCode = WEXITSTATUS(status);
346             GTEST_LOG_(INFO) << "Exit status was " << exitCode;
347         }
348         ASSERT_EQ(exitCode, 0);
349     }
350     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest007: end.";
351 }
352 
TestHandleExceptionRequest(const std::string & socketFileName)353 void TestHandleExceptionRequest(const std::string& socketFileName)
354 {
355     int32_t serverSocketFd = -1;
356     bool ret = StartListen(serverSocketFd, socketFileName.c_str(), 5); // 5: means max connection count is 5
357     ASSERT_TRUE(ret);
358     ASSERT_NE(serverSocketFd, -1);
359     GTEST_LOG_(INFO) << "server start listen fd:" << serverSocketFd;
360 
361     struct timeval timev = {
362         20, // 20 : recv timeout 20 seconds
363         0
364     };
365     void* pTimev = &timev;
366     int retOpt = OHOS_TEMP_FAILURE_RETRY(setsockopt(serverSocketFd, SOL_SOCKET, SO_RCVTIMEO,
367         static_cast<const char*>(pTimev), sizeof(struct timeval)));
368     ASSERT_NE(retOpt, -1);
369 
370     struct sockaddr_un clientAddr;
371     socklen_t clientAddrSize = static_cast<socklen_t>(sizeof(clientAddr));
372     int32_t connectionFd = OHOS_TEMP_FAILURE_RETRY(accept(serverSocketFd,
373         reinterpret_cast<struct sockaddr *>(&clientAddr), &clientAddrSize));
374     ASSERT_GT(connectionFd, 0);
375 
376     std::shared_ptr<FaultLoggerDaemon> daemon = std::make_shared<FaultLoggerDaemon>();
377     struct FaultLoggerdRequest faultloggerdRequest;
378     if (memset_s(&faultloggerdRequest, sizeof(faultloggerdRequest), 0, sizeof(struct FaultLoggerdRequest)) != 0) {
379         GTEST_LOG_(ERROR) << "memset_s failed" ;
380         ASSERT_TRUE(false);
381     }
382     faultloggerdRequest.type = 2; // 2 : CPP_CRASH
383     faultloggerdRequest.pid = getpid();
384     faultloggerdRequest.tid = gettid();
385     faultloggerdRequest.uid = getuid();
386 
387     daemon->HandleExceptionRequest(connectionFd, &faultloggerdRequest);
388 
389     close(connectionFd);
390     close(serverSocketFd);
391 }
392 
393 /**
394  * @tc.name: FaultLoggerDaemonTest008
395  * @tc.desc: test HandleExceptionRequest abnormal branch
396  * @tc.type: FUNC
397  */
398 HWTEST_F (FaultLoggerDaemonTest, FaultLoggerDaemonTest008, TestSize.Level2)
399 {
400     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest008: start.";
401     std::string testSocketName = "faultloggerd.server.test";
402     int32_t pid = fork();
403     if (pid == 0) {
404         DoClientProcess(testSocketName);
405         GTEST_LOG_(INFO) << "client exit";
406         exit(0);
407     } else if (pid > 0) {
408         TestHandleExceptionRequest(testSocketName);
409 
410         int status;
411         if (waitpid(pid, &status, 0) == -1) {
412             return;
413         }
414 
415         int exitCode = -1;
416         if (WIFEXITED(status)) {
417             exitCode = WEXITSTATUS(status);
418             GTEST_LOG_(INFO) << "Exit status was " << exitCode;
419         }
420         ASSERT_EQ(exitCode, 0);
421     }
422     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest008: end.";
423 }
424 
425 /**
426  * @tc.name: FaultLoggerDaemonTest009
427  * @tc.desc: test HandleAccept abnormal branch
428  * @tc.type: FUNC
429  */
430 HWTEST_F (FaultLoggerDaemonTest, FaultLoggerDaemonTest009, TestSize.Level2)
431 {
432     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest009: start.";
433     std::shared_ptr<FaultLoggerDaemon> daemon = std::make_shared<FaultLoggerDaemon>();
434     bool ret = daemon->InitEnvironment();
435     ASSERT_TRUE(ret);
436     daemon->HandleAccept(1, 1);
437     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest009: end.";
438 }
439 
440 /**
441  * @tc.name: FaultLoggerDaemonTest010
442  * @tc.desc: test HandleRequest and HandleRequestByClientType abnormal branch
443  * @tc.type: FUNC
444  */
445 HWTEST_F (FaultLoggerDaemonTest, FaultLoggerDaemonTest010, TestSize.Level2)
446 {
447     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest010: start.";
448     std::shared_ptr<FaultLoggerDaemon> daemon = std::make_shared<FaultLoggerDaemon>();
449     bool ret = daemon->InitEnvironment();
450     ASSERT_TRUE(ret);
451 
452     int32_t epollFd = 1;
453     int32_t connectionFd = 4; // 4 : simulate an fd greater than 3
454     daemon->HandleRequest(epollFd, connectionFd);
455     connectionFd = 1;
456     daemon->HandleRequest(epollFd, connectionFd);
457 
458     FaultLoggerdRequest request;
459     request.clientType = FaultLoggerClientType::DEFAULT_CLIENT;
460     daemon->HandleRequestByClientType(connectionFd, &request);
461     request.clientType = FaultLoggerClientType::LOG_FILE_DES_CLIENT;
462     daemon->HandleRequestByClientType(connectionFd, &request);
463     request.clientType = FaultLoggerClientType::PRINT_T_HILOG_CLIENT;
464     daemon->HandleRequestByClientType(connectionFd, &request);
465     request.clientType = FaultLoggerClientType::PERMISSION_CLIENT;
466     daemon->HandleRequestByClientType(connectionFd, &request);
467     request.clientType = FaultLoggerClientType::SDK_DUMP_CLIENT;
468     daemon->HandleRequestByClientType(connectionFd, &request);
469     request.clientType = FaultLoggerClientType::PIPE_FD_CLIENT;
470     daemon->HandleRequestByClientType(connectionFd, &request);
471     request.clientType = FaultLoggerClientType::REPORT_EXCEPTION_CLIENT;
472     daemon->HandleRequestByClientType(connectionFd, &request);
473     request.clientType = -1;
474     daemon->HandleRequestByClientType(connectionFd, &request);
475     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest010: end.";
476 }
477 
478 /**
479  * @tc.name: FaultLoggerDaemonTest011
480  * @tc.desc: test HandleRequestByPipeType abnormal branch
481  * @tc.type: FUNC
482  */
483 HWTEST_F (FaultLoggerDaemonTest, FaultLoggerDaemonTest011, TestSize.Level2)
484 {
485     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest011: start.";
486     std::shared_ptr<FaultLoggerDaemon> daemon = std::make_shared<FaultLoggerDaemon>();
487     bool ret = daemon->InitEnvironment();
488     ASSERT_TRUE(ret);
489 
490     int fd = -1;
491     int32_t connectionFd = 1;
492     FaultLoggerdRequest request;
493     FaultLoggerPipe2* faultLoggerPipe = new FaultLoggerPipe2(GetTimeMilliSeconds());
494     request.pipeType = FaultLoggerPipeType::PIPE_FD_READ_BUF;
495     daemon->HandleRequestByPipeType(fd, connectionFd, &request, faultLoggerPipe);
496     request.pipeType = FaultLoggerPipeType::PIPE_FD_WRITE_BUF;
497     daemon->HandleRequestByPipeType(fd, connectionFd, &request, faultLoggerPipe);
498     request.pipeType = FaultLoggerPipeType::PIPE_FD_READ_RES;
499     daemon->HandleRequestByPipeType(fd, connectionFd, &request, faultLoggerPipe);
500     request.pipeType = FaultLoggerPipeType::PIPE_FD_WRITE_RES;
501     daemon->HandleRequestByPipeType(fd, connectionFd, &request, faultLoggerPipe);
502     request.pipeType = FaultLoggerPipeType::PIPE_FD_JSON_READ_BUF;
503     daemon->HandleRequestByPipeType(fd, connectionFd, &request, faultLoggerPipe);
504     request.pipeType = FaultLoggerPipeType::PIPE_FD_JSON_WRITE_BUF;
505     daemon->HandleRequestByPipeType(fd, connectionFd, &request, faultLoggerPipe);
506     request.pipeType = FaultLoggerPipeType::PIPE_FD_JSON_READ_RES;
507     daemon->HandleRequestByPipeType(fd, connectionFd, &request, faultLoggerPipe);
508     request.pipeType = FaultLoggerPipeType::PIPE_FD_JSON_WRITE_RES;
509     daemon->HandleRequestByPipeType(fd, connectionFd, &request, faultLoggerPipe);
510     request.pipeType = FaultLoggerPipeType::PIPE_FD_DELETE;
511     daemon->HandleRequestByPipeType(fd, connectionFd, &request, faultLoggerPipe);
512     request.pipeType = -1;
513     daemon->HandleRequestByPipeType(fd, connectionFd, &request, faultLoggerPipe);
514     GTEST_LOG_(INFO) << "FaultLoggerDaemonTest011: end.";
515 }
516 }