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 <gtest/gtest.h>
18#include <iomanip>
19#include <sys/time.h>
20#include <sys/types.h>
21#include <ctime>
22#include <unistd.h>
23#include <vector>
24
25#include "logging.h"
26#include "memory_data_plugin.h"
27#include "plugin_module_api.h"
28#include "sample_plugin.h"
29#include "stream_plugin.h"
30
31using namespace testing::ext;
32
33namespace {
34constexpr uint32_t MAX_BUFFER_SIZE = 4 * 1024 * 1024;
35std::mutex g_taskMutex;
36std::unique_ptr<MemoryDataPlugin> memoryPlugin = nullptr;
37std::unique_ptr<StreamPlugin> streamPlugin = nullptr;
38std::unique_ptr<SamplePlugin> samplePlugin = nullptr;
39
40class PluginModuleApiTest : public ::testing::Test {
41public:
42    PluginModuleCallbacks* memoryCallbacks_;
43    PluginModuleCallbacks* sampleCallbacks_;
44    PluginModuleCallbacks* streamCallbacks_;
45
46    PluginModuleStruct memoryModule_;
47    PluginModuleStruct sampleModule_;
48    PluginModuleStruct streamModule_;
49
50    WriterStruct* writer_;
51protected:
52    static void SetUpTestCase() {}
53    static void TearDownTestCase() {}
54
55    void SetUp()
56    {
57        memoryCallbacks_ = nullptr;
58        sampleCallbacks_ = nullptr;
59        streamCallbacks_ = nullptr;
60        memoryModule_ = {memoryCallbacks_, "memory-plugin", "1.01", MAX_BUFFER_SIZE};
61        sampleModule_ = {sampleCallbacks_, "sample-plugin", "1.01", MAX_BUFFER_SIZE};
62        streamModule_ = {streamCallbacks_, "stream-plugin", "1.01", MAX_BUFFER_SIZE};
63        writer_ = nullptr;
64    }
65
66    bool PollPluginStub(MemoryDataPlugin& plugin, MemoryConfig& protoConfig, MemoryData& protoData);
67    bool StreamPluginStub(StreamPlugin& plugin, StreamConfig& protoConfig, StreamData& protoData);
68    // memory
69    static int MemDataPluginSessionStart(const uint8_t* configData, uint32_t configSize);
70    static int MemPluginReportResult(uint8_t* bufferData, uint32_t bufferSize);
71    static int MemPluginSessionStop();
72
73    // stream
74    static int StreamPluginSessionStart(const uint8_t* configData, uint32_t configSize);
75    static int StreamPluginSessionStop();
76    static int StreamRegisterWriterStruct(WriterStruct* writer);
77    static long Write(WriterStruct* writer, const void* data, size_t size);
78    static bool Flush(WriterStruct* writer);
79
80    // sample
81    static int SamplePluginSessionStart(const uint8_t* configData, uint32_t configSize);
82    static int SamplePluginReportResult(uint8_t* bufferData, uint32_t bufferSize);
83    static int SamplePluginSessionStop();
84    void SetSampleConfig(std::vector<uint8_t>& configData, uint32_t& configSize);
85    void SetMemoryConfig(std::vector<uint8_t>& configData, uint32_t& configSize);
86    void SetStreamConfig(std::vector<uint8_t>& configData, uint32_t& configSize);
87};
88
89// memory
90int PluginModuleApiTest::MemDataPluginSessionStart(const uint8_t* configData, uint32_t configSize)
91{
92    std::lock_guard<std::mutex> guard(g_taskMutex);
93    memoryPlugin = std::make_unique<MemoryDataPlugin>();
94    return memoryPlugin->Start(configData, configSize);
95}
96
97int PluginModuleApiTest::MemPluginReportResult(uint8_t* bufferData, uint32_t bufferSize)
98{
99    std::lock_guard<std::mutex> guard(g_taskMutex);
100    return memoryPlugin->Report(bufferData, bufferSize);
101}
102
103int PluginModuleApiTest::MemPluginSessionStop()
104{
105    std::lock_guard<std::mutex> guard(g_taskMutex);
106    CHECK_TRUE(memoryPlugin != nullptr, -1, "memoryPlugin is null!!!");
107    memoryPlugin->Stop();
108    memoryPlugin = nullptr;
109    return 0;
110}
111
112// stream
113int PluginModuleApiTest::StreamPluginSessionStart(const uint8_t* configData, uint32_t configSize)
114{
115    std::lock_guard<std::mutex> guard(g_taskMutex);
116    CHECK_TRUE(streamPlugin != nullptr, -1, "PluginStub::start plugin fail!!!");
117    return streamPlugin->Start(configData, configSize);
118}
119
120int PluginModuleApiTest::StreamPluginSessionStop()
121{
122    std::lock_guard<std::mutex> guard(g_taskMutex);
123    streamPlugin->Stop();
124    streamPlugin = nullptr;
125    return 0;
126}
127
128int PluginModuleApiTest::StreamRegisterWriterStruct(WriterStruct* writer)
129{
130    std::lock_guard<std::mutex> guard(g_taskMutex);
131    streamPlugin = std::make_unique<StreamPlugin>();
132    streamPlugin->SetWriter(writer);
133    return 0;
134}
135
136// write
137long PluginModuleApiTest::Write(WriterStruct* writer, const void* data, size_t size)
138{
139    PROFILER_LOG_INFO(LOG_CORE, "PluginModuleApiTest::Write no implementation !");
140    return 0;
141}
142
143bool PluginModuleApiTest::Flush(WriterStruct* writer)
144{
145    PROFILER_LOG_INFO(LOG_CORE, "PluginModuleApiTest::Write no implementation !");
146    return true;
147}
148
149// sample
150int PluginModuleApiTest::SamplePluginSessionStart(const uint8_t* configData, uint32_t configSize)
151{
152    std::lock_guard<std::mutex> guard(g_taskMutex);
153    samplePlugin = std::make_unique<SamplePlugin>();
154    return samplePlugin->Start(configData, configSize);
155}
156
157int PluginModuleApiTest::SamplePluginReportResult(uint8_t* bufferData, uint32_t bufferSize)
158{
159    std::lock_guard<std::mutex> guard(g_taskMutex);
160    return samplePlugin->Report(bufferData, bufferSize);
161}
162
163int PluginModuleApiTest::SamplePluginSessionStop()
164{
165    std::lock_guard<std::mutex> guard(g_taskMutex);
166    samplePlugin->Stop();
167    samplePlugin = nullptr;
168    return 0;
169}
170
171void PluginModuleApiTest::SetSampleConfig(std::vector<uint8_t>& configData, uint32_t& configSize)
172{
173    SampleConfig protoConfig;
174    protoConfig.set_pid(1);
175    // serialize
176    protoConfig.SerializeToArray(configData.data(), configData.size());
177    configSize = protoConfig.ByteSizeLong();
178}
179
180void PluginModuleApiTest::SetMemoryConfig(std::vector<uint8_t>& configData, uint32_t& configSize)
181{
182    MemoryConfig protoConfig;
183    protoConfig.set_report_process_mem_info(true);
184    protoConfig.add_pid(1);
185    // serialize
186    protoConfig.SerializeToArray(configData.data(), configSize);
187    configSize = protoConfig.ByteSizeLong();
188}
189
190void PluginModuleApiTest::SetStreamConfig(std::vector<uint8_t>& configData, uint32_t& configSize)
191{
192    StreamConfig protoConfig;
193    protoConfig.set_pid(1);
194    // serialize
195    protoConfig.SerializeToArray(configData.data(), configSize);
196    configSize = protoConfig.ByteSizeLong();
197}
198
199// 流式调用写接口
200HWTEST_F(PluginModuleApiTest, StreamPluginRegister1, TestSize.Level1)
201{
202    PluginModuleCallbacks callbacks = {
203        StreamPluginSessionStart,
204        0,
205        StreamPluginSessionStop,
206        (RegisterWriterStructCallback)StreamRegisterWriterStruct,
207    };
208    streamCallbacks_ = &callbacks;
209
210    EXPECT_NE(streamCallbacks_->onRegisterWriterStruct, nullptr);
211    EXPECT_EQ(streamCallbacks_->onRegisterWriterStruct(writer_), 0);
212    EXPECT_NE(streamPlugin, nullptr);
213
214    EXPECT_EQ(streamPlugin->resultWriter_, nullptr);
215}
216
217// 流式调用写接口
218HWTEST_F(PluginModuleApiTest, StreamPluginRegister2, TestSize.Level1)
219{
220    PluginModuleCallbacks callbacks = {
221        StreamPluginSessionStart,
222        0,
223        StreamPluginSessionStop,
224        (RegisterWriterStructCallback)StreamRegisterWriterStruct,
225    };
226    streamCallbacks_ = &callbacks;
227
228    EXPECT_NE(streamCallbacks_->onRegisterWriterStruct, nullptr);
229    WriterStruct writer = {
230        Write,
231        Flush,
232    };
233    writer_ = &writer;
234    EXPECT_EQ(streamCallbacks_->onRegisterWriterStruct(writer_), 0);
235    EXPECT_NE(streamPlugin, nullptr);
236
237    EXPECT_NE(streamPlugin->resultWriter_, nullptr);
238    EXPECT_NE(streamPlugin->resultWriter_->write, nullptr);
239}
240
241// 流式调用写接口
242HWTEST_F(PluginModuleApiTest, StreamPluginRegister3, TestSize.Level1)
243{
244    PluginModuleCallbacks callbacks = {
245        StreamPluginSessionStart,
246        0,
247        StreamPluginSessionStop,
248        (RegisterWriterStructCallback)StreamRegisterWriterStruct,
249    };
250    streamCallbacks_ = &callbacks;
251
252    EXPECT_NE(streamCallbacks_->onRegisterWriterStruct, nullptr);
253    WriterStruct writer = {
254        Write,
255        Flush,
256    };
257    writer_ = &writer;
258    EXPECT_EQ(streamCallbacks_->onRegisterWriterStruct(writer_), 0);
259    EXPECT_NE(streamPlugin, nullptr);
260
261    EXPECT_NE(streamPlugin->resultWriter_, nullptr);
262    EXPECT_NE(streamPlugin->resultWriter_->write, nullptr);
263    EXPECT_NE(streamPlugin->resultWriter_->flush, nullptr);
264}
265
266// 轮询式调用写接口
267HWTEST_F(PluginModuleApiTest, SamplePluginRegister, TestSize.Level1)
268{
269    PluginModuleCallbacks callbacks = {
270        SamplePluginSessionStart,
271        SamplePluginReportResult,
272        SamplePluginSessionStop,
273        0,
274    };
275    sampleCallbacks_ = &callbacks;
276
277    EXPECT_EQ(sampleCallbacks_->onRegisterWriterStruct, nullptr);
278    EXPECT_EQ(samplePlugin, nullptr);
279}
280
281HWTEST_F(PluginModuleApiTest, MemPluginRegister, TestSize.Level1)
282{
283    PluginModuleCallbacks callbacks = {
284        MemDataPluginSessionStart,
285        MemPluginReportResult,
286        MemPluginSessionStop,
287        0,
288    };
289    memoryCallbacks_ = &callbacks;
290
291    EXPECT_EQ(memoryCallbacks_->onRegisterWriterStruct, nullptr);
292    EXPECT_EQ(memoryPlugin, nullptr);
293}
294
295// 流式插件正常启动
296HWTEST_F(PluginModuleApiTest, StreamPluginStartSucc, TestSize.Level1)
297{
298    PluginModuleCallbacks callbacks = {
299        StreamPluginSessionStart,
300        0,
301        StreamPluginSessionStop,
302        (RegisterWriterStructCallback)StreamRegisterWriterStruct,
303    };
304    streamCallbacks_ = &callbacks;
305
306    EXPECT_NE(streamCallbacks_->onRegisterWriterStruct, nullptr);
307    WriterStruct writer = {
308        Write,
309        Flush,
310    };
311    writer_ = &writer;
312    streamCallbacks_->onRegisterWriterStruct(writer_);
313    EXPECT_NE(streamPlugin, nullptr);
314
315    EXPECT_NE(streamCallbacks_->onPluginSessionStart, nullptr);
316    uint32_t configLen = MAX_BUFFER_SIZE;
317    std::vector<uint8_t> configData(configLen);
318    SetStreamConfig(configData, configLen);
319    EXPECT_EQ(streamCallbacks_->onPluginSessionStart(configData.data(), configLen), 0);
320
321    streamCallbacks_->onPluginSessionStop();
322}
323
324// 流式异常启动
325HWTEST_F(PluginModuleApiTest, StreamPluginStartFail, TestSize.Level1)
326{
327    PluginModuleCallbacks callbacks = {
328        StreamPluginSessionStart,
329        0,
330        StreamPluginSessionStop,
331        (RegisterWriterStructCallback)StreamRegisterWriterStruct,
332    };
333    streamCallbacks_ = &callbacks;
334
335    EXPECT_NE(streamCallbacks_->onRegisterWriterStruct, nullptr);
336    WriterStruct writer;
337    writer_ = &writer;
338    streamCallbacks_->onRegisterWriterStruct(writer_);
339    EXPECT_NE(streamPlugin, nullptr);
340
341    EXPECT_NE(streamCallbacks_->onPluginSessionStart, nullptr);
342    std::vector<uint8_t> configData(MAX_BUFFER_SIZE);
343    EXPECT_EQ(streamCallbacks_->onPluginSessionStart(configData.data(), configData.size()), -1);
344}
345
346// 轮询式异常启动
347HWTEST_F(PluginModuleApiTest, SamplePluginStartFail, TestSize.Level1)
348{
349    PluginModuleCallbacks callbacks = {
350        SamplePluginSessionStart,
351        SamplePluginReportResult,
352        SamplePluginSessionStop,
353        0,
354    };
355    sampleCallbacks_ = &callbacks;
356
357    EXPECT_NE(sampleCallbacks_->onPluginSessionStart, nullptr);
358    EXPECT_EQ(sampleCallbacks_->onPluginSessionStart(nullptr, 0), -1);
359    EXPECT_NE(samplePlugin, nullptr);
360}
361
362// 轮询式插件正常启动
363HWTEST_F(PluginModuleApiTest, SamplePluginStartSucc, TestSize.Level1)
364{
365    PluginModuleCallbacks callbacks = {
366        SamplePluginSessionStart,
367        SamplePluginReportResult,
368        SamplePluginSessionStop,
369        0,
370    };
371    sampleCallbacks_ = &callbacks;
372
373    EXPECT_NE(sampleCallbacks_->onPluginSessionStart, nullptr);
374    uint32_t configLen = MAX_BUFFER_SIZE;
375    std::vector<uint8_t> configData(configLen); // config
376    SetSampleConfig(configData, configLen);
377    EXPECT_EQ(sampleCallbacks_->onPluginSessionStart(configData.data(), configLen), 0);
378    EXPECT_NE(samplePlugin, nullptr);
379
380    sampleCallbacks_->onPluginSessionStop();
381}
382
383// 多个插件启动
384HWTEST_F(PluginModuleApiTest, MultPluginStart, TestSize.Level1)
385{
386    PluginModuleCallbacks callbacks = {
387        SamplePluginSessionStart,
388        SamplePluginReportResult,
389        SamplePluginSessionStop,
390        0,
391    };
392    PluginModuleCallbacks memCallbacks = {
393        MemDataPluginSessionStart,
394        MemPluginReportResult,
395        MemPluginSessionStop,
396        0,
397    };
398    sampleCallbacks_ = &callbacks;
399    memoryCallbacks_ = &memCallbacks;
400    uint32_t configLen = MAX_BUFFER_SIZE;
401
402    EXPECT_NE(sampleCallbacks_->onPluginSessionStart, nullptr);
403    std::vector<uint8_t> sampleConfigData(configLen);
404    SetSampleConfig(sampleConfigData, configLen);
405    EXPECT_EQ(sampleCallbacks_->onPluginSessionStart(sampleConfigData.data(), configLen), 0);
406    EXPECT_NE(samplePlugin, nullptr);
407    sampleCallbacks_->onPluginSessionStop();
408
409    EXPECT_NE(memoryCallbacks_->onPluginSessionStart, nullptr);
410    configLen = MAX_BUFFER_SIZE;
411    std::vector<uint8_t> memoryConfigData(configLen);
412    SetMemoryConfig(memoryConfigData, configLen);
413    EXPECT_EQ(memoryCallbacks_->onPluginSessionStart(memoryConfigData.data(), configLen), 0);
414    EXPECT_NE(memoryPlugin, nullptr);
415    memoryCallbacks_->onPluginSessionStop();
416}
417
418// 流式上报
419HWTEST_F(PluginModuleApiTest, StreamPluginReport, TestSize.Level1)
420{
421    PluginModuleCallbacks callbacks = {
422        StreamPluginSessionStart,
423        0,
424        StreamPluginSessionStop,
425        (RegisterWriterStructCallback)StreamRegisterWriterStruct,
426    };
427    streamCallbacks_ = &callbacks;
428
429    EXPECT_EQ(streamCallbacks_->onPluginReportResult, nullptr);
430}
431
432// 轮询式上报
433HWTEST_F(PluginModuleApiTest, SamplePluginReport, TestSize.Level1)
434{
435    PluginModuleCallbacks callbacks = {
436        SamplePluginSessionStart,
437        SamplePluginReportResult,
438        SamplePluginSessionStop,
439        0,
440    };
441    sampleCallbacks_ = &callbacks;
442
443    EXPECT_NE(sampleCallbacks_->onPluginSessionStart, nullptr);
444    uint32_t configLen = MAX_BUFFER_SIZE;
445    std::vector<uint8_t> configData(configLen);
446    SetSampleConfig(configData, configLen);
447    EXPECT_EQ(sampleCallbacks_->onPluginSessionStart(configData.data(), configLen), 0);
448    EXPECT_NE(samplePlugin, nullptr);
449
450    EXPECT_NE(sampleCallbacks_->onPluginReportResult, nullptr);
451    std::vector<uint8_t> buffer(MAX_BUFFER_SIZE);
452    EXPECT_NE(sampleCallbacks_->onPluginReportResult(buffer.data(), buffer.size()), 0);
453    sampleCallbacks_->onPluginSessionStop();
454}
455
456HWTEST_F(PluginModuleApiTest, MemoryPluginReport, TestSize.Level1)
457{
458    PluginModuleCallbacks callbacks = {
459        MemDataPluginSessionStart,
460        MemPluginReportResult,
461        MemPluginSessionStop,
462        0,
463    };
464    memoryCallbacks_ = &callbacks;
465
466    EXPECT_NE(memoryCallbacks_->onPluginSessionStart, nullptr);
467    uint32_t configLen = MAX_BUFFER_SIZE;
468    std::vector<uint8_t> configData(configLen);
469    SetMemoryConfig(configData, configLen);
470    EXPECT_EQ(memoryCallbacks_->onPluginSessionStart(configData.data(), configLen), 0);
471    EXPECT_NE(memoryPlugin, nullptr);
472
473    EXPECT_NE(memoryCallbacks_->onPluginReportResult, nullptr);
474    std::vector<uint8_t> buffer(MAX_BUFFER_SIZE);
475    EXPECT_NE(memoryCallbacks_->onPluginReportResult(buffer.data(), buffer.size()), 0);
476    memoryCallbacks_->onPluginSessionStop();
477}
478
479// 多个插件上报
480HWTEST_F(PluginModuleApiTest, MultPluginReport1, TestSize.Level1)
481{
482    PluginModuleCallbacks callbacks = {
483        SamplePluginSessionStart,
484        SamplePluginReportResult,
485        SamplePluginSessionStop,
486        0,
487    };
488    sampleCallbacks_ = &callbacks;
489    uint32_t configLen = MAX_BUFFER_SIZE;
490
491    EXPECT_NE(sampleCallbacks_->onPluginSessionStart, nullptr);
492    std::vector<uint8_t> sampleConfigData(configLen);
493    SetSampleConfig(sampleConfigData, configLen);
494    EXPECT_EQ(sampleCallbacks_->onPluginSessionStart(sampleConfigData.data(), configLen), 0);
495    EXPECT_NE(samplePlugin, nullptr);
496    EXPECT_NE(sampleCallbacks_->onPluginReportResult, nullptr);
497    std::vector<uint8_t> sampleBuffer(MAX_BUFFER_SIZE);
498    EXPECT_NE(sampleCallbacks_->onPluginReportResult(sampleBuffer.data(), sampleBuffer.size()), 0);
499
500    PluginModuleCallbacks memCallbacks = {
501        MemDataPluginSessionStart,
502        MemPluginReportResult,
503        MemPluginSessionStop,
504        0,
505    };
506    memoryCallbacks_ = &memCallbacks;
507
508    configLen = MAX_BUFFER_SIZE;
509    EXPECT_NE(memoryCallbacks_->onPluginSessionStart, nullptr);
510    std::vector<uint8_t> memoryConfigData(configLen);
511    SetMemoryConfig(memoryConfigData, configLen);
512    EXPECT_EQ(memoryCallbacks_->onPluginSessionStart(memoryConfigData.data(), configLen), 0);
513    EXPECT_NE(memoryPlugin, nullptr);
514    EXPECT_NE(memoryCallbacks_->onPluginReportResult, nullptr);
515    std::vector<uint8_t> memoryBuffer(MAX_BUFFER_SIZE);
516    EXPECT_NE(memoryCallbacks_->onPluginReportResult(memoryBuffer.data(), memoryBuffer.size()), 0);
517
518    sampleCallbacks_->onPluginSessionStop();
519    memoryCallbacks_->onPluginSessionStop();
520}
521
522HWTEST_F(PluginModuleApiTest, MultPluginReport2, TestSize.Level1)
523{
524    PluginModuleCallbacks callbacks = {
525        SamplePluginSessionStart,
526        SamplePluginReportResult,
527        SamplePluginSessionStop,
528        0,
529    };
530    sampleCallbacks_ = &callbacks;
531    uint32_t configLen = MAX_BUFFER_SIZE;
532
533    EXPECT_NE(sampleCallbacks_->onPluginSessionStart, nullptr);
534    std::vector<uint8_t> sampleConfigData(configLen);
535    SetSampleConfig(sampleConfigData, configLen);
536    EXPECT_EQ(sampleCallbacks_->onPluginSessionStart(sampleConfigData.data(), configLen), 0);
537    EXPECT_NE(samplePlugin, nullptr);
538    EXPECT_NE(sampleCallbacks_->onPluginReportResult, nullptr);
539    std::vector<uint8_t> sampleBuffer(MAX_BUFFER_SIZE);
540    EXPECT_NE(sampleCallbacks_->onPluginReportResult(sampleBuffer.data(), sampleBuffer.size()), 0);
541
542    PluginModuleCallbacks streamCallbacks = {
543        StreamPluginSessionStart,
544        0,
545        StreamPluginSessionStop,
546        (RegisterWriterStructCallback)StreamRegisterWriterStruct,
547    };
548    streamCallbacks_ = &streamCallbacks;
549
550    EXPECT_NE(streamCallbacks_->onRegisterWriterStruct, nullptr);
551    WriterStruct writer = {
552        Write,
553        Flush,
554    };
555    writer_ = &writer;
556    streamCallbacks_->onRegisterWriterStruct(writer_);
557    EXPECT_NE(streamPlugin, nullptr);
558    EXPECT_NE(streamPlugin->resultWriter_, nullptr);
559    EXPECT_NE(streamPlugin->resultWriter_->write, nullptr);
560    EXPECT_NE(streamPlugin->resultWriter_->flush, nullptr);
561
562    EXPECT_NE(streamCallbacks_->onPluginSessionStart, nullptr);
563    configLen = MAX_BUFFER_SIZE;
564    std::vector<uint8_t> configData(configLen);
565    SetStreamConfig(configData, configLen);
566    EXPECT_EQ(streamCallbacks_->onPluginSessionStart(configData.data(), configLen), 0);
567
568    sampleCallbacks_->onPluginSessionStop();
569    streamCallbacks_->onPluginSessionStop();
570}
571
572// 流式插件停止
573HWTEST_F(PluginModuleApiTest, StreamPluginStop, TestSize.Level1)
574{
575    PluginModuleCallbacks callbacks = {
576        StreamPluginSessionStart,
577        0,
578        StreamPluginSessionStop,
579        (RegisterWriterStructCallback)StreamRegisterWriterStruct,
580    };
581    streamCallbacks_ = &callbacks;
582
583    EXPECT_NE(streamCallbacks_->onRegisterWriterStruct, nullptr);
584    streamCallbacks_->onRegisterWriterStruct(writer_);
585    EXPECT_NE(streamPlugin, nullptr);
586
587    EXPECT_NE(streamCallbacks_->onPluginSessionStart, nullptr);
588    std::vector<uint8_t> configData(1);
589    streamCallbacks_->onPluginSessionStart(configData.data(), configData.size());
590
591    EXPECT_NE(streamCallbacks_->onPluginSessionStop, nullptr);
592    EXPECT_EQ(streamCallbacks_->onPluginSessionStop(), 0);
593}
594
595// 轮询式插件停止
596HWTEST_F(PluginModuleApiTest, SamplePluginStop, TestSize.Level1)
597{
598    PluginModuleCallbacks callbacks = {
599        SamplePluginSessionStart,
600        SamplePluginReportResult,
601        SamplePluginSessionStop,
602        0,
603    };
604    sampleCallbacks_ = &callbacks;
605
606    EXPECT_NE(sampleCallbacks_->onPluginSessionStart, nullptr);
607    uint32_t configLen = MAX_BUFFER_SIZE;
608    std::vector<uint8_t> configData(configLen);
609    SetSampleConfig(configData, configLen);
610    EXPECT_EQ(sampleCallbacks_->onPluginSessionStart(configData.data(), configLen), 0);
611    EXPECT_NE(samplePlugin, nullptr);
612
613    EXPECT_NE(sampleCallbacks_->onPluginSessionStop, nullptr);
614    EXPECT_EQ(sampleCallbacks_->onPluginSessionStop(), 0);
615}
616
617HWTEST_F(PluginModuleApiTest, MemoryPluginStop, TestSize.Level1)
618{
619    PluginModuleCallbacks callbacks = {
620        MemDataPluginSessionStart,
621        MemPluginReportResult,
622        MemPluginSessionStop,
623        0,
624    };
625    memoryCallbacks_ = &callbacks;
626
627    EXPECT_NE(memoryCallbacks_->onPluginSessionStart, nullptr);
628    uint32_t configLen = MAX_BUFFER_SIZE;
629    std::vector<uint8_t> memoryConfigData(configLen);
630    SetMemoryConfig(memoryConfigData, configLen);
631    EXPECT_EQ(memoryCallbacks_->onPluginSessionStart(memoryConfigData.data(), configLen), 0);
632    EXPECT_NE(memoryPlugin, nullptr);
633
634    EXPECT_NE(memoryCallbacks_->onPluginSessionStop, nullptr);
635    EXPECT_EQ(memoryCallbacks_->onPluginSessionStop(), 0);
636}
637
638// 多个插件停止
639HWTEST_F(PluginModuleApiTest, MultPluginStop, TestSize.Level1)
640{
641    PluginModuleCallbacks callbacks = {
642        SamplePluginSessionStart,
643        SamplePluginReportResult,
644        SamplePluginSessionStop,
645        0,
646    };
647    PluginModuleCallbacks memCallbacks = {
648        MemDataPluginSessionStart,
649        MemPluginReportResult,
650        MemPluginSessionStop,
651        0,
652    };
653    sampleCallbacks_ = &callbacks;
654    memoryCallbacks_ = &memCallbacks;
655    uint32_t configLen = MAX_BUFFER_SIZE;
656
657    EXPECT_NE(sampleCallbacks_->onPluginSessionStart, nullptr);
658    std::vector<uint8_t> sampleConfigData(configLen);
659    SetSampleConfig(sampleConfigData, configLen);
660    EXPECT_EQ(sampleCallbacks_->onPluginSessionStart(sampleConfigData.data(), configLen), 0);
661    EXPECT_NE(samplePlugin, nullptr);
662
663    EXPECT_NE(memoryCallbacks_->onPluginSessionStart, nullptr);
664    configLen = MAX_BUFFER_SIZE;
665    std::vector<uint8_t> memoryConfigData(configLen);
666    SetMemoryConfig(memoryConfigData, configLen);
667    EXPECT_EQ(memoryCallbacks_->onPluginSessionStart(memoryConfigData.data(), configLen), 0);
668    EXPECT_NE(memoryPlugin, nullptr);
669
670    EXPECT_EQ(sampleCallbacks_->onPluginSessionStop(), 0);
671    EXPECT_EQ(memoryCallbacks_->onPluginSessionStop(), 0);
672}
673
674// 异常停止
675HWTEST_F(PluginModuleApiTest, PluginAbnormalStop, TestSize.Level1)
676{
677    PluginModuleCallbacks callbacks = {
678        MemDataPluginSessionStart,
679        MemPluginReportResult,
680        MemPluginSessionStop,
681        0,
682    };
683    memoryCallbacks_ = &callbacks;
684
685    EXPECT_NE(memoryCallbacks_->onPluginSessionStop, nullptr);
686    EXPECT_EQ(memoryCallbacks_->onPluginSessionStop(), -1);
687}
688} // namespace