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 "surface_encoder_adapter_unittest.h"
17 #include "mock/mock_avbuffer_queue_producer.h"
18 #include "mock/mock_encoder_adapter_key_frame_pts_callback.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22 using namespace OHOS::Media;
23
24 const static int32_t TIMES_TWO = 2;
25 const static int32_t TEST_ERR_CODE = -1;
26 const static int32_t TEST_SUCCESS_CODE = 0;
27 const static int64_t TEST_PAUSE_TIME = -2;
28 const static int64_t TEST_PAUSE_TIME_DEFAULT = -1;
29 const static int64_t TEST_CURRENT_PTS = 1;
30 const static uint32_t TEST_INDEX = 1;
31
SetUpTestCase(void)32 void SurfaceEncoderAdapterUnitTest::SetUpTestCase(void) {}
33
TearDownTestCase(void)34 void SurfaceEncoderAdapterUnitTest::TearDownTestCase(void) {}
35
SetUp(void)36 void SurfaceEncoderAdapterUnitTest::SetUp(void)
37 {
38 mockCodecServer_ = std::make_shared<MockAVCodecVideoEncoder>();
39 surfaceEncoderAdapter_ = std::make_shared<SurfaceEncoderAdapter>();
40 }
41
TearDown(void)42 void SurfaceEncoderAdapterUnitTest::TearDown(void)
43 {
44 mockCodecServer_ = nullptr;
45 surfaceEncoderAdapter_ = nullptr;
46 }
47
48 /**
49 * @tc.name : Test SetInputSurface
50 * @tc.number: SetInputSurface_001
51 * @tc.desc : Test SetInputSurface codecServer_ != nullptr
52 * Test SetInputSurface codecServerPtr->SetInputSurface == 0
53 */
54 HWTEST_F(SurfaceEncoderAdapterUnitTest, SetInputSurface_001, TestSize.Level1)
55 {
56 surfaceEncoderAdapter_->codecServer_ = mockCodecServer_;
57 EXPECT_CALL(*(mockCodecServer_), Release()).WillRepeatedly(Return(TEST_SUCCESS_CODE));
58 Status status = surfaceEncoderAdapter_->SetInputSurface(nullptr);
59 EXPECT_EQ(status, Status::ERROR_UNKNOWN);
60 }
61
62 /**
63 * @tc.name : Test Pause
64 * @tc.number: Pause_001
65 * @tc.desc : Test Pause !pauseResumeQueue_.empty()
66 */
67 HWTEST_F(SurfaceEncoderAdapterUnitTest, Pause_001, TestSize.Level1)
68 {
69 surfaceEncoderAdapter_->isTransCoderMode = false;
70 surfaceEncoderAdapter_->pauseResumeQueue_.push_back({TEST_PAUSE_TIME, StateCode::PAUSE});
71 surfaceEncoderAdapter_->Pause();
72 EXPECT_EQ(surfaceEncoderAdapter_->pauseResumeQueue_.back().second, StateCode::PAUSE);
73 }
74
75 /**
76 * @tc.name : Test Pause
77 * @tc.number: Pause_002
78 * @tc.desc : Test Pause pauseResumeQueue_.back().second == StateCode::RESUME
79 * && pauseResumeQueue_.back().first <= pauseTime_
80 */
81 HWTEST_F(SurfaceEncoderAdapterUnitTest, Pause_002, TestSize.Level1)
82 {
83 surfaceEncoderAdapter_->isTransCoderMode = false;
84 surfaceEncoderAdapter_->pauseResumeQueue_.push_back({TEST_PAUSE_TIME, StateCode::RESUME});
85 surfaceEncoderAdapter_->Pause();
86 EXPECT_EQ(surfaceEncoderAdapter_->pauseResumeQueue_.back().second, StateCode::RESUME);
87 }
88
89 /**
90 * @tc.name : Test Resume
91 * @tc.number: Resume_001
92 * @tc.desc : Test Resume pauseResumeQueue_.back().second != StateCode::RESUME
93 */
94 HWTEST_F(SurfaceEncoderAdapterUnitTest, Resume_001, TestSize.Level1)
95 {
96 surfaceEncoderAdapter_->isTransCoderMode = false;
97 surfaceEncoderAdapter_->pauseResumeQueue_.push_back({TEST_PAUSE_TIME, StateCode::PAUSE});
98 surfaceEncoderAdapter_->Resume();
99 EXPECT_EQ(surfaceEncoderAdapter_->pauseResumeQueue_.back().first, TEST_PAUSE_TIME);
100 }
101
102 /**
103 * @tc.name : Test Resume
104 * @tc.number: Resume_002
105 * @tc.desc : Test Resume pauseTime_ == -1
106 */
107 HWTEST_F(SurfaceEncoderAdapterUnitTest, Resume_002, TestSize.Level1)
108 {
109 surfaceEncoderAdapter_->isTransCoderMode = false;
110 surfaceEncoderAdapter_->pauseTime_ = TEST_PAUSE_TIME_DEFAULT;
111 surfaceEncoderAdapter_->pauseResumeQueue_.push_back({TEST_PAUSE_TIME, StateCode::PAUSE});
112 surfaceEncoderAdapter_->Resume();
113 EXPECT_EQ(surfaceEncoderAdapter_->totalPauseTimeQueue_.size(), 1);
114 }
115
116 /**
117 * @tc.name : Test Flush
118 * @tc.number: Flush_001
119 * @tc.desc : Test Flush codecServer_->Flush() != 0
120 */
121 HWTEST_F(SurfaceEncoderAdapterUnitTest, Flush_001, TestSize.Level1)
122 {
123 surfaceEncoderAdapter_->codecServer_ = mockCodecServer_;
124 EXPECT_CALL(*(mockCodecServer_), Flush()).WillRepeatedly(Return(TEST_ERR_CODE));
125 EXPECT_CALL(*(mockCodecServer_), Release()).WillRepeatedly(Return(TEST_SUCCESS_CODE));
126 Status status = surfaceEncoderAdapter_->Flush();
127 EXPECT_EQ(status, Status::ERROR_UNKNOWN);
128 }
129
130 /**
131 * @tc.name : Test Reset
132 * @tc.number: Reset_001
133 * @tc.desc : Test Reset codecServer_->Reset() != 0
134 */
135 HWTEST_F(SurfaceEncoderAdapterUnitTest, Reset_001, TestSize.Level1)
136 {
137 surfaceEncoderAdapter_->codecServer_ = mockCodecServer_;
138 EXPECT_CALL(*(mockCodecServer_), Reset()).WillRepeatedly(Return(TEST_ERR_CODE));
139 EXPECT_CALL(*(mockCodecServer_), Release()).WillRepeatedly(Return(TEST_SUCCESS_CODE));
140 Status status = surfaceEncoderAdapter_->Reset();
141 EXPECT_EQ(status, Status::ERROR_UNKNOWN);
142 }
143
144 /**
145 * @tc.name : Test Release
146 * @tc.number: Release_001
147 * @tc.desc : Test Release codecServer_->Release() != 0
148 */
149 HWTEST_F(SurfaceEncoderAdapterUnitTest, Release_001, TestSize.Level1)
150 {
151 surfaceEncoderAdapter_->codecServer_ = mockCodecServer_;
152 EXPECT_CALL(*(mockCodecServer_), Release()).WillRepeatedly(Return(TEST_ERR_CODE));
153 Status status = surfaceEncoderAdapter_->Release();
154 EXPECT_EQ(status, Status::ERROR_UNKNOWN);
155 }
156
157 /**
158 * @tc.name : Test NotifyEos
159 * @tc.number: NotifyEos_001
160 * @tc.desc : Test NotifyEos codecServer_->NotifyEos() != 0
161 */
162 HWTEST_F(SurfaceEncoderAdapterUnitTest, NotifyEos_001, TestSize.Level1)
163 {
164 surfaceEncoderAdapter_->codecServer_ = mockCodecServer_;
165 EXPECT_CALL(*(mockCodecServer_), NotifyEos()).WillRepeatedly(Return(TEST_ERR_CODE));
166 EXPECT_CALL(*(mockCodecServer_), Release()).WillRepeatedly(Return(TEST_SUCCESS_CODE));
167 surfaceEncoderAdapter_->isTransCoderMode = false;
168 surfaceEncoderAdapter_->currentPts_ = UINT32_MAX;
169 Status status = surfaceEncoderAdapter_->NotifyEos(UINT32_MAX);
170 EXPECT_EQ(status, Status::ERROR_UNKNOWN);
171 }
172
173 /**
174 * @tc.name : Test SetParameter
175 * @tc.number: SetParameter_001
176 * @tc.desc : Test SetParameter codecServer_->SetParameter() != 0
177 */
178 HWTEST_F(SurfaceEncoderAdapterUnitTest, SetParameter_001, TestSize.Level1)
179 {
180 surfaceEncoderAdapter_->codecServer_ = mockCodecServer_;
181 EXPECT_CALL(*(mockCodecServer_), SetParameter(_)).WillRepeatedly(Return(TEST_ERR_CODE));
182 EXPECT_CALL(*(mockCodecServer_), Release()).WillRepeatedly(Return(TEST_SUCCESS_CODE));
183 Status status = surfaceEncoderAdapter_->SetParameter(nullptr);
184 EXPECT_EQ(status, Status::ERROR_UNKNOWN);
185 }
186
187 /**
188 * @tc.name : Test TransCoderOnOutputBufferAvailable
189 * @tc.number: TransCoderOnOutputBufferAvailable_001
190 * @tc.desc : Test TransCoderOnOutputBufferAvailable outputBufferQueueProducer_->RequestBuffer != Status::OK
191 */
192 HWTEST_F(SurfaceEncoderAdapterUnitTest, TransCoderOnOutputBufferAvailable_001, TestSize.Level1)
193 {
194 AVBufferConfig config;
195 config.memoryType = MemoryType::VIRTUAL_MEMORY;
196 auto avbuffer = AVBuffer::CreateAVBuffer(config);
197 auto mockProducer = std::make_shared<MockAVBufferQueueProducer>();
198 EXPECT_CALL(*(mockProducer), RequestBuffer(_, _, _)).WillRepeatedly(Return(Status::ERROR_UNKNOWN));
199 surfaceEncoderAdapter_->outputBufferQueueProducer_ = OHOS::sptr<AVBufferQueueProducer>(mockProducer.get());
200 surfaceEncoderAdapter_->TransCoderOnOutputBufferAvailable(TEST_INDEX, avbuffer);
201 EXPECT_TRUE(surfaceEncoderAdapter_->indexs_.empty());
202 }
203
204 /**
205 * @tc.name : Test OnOutputBufferAvailable
206 * @tc.number: OnOutputBufferAvailable_001
207 * @tc.desc : Test OnOutputBufferAvailable (stopTime_ != -1 && buffer->pts_ >
208 * stopTime_ - (SEC_TO_NS / videoFrameRate_)) == true
209 */
210 HWTEST_F(SurfaceEncoderAdapterUnitTest, OnOutputBufferAvailable_001, TestSize.Level1)
211 {
212 auto avbuffer = AVBuffer::CreateAVBuffer();
213 avbuffer->pts_ = UINT32_MAX;
214 surfaceEncoderAdapter_->stopTime_ = 1;
215 surfaceEncoderAdapter_->isTransCoderMode = false;
216 surfaceEncoderAdapter_->OnOutputBufferAvailable(TEST_INDEX, avbuffer);
217 EXPECT_TRUE(surfaceEncoderAdapter_->indexs_.empty());
218 }
219
220 /**
221 * @tc.name : Test CheckFrames
222 * @tc.number: CheckFrames_001
223 * @tc.desc : Test CheckFrames totalPauseTimeQueue_.empty() == true
224 */
225 HWTEST_F(SurfaceEncoderAdapterUnitTest, CheckFrames_001, TestSize.Level1)
226 {
227 surfaceEncoderAdapter_->pauseResumeQueue_.push_back({TEST_PAUSE_TIME, StateCode::RESUME});
228 surfaceEncoderAdapter_->totalPauseTimeQueue_.clear();
229 int64_t pauseTime = static_cast<int64_t>(TEST_PAUSE_TIME_DEFAULT);
230 bool ret = surfaceEncoderAdapter_->CheckFrames(TEST_PAUSE_TIME_DEFAULT, pauseTime);
231 EXPECT_TRUE(!ret);
232 }
233
234 /**
235 * @tc.name : Test AddStartPts
236 * @tc.number: AddStartPts_001
237 * @tc.desc : Test AddStartPts encoderAdapterKeyFramePtsCallback_ != nullptr
238 * Test AddStopPts encoderAdapterKeyFramePtsCallback_ == nullptr
239 * Test AddPauseResumePts encoderAdapterKeyFramePtsCallback_ != nullptr
240 */
241 HWTEST_F(SurfaceEncoderAdapterUnitTest, AddStartPts_001, TestSize.Level1)
242 {
243 // Test AddStartPts encoderAdapterKeyFramePtsCallback_ != nullptr
244 surfaceEncoderAdapter_->isStartKeyFramePts_ = true;
245 auto callback = std::make_shared<MockEncoderAdapterKeyFramePtsCallback>();
246 EXPECT_CALL(*(callback.get()), OnReportFirstFramePts(_)).Times(TIMES_TWO);
247 surfaceEncoderAdapter_->encoderAdapterKeyFramePtsCallback_ = callback;
248 surfaceEncoderAdapter_->AddStartPts(TEST_CURRENT_PTS);
249
250 // Test AddStopPts encoderAdapterKeyFramePtsCallback_ == nullptr
251 surfaceEncoderAdapter_->isStopKeyFramePts_ = true;
252 surfaceEncoderAdapter_->encoderAdapterKeyFramePtsCallback_ = nullptr;
253 surfaceEncoderAdapter_->AddStopPts();
254
255 // Test AddPauseResumePts encoderAdapterKeyFramePtsCallback_ != nullptr
256 surfaceEncoderAdapter_->pauseResumePts_.push_back({TEST_PAUSE_TIME, StateCode::RESUME});
257 surfaceEncoderAdapter_->encoderAdapterKeyFramePtsCallback_ = callback;
258 bool ret = surfaceEncoderAdapter_->AddPauseResumePts(TEST_PAUSE_TIME_DEFAULT);
259 EXPECT_TRUE(!ret);
260 }