1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file expect 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 <chrono>
17 #include <memory>
18 #include <thread>
19 #include "avcodec_errors.h"
20 #include "codec_server_coverage_unit_test.h"
21 #include "codeclist_core.h"
22 #include "media_description.h"
23 #include "meta/meta_key.h"
24 #include "unittest_utils.h"
25
26 #define EXPECT_CALL_GET_HCODEC_CAPS_MOCK \
27 EXPECT_CALL(*codecBaseMock_, GetHCapabilityList).Times(AtLeast(1)).WillRepeatedly
28 #define EXPECT_CALL_GET_FCODEC_CAPS_MOCK \
29 EXPECT_CALL(*codecBaseMock_, GetFCapabilityList).Times(AtLeast(1)).WillRepeatedly
30 using namespace OHOS;
31 using namespace OHOS::MediaAVCodec;
32 using namespace OHOS::Media;
33 using namespace testing;
34 using namespace testing::ext;
35
36 namespace OHOS {
37 namespace MediaAVCodec {
CreateCodecByMime()38 void CodecServerUnitTest::CreateCodecByMime()
39 {
40 std::string codecName = "video.H.Encoder.Name.00";
41 std::string codecMime = CODEC_MIME_MOCK_00;
42
43 EXPECT_CALL(*codecBaseMock_, Init).Times(1).WillOnce(Return(AVCS_ERR_OK));
44 EXPECT_CALL_GET_HCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, HCODEC_CAPS)));
45 EXPECT_CALL_GET_FCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, {})));
46 EXPECT_CALL(*codecBaseMock_, CodecBaseCtor()).Times(1);
47 EXPECT_CALL(*codecBaseMock_, CreateHCodecByName(codecName))
48 .Times(1)
49 .WillOnce(Return(std::make_shared<CodecBase>()));
50 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<AVCodecCallback>(nullptr)))
51 .Times(1)
52 .WillOnce(Return(AVCS_ERR_OK));
53 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<MediaCodecCallback>(nullptr)))
54 .Times(1)
55 .WillOnce(Return(AVCS_ERR_OK));
56
57 int32_t ret = server_->Init(AVCODEC_TYPE_VIDEO_ENCODER, true, codecMime, *validFormat_.GetMeta(),
58 API_VERSION::API_VERSION_11);
59 EXPECT_EQ(ret, AVCS_ERR_OK);
60 }
61
62 /**
63 * @tc.name: PreparePostProcessing_Invalid_Test_001
64 * @tc.desc: postProcessing controller is nullptr
65 */
66 HWTEST_F(CodecServerUnitTest, PreparePostProcessing_Invalid_Test_001, TestSize.Level1)
67 {
68 CreateCodecByMime();
69 server_->postProcessing_ = std::make_unique<CodecServer::PostProcessingType>(server_->codecBase_);
70 int32_t ret = server_->PreparePostProcessing();
71 EXPECT_NE(ret, AVCS_ERR_OK);
72 }
73
74 /**
75 * @tc.name: PreparePostProcessing_Valid_Test_002
76 * @tc.desc: codec PreparePostProcessing
77 */
78 HWTEST_F(CodecServerUnitTest, PreparePostProcessing_Valid_Test_002, TestSize.Level1)
79 {
80 CreateCodecByMime();
81 server_->postProcessing_ = nullptr;
82 int32_t ret = server_->PreparePostProcessing();
83 EXPECT_EQ(ret, AVCS_ERR_OK);
84 }
85
86 /**
87 * @tc.name: PostProcessingOnError_Valid_Test_001
88 * @tc.desc: videoCb_ is not nullptr
89 */
90 HWTEST_F(CodecServerUnitTest, PostProcessingOnError_Valid_Test_001, TestSize.Level1)
91 {
92 CreateCodecByMime();
93 auto mock = std::make_shared<MediaCodecCallbackMock>();
94 server_->videoCb_ = mock;
95 int32_t errorCode = AVCS_ERR_OK;
96 server_->PostProcessingOnError(errorCode);
97 }
98
99 /**
100 * @tc.name: PostProcessingOnOutputBufferAvailable_Valid_Test_001
101 * @tc.desc: videoCb_ is not nullptr
102 */
103 HWTEST_F(CodecServerUnitTest, PostProcessingOnOutputBufferAvailable_Valid_Test_001, TestSize.Level1)
104 {
105 CreateCodecByMime();
106 auto mock = std::make_shared<MediaCodecCallbackMock>();
107 server_->videoCb_ = mock;
108 int32_t index = 1;
109 int32_t flag = 1;
110 server_->PostProcessingOnOutputBufferAvailable(index, flag);
111 }
112
113 /**
114 * @tc.name: PostProcessingOnOutputBufferAvailable_Valid_Test_002
115 * @tc.desc: videoCb_ is nullptr
116 */
117 HWTEST_F(CodecServerUnitTest, PostProcessingOnOutputBufferAvailable_Valid_Test_002, TestSize.Level1)
118 {
119 CreateCodecByMime();
120 server_->videoCb_ = nullptr;
121 int32_t index = 1;
122 int32_t flag = 1;
123 server_->PostProcessingOnOutputBufferAvailable(index, flag);
124 }
125
126 /**
127 * @tc.name: StartPostProcessing_Invalid_Test_001
128 * @tc.desc: postProcessing controller is nullptr
129 */
130 HWTEST_F(CodecServerUnitTest, StartPostProcessing_Invalid_Test_001, TestSize.Level1)
131 {
132 CreateCodecByMime();
133 server_->postProcessing_ = std::make_unique<CodecServer::PostProcessingType>(server_->codecBase_);
134 int32_t ret = server_->StartPostProcessing();
135 EXPECT_NE(ret, AVCS_ERR_OK);
136 }
137
138 /**
139 * @tc.name: StopPostProcessing_inValid_Test_001
140 * @tc.desc: postProcessing controller is nullptr
141 */
142 HWTEST_F(CodecServerUnitTest, StopPostProcessing_inValid_Test_001, TestSize.Level1)
143 {
144 CreateCodecByMime();
145 server_->postProcessingTask_ = nullptr;
146 server_->postProcessing_ = std::make_unique<CodecServer::PostProcessingType>(server_->codecBase_);
147 int32_t ret = server_->StopPostProcessing();
148 EXPECT_NE(ret, AVCS_ERR_OK);
149 }
150
151 /**
152 * @tc.name: StopPostProcessing_Valid_Test_002
153 * @tc.desc: codec StopPostProcessing
154 */
155 HWTEST_F(CodecServerUnitTest, StopPostProcessing_Valid_Test_002, TestSize.Level1)
156 {
157 CreateCodecByMime();
158 auto bufferInfoQueue = std::make_shared<CodecServer::DecodedBufferInfoQueue>(DEFAULT_LOCK_FREE_QUEUE_NAME);
159 auto postprocessingBufferInfoQueue =
160 std::make_shared<CodecServer::PostProcessingBufferInfoQueue>(POST_PROCESSING_LOCK_FREE_QUEUE_NAME);
161 server_->postProcessingTask_ = std::make_unique<TaskThread>(DEFAULT_TASK_NAME);
162 server_->postProcessing_ = nullptr;
163 server_->decodedBufferInfoQueue_ = bufferInfoQueue;
164 server_->postProcessingInputBufferInfoQueue_ = postprocessingBufferInfoQueue;
165 int32_t ret = server_->StopPostProcessing();
166 EXPECT_EQ(ret, AVCS_ERR_OK);
167 }
168
169 /**
170 * @tc.name: FlushPostProcessing_Invalid_Test_001
171 * @tc.desc: postProcessing flush failed
172 */
173 HWTEST_F(CodecServerUnitTest, FlushPostProcessing_Invalid_Test_001, TestSize.Level1)
174 {
175 CreateCodecByMime();
176 auto bufferInfoQueue = std::make_shared<CodecServer::DecodedBufferInfoQueue>(DEFAULT_LOCK_FREE_QUEUE_NAME);
177 auto postprocessingBufferInfoQueue =
178 std::make_shared<CodecServer::PostProcessingBufferInfoQueue>(POST_PROCESSING_LOCK_FREE_QUEUE_NAME);
179 server_->postProcessing_ = std::make_unique<CodecServer::PostProcessingType>(server_->codecBase_);
180 server_->postProcessingTask_ = std::make_unique<TaskThread>(DEFAULT_TASK_NAME);
181 server_->decodedBufferInfoQueue_ = bufferInfoQueue;
182 server_->postProcessingInputBufferInfoQueue_ = postprocessingBufferInfoQueue;
183 int32_t ret = server_->FlushPostProcessing();
184 EXPECT_NE(ret, AVCS_ERR_OK);
185 }
186
187 /**
188 * @tc.name: FlushPostProcessing_Invalid_Test_002
189 * @tc.desc: postProcessing flush failed
190 */
191 HWTEST_F(CodecServerUnitTest, FlushPostProcessing_Invalid_Test_002, TestSize.Level1)
192 {
193 CreateCodecByMime();
194 auto bufferInfoQueue = std::make_shared<CodecServer::DecodedBufferInfoQueue>(DEFAULT_LOCK_FREE_QUEUE_NAME);
195 server_->postProcessing_ = std::make_unique<CodecServer::PostProcessingType>(server_->codecBase_);
196 server_->postProcessingTask_ = nullptr;
197 server_->decodedBufferInfoQueue_ = nullptr;
198 server_->postProcessingInputBufferInfoQueue_ = nullptr;
199 int32_t ret = server_->FlushPostProcessing();
200 EXPECT_NE(ret, AVCS_ERR_OK);
201 }
202
203 /**
204 * @tc.name: FlushPostProcessing_Valid_Test_002
205 * @tc.desc: codec FlushPostProcessing
206 */
207 HWTEST_F(CodecServerUnitTest, FlushPostProcessing_Valid_Test_002, TestSize.Level1)
208 {
209 CreateCodecByMime();
210 server_->postProcessing_ = nullptr;
211 int32_t ret = server_->FlushPostProcessing();
212 EXPECT_EQ(ret, AVCS_ERR_OK);
213 }
214
215 /**
216 * @tc.name: ResetPostProcessing_Valid_Test_001
217 * @tc.desc: codec ResetPostProcessing
218 */
219 HWTEST_F(CodecServerUnitTest, ResetPostProcessing_Valid_Test_001, TestSize.Level1)
220 {
221 CreateCodecByMime();
222 server_->postProcessing_ = std::make_unique<CodecServer::PostProcessingType>(server_->codecBase_);
223 int32_t ret = server_->ResetPostProcessing();
224 EXPECT_EQ(ret, AVCS_ERR_OK);
225 }
226
227 /**
228 * @tc.name: StartPostProcessingTask_Valid_Test_001
229 * @tc.desc: codec StartPostProcessingTask
230 */
231 HWTEST_F(CodecServerUnitTest, StartPostProcessingTask_Valid_Test_001, TestSize.Level1)
232 {
233 CreateCodecByMime();
234 auto bufferInfoQueue = std::make_shared<CodecServer::DecodedBufferInfoQueue>(DEFAULT_LOCK_FREE_QUEUE_NAME);
235 auto postprocessingBufferInfoQueue =
236 std::make_shared<CodecServer::PostProcessingBufferInfoQueue>(POST_PROCESSING_LOCK_FREE_QUEUE_NAME);
237 server_->postProcessingTask_ = nullptr;
238 server_->decodedBufferInfoQueue_ = bufferInfoQueue;
239 server_->postProcessingInputBufferInfoQueue_ = postprocessingBufferInfoQueue;
240 server_->StartPostProcessingTask();
241 EXPECT_NE(server_->postProcessingTask_, nullptr);
242 }
243
244 /**
245 * @tc.name: StartPostProcessingTask_Valid_Test_002
246 * @tc.desc: codec StartPostProcessingTask
247 */
248 HWTEST_F(CodecServerUnitTest, StartPostProcessingTask_Valid_Test_002, TestSize.Level1)
249 {
250 CreateCodecByMime();
251 auto bufferInfoQueue = std::make_shared<CodecServer::DecodedBufferInfoQueue>(DEFAULT_LOCK_FREE_QUEUE_NAME);
252 server_->postProcessingTask_ = std::make_unique<TaskThread>(DEFAULT_TASK_NAME);
253 server_->decodedBufferInfoQueue_ = nullptr;
254 server_->postProcessingInputBufferInfoQueue_ = nullptr;
255 server_->StartPostProcessingTask();
256 }
257
258 /**
259 * @tc.name: DeactivatePostProcessingQueue_Valid_Test_001
260 * @tc.desc: codec DeactivatePostProcessingQueue
261 */
262 HWTEST_F(CodecServerUnitTest, DeactivatePostProcessingQueue_Valid_Test_001, TestSize.Level1)
263 {
264 CreateCodecByMime();
265 auto bufferInfoQueue = std::make_shared<CodecServer::DecodedBufferInfoQueue>(DEFAULT_LOCK_FREE_QUEUE_NAME);
266 auto postprocessingBufferInfoQueue =
267 std::make_shared<CodecServer::PostProcessingBufferInfoQueue>(POST_PROCESSING_LOCK_FREE_QUEUE_NAME);
268 server_->decodedBufferInfoQueue_ = bufferInfoQueue;
269 server_->postProcessingInputBufferInfoQueue_ = postprocessingBufferInfoQueue;
270 server_->DeactivatePostProcessingQueue();
271 EXPECT_EQ(server_->decodedBufferInfoQueue_->active_, false);
272 EXPECT_EQ(server_->postProcessingInputBufferInfoQueue_->active_, false);
273 }
274
275 /**
276 * @tc.name: CleanPostProcessingResource_Valid_Test_001
277 * @tc.desc: codec CleanPostProcessingResource
278 */
279 HWTEST_F(CodecServerUnitTest, CleanPostProcessingResource_Valid_Test_001, TestSize.Level1)
280 {
281 CreateCodecByMime();
282 auto bufferInfoQueue = std::make_shared<CodecServer::DecodedBufferInfoQueue>(DEFAULT_LOCK_FREE_QUEUE_NAME);
283 auto postprocessingBufferInfoQueue =
284 std::make_shared<CodecServer::PostProcessingBufferInfoQueue>(POST_PROCESSING_LOCK_FREE_QUEUE_NAME);
285 server_->postProcessingTask_ = std::make_unique<TaskThread>(DEFAULT_TASK_NAME);
286 server_->decodedBufferInfoQueue_ = bufferInfoQueue;
287 server_->postProcessingInputBufferInfoQueue_ = postprocessingBufferInfoQueue;
288 server_->CleanPostProcessingResource();
289 EXPECT_EQ(server_->postProcessingTask_, nullptr);
290 EXPECT_EQ(server_->decodedBufferInfoQueue_, nullptr);
291 EXPECT_EQ(server_->postProcessingInputBufferInfoQueue_, nullptr);
292 }
293 } // namespace MediaAVCodec
294 } // namespace OHOS
295
main(int argc,char ** argv)296 int main(int argc, char **argv)
297 {
298 testing::GTEST_FLAG(output) = "xml:./";
299 testing::InitGoogleTest(&argc, argv);
300 auto res = RUN_ALL_TESTS();
301 std::this_thread::sleep_for(std::chrono::milliseconds(1000)); // 1000ms
302 return res;
303 }