1 /*
2 * Copyright (C) 2025 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 "gmock/gmock.h"
17
18 #include "sei_parser_helper_unittest.h"
19
20
21 namespace OHOS {
22 namespace Media {
23 namespace Pipeline {
24 using namespace OHOS;
25 using namespace OHOS::Media;
26 using namespace std;
27 using namespace testing;
28 using namespace testing::ext;
29 // const static int32_t INVALID_NUM = -1;
30 const static int32_t NUM_TEST = 0;
31 // const static int32_t ID_TEST = 0;
32 const static int32_t TIME_TEST = 10;
33 const static std::string NAME_TEST = "name/test";
34 class MockEventReceiver : public EventReceiver {
35 public:
36 MockEventReceiver() = default;
OnEvent(const Event & event)37 void OnEvent(const Event &event){};
38 };
39
SetUpTestCase(void)40 void AvcSeiParserHelperUnittest::SetUpTestCase(void) {}
41
TearDownTestCase(void)42 void AvcSeiParserHelperUnittest::TearDownTestCase(void) {}
43
SetUp(void)44 void AvcSeiParserHelperUnittest::SetUp(void)
45 {
46 avcSeiParserHelper_ = std::make_shared<AvcSeiParserHelper>();
47 }
48
TearDown(void)49 void AvcSeiParserHelperUnittest::TearDown(void)
50 {
51 ASSERT_NE(avcSeiParserHelper_, nullptr);
52 avcSeiParserHelper_ = nullptr;
53 }
54
55 /**
56 * @tc.name: Test ParseSeiRbsp API
57 * @tc.number: ParseSeiRbsp_001
58 * @tc.desc: Test bodyPtr + SEI_UUID_LEN >= maxPtr
59 */
60 HWTEST_F(AvcSeiParserHelperUnittest, ParseSeiRbsp_001, TestSize.Level0)
61 {
62 ASSERT_NE(avcSeiParserHelper_, nullptr);
63 uint8_t buffer[10];
64 uint8_t* bodyPtr = buffer + sizeof(buffer);
65 const uint8_t* const maxPtr = buffer;
66 std::shared_ptr<SeiPayloadInfoGroup> group = std::make_shared<SeiPayloadInfoGroup>();
67 auto ret = avcSeiParserHelper_->ParseSeiRbsp(bodyPtr, maxPtr, group);
68 EXPECT_EQ(ret, Status::ERROR_UNSUPPORTED_FORMAT);
69 }
70
71 /**
72 * @tc.name: Test SeiParserListener Constructor&FlowLimit API
73 * @tc.number: SeiParserListenerConstructor_001
74 * @tc.desc: Test Constructor all
75 * Test FlowLimit all
76 */
77 HWTEST_F(AvcSeiParserHelperUnittest, SeiParserListenerConstructor_001, TestSize.Level0)
78 {
79 ASSERT_NE(avcSeiParserHelper_, nullptr);
80 auto mockProducer = new MockAVBufferQueueProducer();
81 EXPECT_CALL(*(mockProducer), SetBufferFilledListener(_)).WillRepeatedly(Return(Status::OK));
82 sptr<AVBufferQueueProducer> producer = mockProducer;
83 std::shared_ptr<Pipeline::EventReceiver> eventReceiver = std::make_shared<MockEventReceiver>();
84 bool isFlowLimited = false;
85 auto seiParserListener = std::make_shared<SeiParserListener>(NAME_TEST, producer, eventReceiver, isFlowLimited);
86
87 seiParserListener->seiParserHelper_ = avcSeiParserHelper_;
88 std::shared_ptr<AVBuffer> avBuffer = std::make_shared<AVBuffer>();
89 auto mockSyncCenter = std::make_shared<MediaSyncManager>();
90 EXPECT_CALL(*(mockSyncCenter), GetMediaTimeNow()).WillRepeatedly(Return(NUM_TEST));
91 seiParserListener->syncCenter_ = mockSyncCenter;
92 seiParserListener->startPts_ = NUM_TEST;
93 avBuffer->pts_ = TIME_TEST;
94 seiParserListener->FlowLimit(avBuffer);
95 EXPECT_NE(seiParserListener->startPts_, avBuffer->pts_);
96 }
97
98 /**
99 * @tc.name: Test SetPayloadTypeVec API
100 * @tc.number: SeiParserListenerSetPayloadTypeVec_001
101 * @tc.desc: Test all
102 */
103 HWTEST_F(AvcSeiParserHelperUnittest, SeiParserListenerSetPayloadTypeVec_001, TestSize.Level0)
104 {
105 ASSERT_NE(avcSeiParserHelper_, nullptr);
106 auto mockProducer = new MockAVBufferQueueProducer();
107 EXPECT_CALL(*(mockProducer), SetBufferFilledListener(_)).WillRepeatedly(Return(Status::OK));
108 sptr<AVBufferQueueProducer> producer = mockProducer;
109 std::shared_ptr<Pipeline::EventReceiver> eventReceiver = std::make_shared<MockEventReceiver>();
110 bool isFlowLimited = false;
111 auto seiParserListener = std::make_shared<SeiParserListener>(NAME_TEST, producer, eventReceiver, isFlowLimited);
112 seiParserListener->seiParserHelper_ = avcSeiParserHelper_;
113 std::vector<int32_t> vector;
114 seiParserListener->SetPayloadTypeVec(vector);
115 EXPECT_EQ(avcSeiParserHelper_->payloadTypeVec_, vector);
116 }
117
118 /**
119 * @tc.name: Test OnInterrupted API
120 * @tc.number: SeiParserListenerOnInterrupted_001
121 * @tc.desc: Test all
122 */
123 HWTEST_F(AvcSeiParserHelperUnittest, SeiParserListenerOnInterrupted_001, TestSize.Level0)
124 {
125 ASSERT_NE(avcSeiParserHelper_, nullptr);
126 auto mockProducer = new MockAVBufferQueueProducer();
127 EXPECT_CALL(*(mockProducer), SetBufferFilledListener(_)).WillRepeatedly(Return(Status::OK));
128 sptr<AVBufferQueueProducer> producer = mockProducer;
129 std::shared_ptr<Pipeline::EventReceiver> eventReceiver = std::make_shared<MockEventReceiver>();
130 bool isFlowLimited = false;
131 auto seiParserListener = std::make_shared<SeiParserListener>(NAME_TEST, producer, eventReceiver, isFlowLimited);
132 seiParserListener->seiParserHelper_ = avcSeiParserHelper_;
133 bool isInterruptNeeded = true;
134 seiParserListener->OnInterrupted(isInterruptNeeded);
135 EXPECT_EQ(seiParserListener->isInterruptNeeded_, isInterruptNeeded);
136 }
137
138 /**
139 * @tc.name: Test SetSeiMessageCbStatus API
140 * @tc.number: SeiParserListenerSetSeiMessageCbStatus_001
141 * @tc.desc: Test status == true
142 * Test status == false && payloadTypes.empty() == true
143 * Test status == false && payloadTypes.empty() == false
144 */
145 HWTEST_F(AvcSeiParserHelperUnittest, SeiParserListenerSetSeiMessageCbStatus_001, TestSize.Level0)
146 {
147 ASSERT_NE(avcSeiParserHelper_, nullptr);
148 auto mockProducer = new MockAVBufferQueueProducer();
149 EXPECT_CALL(*(mockProducer), SetBufferFilledListener(_)).WillRepeatedly(Return(Status::OK));
150 sptr<AVBufferQueueProducer> producer = mockProducer;
151 std::shared_ptr<Pipeline::EventReceiver> eventReceiver = std::make_shared<MockEventReceiver>();
152 bool isFlowLimited = false;
153 auto seiParserListener = std::make_shared<SeiParserListener>(NAME_TEST, producer, eventReceiver, isFlowLimited);
154 seiParserListener->seiParserHelper_ = avcSeiParserHelper_;
155 bool status = true;
156 std::vector<int32_t> payloadTypes;
157 auto ret = seiParserListener->SetSeiMessageCbStatus(status, payloadTypes);
158 EXPECT_EQ(ret, Status::OK);
159 EXPECT_EQ(seiParserListener->payloadTypes_, payloadTypes);
160 EXPECT_EQ(avcSeiParserHelper_->payloadTypeVec_, payloadTypes);
161
162 status = false;
163 ret = seiParserListener->SetSeiMessageCbStatus(status, payloadTypes);
164 EXPECT_EQ(ret, Status::OK);
165 EXPECT_EQ(seiParserListener->payloadTypes_, payloadTypes);
166 EXPECT_EQ(avcSeiParserHelper_->payloadTypeVec_, payloadTypes);
167
168 payloadTypes.push_back(NUM_TEST);
169 payloadTypes.push_back(NUM_TEST);
170 ret = seiParserListener->SetSeiMessageCbStatus(status, payloadTypes);
171 EXPECT_EQ(ret, Status::OK);
172 EXPECT_NE(seiParserListener->payloadTypes_, payloadTypes);
173 EXPECT_EQ(seiParserListener->payloadTypes_.size(), 0);
174 EXPECT_EQ(avcSeiParserHelper_->payloadTypeVec_, seiParserListener->payloadTypes_);
175 }
176 } // namespace Pipeline
177 } // namespace Media
178 } // namespace OHOS
179