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 "codec_server_coverage_unit_test.h"
17 #include <fcntl.h>
18 #include <iostream>
19 #include <memory>
20 #include <vector>
21 #include "avcodec_errors.h"
22 #include "codeclist_core.h"
23 #include "media_description.h"
24 #include "meta/meta_key.h"
25 #include "ui/rs_surface_node.h"
26 #include "window_manager.h"
27 #include "window_option.h"
28 #ifdef SUPPORT_DRM
29 #include "imedia_key_session_service.h"
30 #endif
31 #define EXPECT_CALL_GET_HCODEC_CAPS_MOCK \
32 EXPECT_CALL(*codecBaseMock_, GetHCapabilityList).Times(AtLeast(1)).WillRepeatedly
33 #define EXPECT_CALL_GET_FCODEC_CAPS_MOCK \
34 EXPECT_CALL(*codecBaseMock_, GetFCapabilityList).Times(AtLeast(1)).WillRepeatedly
35 using namespace OHOS;
36 using namespace OHOS::MediaAVCodec;
37 using namespace OHOS::Media;
38 using namespace testing;
39 using namespace testing::ext;
40
41 namespace OHOS {
42 namespace MediaAVCodec {
CreateFCodecByName()43 void CodecServerUnitTest::CreateFCodecByName()
44 {
45 std::string codecName = "video.F.Decoder.Name.00";
46
47 EXPECT_CALL(*codecBaseMock_, Init).Times(1).WillOnce(Return(AVCS_ERR_OK));
48 EXPECT_CALL_GET_HCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, {})));
49 EXPECT_CALL_GET_FCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, FCODEC_CAPS)));
50 EXPECT_CALL(*codecBaseMock_, CodecBaseCtor()).Times(1);
51 EXPECT_CALL(*codecBaseMock_, CreateFCodecByName(codecName))
52 .Times(1)
53 .WillOnce(Return(std::make_shared<CodecBase>()));
54 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<AVCodecCallback>(nullptr)))
55 .Times(1)
56 .WillOnce(Return(AVCS_ERR_OK));
57 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<MediaCodecCallback>(nullptr)))
58 .Times(1)
59 .WillOnce(Return(AVCS_ERR_OK));
60 int32_t ret = server_->Init(AVCODEC_TYPE_VIDEO_ENCODER, false, codecName,
61 *validFormat_.GetMeta(), API_VERSION::API_VERSION_11);
62 EXPECT_EQ(ret, AVCS_ERR_OK);
63 }
64
CreateFCodecByMime()65 void CodecServerUnitTest::CreateFCodecByMime()
66 {
67 std::string codecName = "video.F.Decoder.Name.00";
68 std::string codecMime = CODEC_MIME_MOCK_00;
69
70 EXPECT_CALL(*codecBaseMock_, Init).Times(1).WillOnce(Return(AVCS_ERR_OK));
71 EXPECT_CALL_GET_HCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, {})));
72 EXPECT_CALL_GET_FCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, FCODEC_CAPS)));
73 EXPECT_CALL(*codecBaseMock_, CodecBaseCtor()).Times(1);
74 EXPECT_CALL(*codecBaseMock_, CreateFCodecByName(codecName))
75 .Times(1)
76 .WillOnce(Return(std::make_shared<CodecBase>()));
77 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<AVCodecCallback>(nullptr)))
78 .Times(1)
79 .WillOnce(Return(AVCS_ERR_OK));
80 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<MediaCodecCallback>(nullptr)))
81 .Times(1)
82 .WillOnce(Return(AVCS_ERR_OK));
83
84 int32_t ret = server_->Init(AVCODEC_TYPE_VIDEO_ENCODER, true, codecMime,
85 *validFormat_.GetMeta(), API_VERSION::API_VERSION_11);
86 EXPECT_EQ(ret, AVCS_ERR_OK);
87 }
88
CreateHCodecByName()89 void CodecServerUnitTest::CreateHCodecByName()
90 {
91 std::string codecName = "video.H.Encoder.Name.00";
92
93 EXPECT_CALL(*codecBaseMock_, Init).Times(1).WillOnce(Return(AVCS_ERR_OK));
94 EXPECT_CALL_GET_HCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, HCODEC_CAPS)));
95 EXPECT_CALL_GET_FCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, {})));
96 EXPECT_CALL(*codecBaseMock_, CodecBaseCtor()).Times(1);
97 EXPECT_CALL(*codecBaseMock_, CreateHCodecByName(codecName))
98 .Times(1)
99 .WillOnce(Return(std::make_shared<CodecBase>()));
100 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<AVCodecCallback>(nullptr)))
101 .Times(1)
102 .WillOnce(Return(AVCS_ERR_OK));
103 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<MediaCodecCallback>(nullptr)))
104 .Times(1)
105 .WillOnce(Return(AVCS_ERR_OK));
106
107 int32_t ret = server_->Init(AVCODEC_TYPE_VIDEO_ENCODER, false, codecName,
108 *validFormat_.GetMeta(), API_VERSION::API_VERSION_11);
109 EXPECT_EQ(ret, AVCS_ERR_OK);
110 }
111
CreateHCodecByMime()112 void CodecServerUnitTest::CreateHCodecByMime()
113 {
114 std::string codecName = "video.H.Encoder.Name.00";
115 std::string codecMime = CODEC_MIME_MOCK_00;
116
117 EXPECT_CALL(*codecBaseMock_, Init).Times(1).WillOnce(Return(AVCS_ERR_OK));
118 EXPECT_CALL_GET_HCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, HCODEC_CAPS)));
119 EXPECT_CALL_GET_FCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, {})));
120 EXPECT_CALL(*codecBaseMock_, CodecBaseCtor()).Times(1);
121 EXPECT_CALL(*codecBaseMock_, CreateHCodecByName(codecName))
122 .Times(1)
123 .WillOnce(Return(std::make_shared<CodecBase>()));
124 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<AVCodecCallback>(nullptr)))
125 .Times(1)
126 .WillOnce(Return(AVCS_ERR_OK));
127 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<MediaCodecCallback>(nullptr)))
128 .Times(1)
129 .WillOnce(Return(AVCS_ERR_OK));
130
131 int32_t ret = server_->Init(AVCODEC_TYPE_VIDEO_ENCODER, true, codecMime,
132 *validFormat_.GetMeta(), API_VERSION::API_VERSION_11);
133 EXPECT_EQ(ret, AVCS_ERR_OK);
134 }
135
136 /**
137 * @tc.name: Codec_Server_Constructor_001
138 * @tc.desc: create video encoder of fcodec by name
139 */
140 HWTEST_F(CodecServerUnitTest, Codec_Server_Constructor_001, TestSize.Level1)
141 {
142 CreateFCodecByName();
143 EXPECT_NE(server_->codecBase_, nullptr);
144 }
145
146 /**
147 * @tc.name: Codec_Server_Constructor_002
148 * @tc.desc: create video encoder of fcodec by mime
149 */
150 HWTEST_F(CodecServerUnitTest, Codec_Server_Constructor_002, TestSize.Level1)
151 {
152 CreateFCodecByMime();
153 EXPECT_NE(server_->codecBase_, nullptr);
154 }
155
156 /**
157 * @tc.name: Codec_Server_Constructor_003
158 * @tc.desc: create video encoder of hcodec by name
159 */
160 HWTEST_F(CodecServerUnitTest, Codec_Server_Constructor_003, TestSize.Level1)
161 {
162 CreateHCodecByName();
163 EXPECT_NE(server_->codecBase_, nullptr);
164 }
165
166 /**
167 * @tc.name: Codec_Server_Constructor_004
168 * @tc.desc: create video encoder of hcodec by mime
169 */
170 HWTEST_F(CodecServerUnitTest, Codec_Server_Constructor_004, TestSize.Level1)
171 {
172 CreateHCodecByMime();
173 EXPECT_NE(server_->codecBase_, nullptr);
174 }
175
176 /**
177 * @tc.name: Codec_Server_Constructor_005
178 * @tc.desc: 1. failed to create video decoder of hcodec by mime
179 * 2. return fcodec
180 */
181 HWTEST_F(CodecServerUnitTest, Codec_Server_Constructor_005, TestSize.Level1)
182 {
183 std::string codecMime = CODEC_MIME_MOCK_01;
184 std::string hcodecName = "video.H.Decoder.Name.01";
185 std::string fcodecName = "video.F.Decoder.Name.01";
186
187 EXPECT_CALL(*codecBaseMock_, Init).Times(1).WillOnce(Return(AVCS_ERR_OK));
188 EXPECT_CALL_GET_HCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, HCODEC_CAPS)));
189 EXPECT_CALL_GET_FCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, FCODEC_CAPS)));
190 EXPECT_CALL(*codecBaseMock_, CodecBaseCtor()).Times(1);
191 EXPECT_CALL(*codecBaseMock_, CreateHCodecByName(hcodecName)).Times(1).WillOnce(Return(nullptr));
192 EXPECT_CALL(*codecBaseMock_, CreateFCodecByName(fcodecName))
193 .Times(1)
194 .WillOnce(Return(std::make_shared<CodecBase>()));
195 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<AVCodecCallback>(nullptr)))
196 .Times(1)
197 .WillOnce(Return(AVCS_ERR_OK));
198 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<MediaCodecCallback>(nullptr)))
199 .Times(1)
200 .WillOnce(Return(AVCS_ERR_OK));
201
202 int32_t ret = server_->Init(AVCODEC_TYPE_VIDEO_DECODER, true, codecMime,
203 *validFormat_.GetMeta(), API_VERSION::API_VERSION_11);
204 EXPECT_EQ(ret, AVCS_ERR_OK);
205
206 EXPECT_NE(server_->codecBase_, nullptr);
207 }
208
209 /**
210 * @tc.name: Codec_Server_Constructor_006
211 * @tc.desc: 1. sucess to create video decoder of hcodec by mime
212 * 2. failed to init video hcodec
213 * 3. return fcodec
214 */
215 HWTEST_F(CodecServerUnitTest, Codec_Server_Constructor_006, TestSize.Level1)
216 {
217 std::string codecMime = CODEC_MIME_MOCK_01;
218 std::string hcodecName = "video.H.Decoder.Name.01";
219 std::string fcodecName = "video.F.Decoder.Name.01";
220
221 EXPECT_CALL(*codecBaseMock_, Init).Times(2).WillOnce(Return(AVCS_ERR_UNKNOWN)).WillOnce(Return(AVCS_ERR_OK));
222 EXPECT_CALL_GET_HCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, HCODEC_CAPS)));
223 EXPECT_CALL_GET_FCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, FCODEC_CAPS)));
224 EXPECT_CALL(*codecBaseMock_, CodecBaseCtor()).Times(2);
225 EXPECT_CALL(*codecBaseMock_, CreateHCodecByName(hcodecName))
226 .Times(1)
227 .WillOnce(Return(std::make_shared<CodecBase>()));
228 EXPECT_CALL(*codecBaseMock_, CreateFCodecByName(fcodecName))
229 .Times(1)
230 .WillOnce(Return(std::make_shared<CodecBase>()));
231 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<AVCodecCallback>(nullptr)))
232 .Times(1)
233 .WillOnce(Return(AVCS_ERR_OK));
234 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<MediaCodecCallback>(nullptr)))
235 .Times(1)
236 .WillOnce(Return(AVCS_ERR_OK));
237
238 int32_t ret = server_->Init(AVCODEC_TYPE_VIDEO_DECODER, true, codecMime, *validFormat_.GetMeta(),
239 API_VERSION::API_VERSION_11);
240 EXPECT_EQ(ret, AVCS_ERR_OK);
241
242 EXPECT_NE(server_->codecBase_, nullptr);
243 }
244
245 /**
246 * @tc.name: Codec_Server_Constructor_Invalid_001
247 * @tc.desc: 1. create hcodec by name
248 * 2. CodecFactory return nullptr
249 */
250 HWTEST_F(CodecServerUnitTest, Codec_Server_Constructor_Invalid_001, TestSize.Level1)
251 {
252 std::string codecName = "video.H.Encoder.Name.00";
253
254 EXPECT_CALL_GET_HCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, HCODEC_CAPS)));
255 EXPECT_CALL_GET_FCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, FCODEC_CAPS)));
256 EXPECT_CALL(*codecBaseMock_, CreateHCodecByName(codecName)).Times(1).WillOnce(Return(nullptr));
257 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<AVCodecCallback>(nullptr))).Times(0);
258 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<MediaCodecCallback>(nullptr))).Times(0);
259
260 int32_t ret = server_->Init(AVCODEC_TYPE_VIDEO_ENCODER, false, codecName,
261 *validFormat_.GetMeta(), API_VERSION::API_VERSION_11);
262 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
263 }
264
265 /**
266 * @tc.name: Codec_Server_Constructor_Invalid_002
267 * @tc.desc: 1. create hcodec by name
268 * 2. SetCallback of AVCodecCallback return error
269 */
270 HWTEST_F(CodecServerUnitTest, Codec_Server_Constructor_Invalid_002, TestSize.Level1)
271 {
272 std::string codecName = "video.H.Encoder.Name.00";
273
274 EXPECT_CALL(*codecBaseMock_, Init).Times(1).WillOnce(Return(AVCS_ERR_OK));
275 EXPECT_CALL_GET_HCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, HCODEC_CAPS)));
276 EXPECT_CALL_GET_FCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, FCODEC_CAPS)));
277 EXPECT_CALL(*codecBaseMock_, CodecBaseCtor()).Times(1);
278 EXPECT_CALL(*codecBaseMock_, CreateHCodecByName(codecName))
279 .Times(1)
280 .WillOnce(Return(std::make_shared<CodecBase>()));
281 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<AVCodecCallback>(nullptr)))
282 .Times(1)
283 .WillOnce(Return(AVCS_ERR_INVALID_OPERATION));
284 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<MediaCodecCallback>(nullptr))).Times(0);
285
286 int32_t ret = server_->Init(AVCODEC_TYPE_VIDEO_ENCODER, false, codecName,
287 *validFormat_.GetMeta(), API_VERSION::API_VERSION_11);
288 EXPECT_EQ(ret, AVCS_ERR_INVALID_OPERATION);
289 }
290
291 /**
292 * @tc.name: Codec_Server_Constructor_Invalid_003
293 * @tc.desc: 1. create hcodec by name
294 * 2. SetCallback of MediaCodecCallback return error
295 */
296 HWTEST_F(CodecServerUnitTest, Codec_Server_Constructor_Invalid_003, TestSize.Level1)
297 {
298 std::string codecName = "video.H.Encoder.Name.00";
299
300 EXPECT_CALL(*codecBaseMock_, Init).Times(1).WillOnce(Return(AVCS_ERR_OK));
301 EXPECT_CALL_GET_HCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, HCODEC_CAPS)));
302 EXPECT_CALL_GET_FCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, FCODEC_CAPS)));
303 EXPECT_CALL(*codecBaseMock_, CodecBaseCtor()).Times(1);
304 EXPECT_CALL(*codecBaseMock_, CreateHCodecByName(codecName))
305 .Times(1)
306 .WillOnce(Return(std::make_shared<CodecBase>()));
307 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<AVCodecCallback>(nullptr)))
308 .Times(1)
309 .WillOnce(Return(AVCS_ERR_OK));
310 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<MediaCodecCallback>(nullptr)))
311 .Times(1)
312 .WillOnce(Return(AVCS_ERR_INVALID_OPERATION));
313
314 int32_t ret = server_->Init(AVCODEC_TYPE_VIDEO_ENCODER, false, codecName,
315 *validFormat_.GetMeta(), API_VERSION::API_VERSION_11);
316 EXPECT_EQ(ret, AVCS_ERR_INVALID_OPERATION);
317 }
318
319 /**
320 * @tc.name: Codec_Server_Constructor_Invalid_004
321 * @tc.desc: 1. create hcodec by name
322 * 2. SetCallback of MediaCodecCallback return error
323 */
324 HWTEST_F(CodecServerUnitTest, Codec_Server_Constructor_Invalid_004, TestSize.Level1)
325 {
326 std::string codecName = "video.H.Encoder.Name.00";
327
328 EXPECT_CALL(*codecBaseMock_, Init).Times(1).WillOnce(Return(AVCS_ERR_OK));
329 EXPECT_CALL_GET_HCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, HCODEC_CAPS)));
330 EXPECT_CALL_GET_FCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, FCODEC_CAPS)));
331 EXPECT_CALL(*codecBaseMock_, CodecBaseCtor()).Times(1);
332 EXPECT_CALL(*codecBaseMock_, CreateHCodecByName(codecName))
333 .Times(1)
334 .WillOnce(Return(std::make_shared<CodecBase>()));
335 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<AVCodecCallback>(nullptr)))
336 .Times(1)
337 .WillOnce(Return(AVCS_ERR_OK));
338 EXPECT_CALL(*codecBaseMock_, SetCallback(std::shared_ptr<MediaCodecCallback>(nullptr)))
339 .Times(1)
340 .WillOnce(Return(AVCS_ERR_INVALID_OPERATION));
341
342 int32_t ret =
343 server_->Init(AVCODEC_TYPE_VIDEO_ENCODER, false, codecName,
344 *validFormat_.GetMeta(), API_VERSION::API_VERSION_11);
345 EXPECT_EQ(ret, AVCS_ERR_INVALID_OPERATION);
346 }
347
348 /**
349 * @tc.name: Codec_Server_Constructor_Invalid_005
350 * @tc.desc: invalid audio codecname
351 */
352 HWTEST_F(CodecServerUnitTest, Codec_Server_Constructor_Invalid_005, TestSize.Level1)
353 {
354 std::string codecName = "AudioDecoder.InvaildName";
355 int32_t ret =
356 server_->Init(AVCODEC_TYPE_AUDIO_ENCODER, false, codecName,
357 *validFormat_.GetMeta(), API_VERSION::API_VERSION_11);
358 EXPECT_EQ(ret, AVCS_ERR_INVALID_OPERATION);
359 }
360
361 /**
362 * @tc.name: Codec_Server_Constructor_Invalid_006
363 * @tc.desc: invalid mime type
364 */
365 HWTEST_F(CodecServerUnitTest, Codec_Server_Constructor_Invalid_006, TestSize.Level1)
366 {
367 std::string codecMime = "test";
368 EXPECT_CALL_GET_HCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, HCODEC_CAPS)));
369 EXPECT_CALL_GET_FCODEC_CAPS_MOCK(Return(RetAndCaps(AVCS_ERR_OK, FCODEC_CAPS)));
370
371 int32_t ret = server_->Init(AVCODEC_TYPE_VIDEO_ENCODER, true, codecMime, *validFormat_.GetMeta(),
372 API_VERSION::API_VERSION_11);
373 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
374 }
375
376 /**
377 * @tc.name: State_Test_Configure_001
378 * @tc.desc: codec Configure
379 */
380 HWTEST_F(CodecServerUnitTest, State_Test_Configure_001, TestSize.Level1)
381 {
382 CreateHCodecByMime();
383 server_->status_ = CodecServer::CodecStatus::INITIALIZED;
384
385 EXPECT_CALL(*codecBaseMock_, Configure()).Times(1).WillOnce(Return(AVCS_ERR_OK));
386
387 int32_t ret = server_->Configure(validFormat_);
388 EXPECT_EQ(ret, AVCS_ERR_OK);
389 EXPECT_EQ(server_->status_, CodecServer::CodecStatus::CONFIGURED);
390 }
391
392 /**
393 * @tc.name: State_Test_Configure_Invalid_001
394 * @tc.desc: Configure in invalid state
395 */
396 HWTEST_F(CodecServerUnitTest, State_Test_Invalid_Configure_001, TestSize.Level1)
397 {
398 // valid: INITIALIZED
399 std::vector<CodecServer::CodecStatus> testList = {
400 CodecServer::CodecStatus::UNINITIALIZED, CodecServer::CodecStatus::CONFIGURED,
401 CodecServer::CodecStatus::RUNNING, CodecServer::CodecStatus::FLUSHED,
402 CodecServer::CodecStatus::END_OF_STREAM, CodecServer::CodecStatus::ERROR,
403 };
404 CreateHCodecByMime();
405 for (auto &val : testList) {
406 server_->status_ = val;
407 int32_t ret = server_->Configure(validFormat_);
408 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE) << "state: " << val << "\n";
409 }
410 }
411
412 /**
413 * @tc.name: State_Test_Configure_Invalid_002
414 * @tc.desc: Configure with codecBase is nullptr
415 */
416 HWTEST_F(CodecServerUnitTest, State_Test_Invalid_Configure_002, TestSize.Level1)
417 {
418 CreateHCodecByMime();
419 server_->codecBase_ = nullptr;
420
421 int32_t ret = server_->Configure(validFormat_);
422 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
423 }
424
425 /**
426 * @tc.name: State_Test_Configure_Invalid_003
427 * @tc.desc: Configure return err
428 */
429 HWTEST_F(CodecServerUnitTest, State_Test_Invalid_Configure_003, TestSize.Level1)
430 {
431 CreateHCodecByMime();
432 server_->status_ = CodecServer::CodecStatus::INITIALIZED;
433
434 int32_t err = AVCS_ERR_UNKNOWN;
435 EXPECT_CALL(*codecBaseMock_, Configure()).Times(1).WillOnce(Return(err));
436
437 int32_t ret = server_->Configure(validFormat_);
438 EXPECT_EQ(ret, err);
439 EXPECT_EQ(server_->status_, CodecServer::CodecStatus::ERROR);
440 }
441
442 /**
443 * @tc.name: State_Test_Start_001
444 * @tc.desc: codec Start
445 */
446 HWTEST_F(CodecServerUnitTest, State_Test_Start_001, TestSize.Level1)
447 {
448 std::vector<CodecServer::CodecStatus> testList = {
449 CodecServer::CodecStatus::CONFIGURED,
450 CodecServer::CodecStatus::FLUSHED,
451 };
452 CreateHCodecByMime();
453 EXPECT_CALL(*codecBaseMock_, Start()).Times(testList.size()).WillRepeatedly(Return(AVCS_ERR_OK));
454 EXPECT_CALL(*codecBaseMock_, GetOutputFormat()).Times(testList.size()).WillRepeatedly(Return(AVCS_ERR_OK));
455 for (auto &val : testList) {
456 server_->status_ = val;
457 int32_t ret = server_->Start();
458 EXPECT_EQ(ret, AVCS_ERR_OK);
459 EXPECT_EQ(server_->status_, CodecServer::CodecStatus::RUNNING);
460 }
461 }
462
463 /**
464 * @tc.name: State_Test_Start_Invalid_001
465 * @tc.desc: Start in invalid state
466 */
467 HWTEST_F(CodecServerUnitTest, State_Test_Invalid_Start_001, TestSize.Level1)
468 {
469 std::vector<CodecServer::CodecStatus> testList = {
470 CodecServer::CodecStatus::INITIALIZED, CodecServer::CodecStatus::UNINITIALIZED,
471 CodecServer::CodecStatus::RUNNING, CodecServer::CodecStatus::END_OF_STREAM,
472 CodecServer::CodecStatus::ERROR,
473 };
474 CreateHCodecByMime();
475 for (auto &val : testList) {
476 server_->status_ = val;
477 int32_t ret = server_->Start();
478 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE) << "state: " << val << "\n";
479 }
480 }
481
482 /**
483 * @tc.name: State_Test_Start_Invalid_002
484 * @tc.desc: Start with codecBase is nullptr
485 */
486 HWTEST_F(CodecServerUnitTest, State_Test_Invalid_Start_002, TestSize.Level1)
487 {
488 CreateHCodecByMime();
489 server_->status_ = CodecServer::CodecStatus::FLUSHED;
490 server_->codecBase_ = nullptr;
491
492 int32_t ret = server_->Start();
493 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
494 }
495
496 /**
497 * @tc.name: State_Test_Start_Invalid_003
498 * @tc.desc: Start return err
499 */
500 HWTEST_F(CodecServerUnitTest, State_Test_Invalid_Start_003, TestSize.Level1)
501 {
502 CreateHCodecByMime();
503 server_->status_ = CodecServer::CodecStatus::FLUSHED;
504
505 int32_t err = AVCS_ERR_UNKNOWN;
506 EXPECT_CALL(*codecBaseMock_, Start).Times(1).WillOnce(Return(err));
507
508 int32_t ret = server_->Start();
509 EXPECT_EQ(ret, err);
510 EXPECT_EQ(server_->status_, CodecServer::CodecStatus::ERROR);
511 }
512
CreateSurface()513 sptr<Surface> CreateSurface()
514 {
515 auto consumer = Surface::CreateSurfaceAsConsumer();
516 auto p = consumer->GetProducer();
517 return Surface::CreateSurfaceAsProducer(p);
518 }
519
520 /**
521 * @tc.name: CreateInputSurface_Valid_Test_001
522 * @tc.desc: codec CreateInputSurface in valid state
523 */
524 HWTEST_F(CodecServerUnitTest, CreateInputSurface_Valid_Test_001, TestSize.Level1)
525 {
526 CreateHCodecByMime();
527 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
528 sptr<Surface> surface = CreateSurface();
529 if (surface != nullptr) {
530 EXPECT_CALL(*codecBaseMock_, CreateInputSurface()).Times(1).WillOnce(Return(surface));
531 sptr<Surface> ret = server_->CreateInputSurface();
532 EXPECT_EQ(ret, surface);
533 }
534 }
535
536 /**
537 * @tc.name: CreateInputSurface_Invalid_Test_001
538 * @tc.desc: CreateInputSurface in invalid state
539 */
540 HWTEST_F(CodecServerUnitTest, CreateInputSurface_Invalid_Test_001, TestSize.Level1)
541 {
542 std::vector<CodecServer::CodecStatus> testList = {
543 CodecServer::CodecStatus::INITIALIZED, CodecServer::CodecStatus::UNINITIALIZED,
544 CodecServer::CodecStatus::RUNNING, CodecServer::CodecStatus::END_OF_STREAM,
545 CodecServer::CodecStatus::ERROR, CodecServer::CodecStatus::FLUSHED,
546 };
547 CreateHCodecByMime();
548
549 for (auto &val : testList) {
550 server_->status_ = val;
551 sptr<Surface> ret = server_->CreateInputSurface();
552 EXPECT_EQ(ret, nullptr) << "state: " << val << "\n";
553 }
554 }
555
556 /**
557 * @tc.name: CreateInputSurface_Invalid_Test_002
558 * @tc.desc: CreateInputSurface with codecBase is nullptr
559 */
560 HWTEST_F(CodecServerUnitTest, CreateInputSurface_Invalid_Test_002, TestSize.Level1)
561 {
562 CreateHCodecByMime();
563 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
564 server_->codecBase_ = nullptr;
565 sptr<Surface> ret = server_->CreateInputSurface();
566 EXPECT_EQ(ret, nullptr);
567 }
568
569 /**
570 * @tc.name: SetInputSurface_Valid_Test_001
571 * @tc.desc: codec SetInputSurface
572 */
573 HWTEST_F(CodecServerUnitTest, SetInputSurface_Valid_Test_001, TestSize.Level1)
574 {
575 CreateHCodecByMime();
576 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
577 sptr<Surface> surface = CreateSurface();
578 if (surface != nullptr) {
579 EXPECT_CALL(*codecBaseMock_, SetInputSurface(surface)).Times(1).WillOnce(Return(AVCS_ERR_OK));
580 int32_t ret = server_->SetInputSurface(surface);
581 EXPECT_EQ(ret, AVCS_ERR_OK);
582 }
583 }
584
585 /**
586 * @tc.name: SetInputSurface_Valid_Test_002
587 * @tc.desc: codec SetInputSurface
588 */
589 HWTEST_F(CodecServerUnitTest, SetInputSurface_Valid_Test_002, TestSize.Level1)
590 {
591 CreateHCodecByMime();
592 server_->isModeConfirmed_ = false;
593 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
594 sptr<Surface> surface = CreateSurface();
595 if (surface != nullptr) {
596 EXPECT_CALL(*codecBaseMock_, SetInputSurface(surface)).Times(1).WillOnce(Return(AVCS_ERR_OK));
597 int32_t ret = server_->SetInputSurface(surface);
598 EXPECT_EQ(ret, AVCS_ERR_OK);
599 }
600 }
601
602 /**
603 * @tc.name: SetInputSurface_Invalid_Test_001
604 * @tc.desc: SetInputSurface in invalid state
605 */
606 HWTEST_F(CodecServerUnitTest, SetInputSurface_Invalid_Test_001, TestSize.Level1)
607 {
608 std::vector<CodecServer::CodecStatus> testList = {
609 CodecServer::CodecStatus::INITIALIZED, CodecServer::CodecStatus::UNINITIALIZED,
610 CodecServer::CodecStatus::RUNNING, CodecServer::CodecStatus::END_OF_STREAM,
611 CodecServer::CodecStatus::ERROR, CodecServer::CodecStatus::FLUSHED,
612 };
613 CreateHCodecByMime();
614
615 sptr<Surface> surface = CreateSurface();
616 if (surface != nullptr) {
617 for (auto &val : testList) {
618 server_->status_ = val;
619 int32_t ret = server_->SetInputSurface(surface);
620 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE) << "state: " << val << "\n";
621 }
622 }
623 }
624
625 /**
626 * @tc.name: SetInputSurface_Invalid_Test_002
627 * @tc.desc: SetInputSurface with codecBase is nullptr
628 */
629 HWTEST_F(CodecServerUnitTest, SetInputSurface_Invalid_Test_002, TestSize.Level1)
630 {
631 CreateHCodecByMime();
632 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
633 server_->codecBase_ = nullptr;
634 sptr<Surface> surface = CreateSurface();
635 if (surface != nullptr) {
636 int32_t ret = server_->SetInputSurface(surface);
637 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
638 }
639 }
640
641 /**
642 * @tc.name: SetOutputSurface_Valid_Test_001
643 * @tc.desc: codec SetOutputSurface
644 */
645 HWTEST_F(CodecServerUnitTest, SetOutputSurface_Valid_Test_001, TestSize.Level1)
646 {
647 CreateHCodecByMime();
648 server_->isModeConfirmed_ = true;
649 server_->isSurfaceMode_ = true;
650
651 std::vector<CodecServer::CodecStatus> testList = {
652 CodecServer::CodecStatus::CONFIGURED, CodecServer::CodecStatus::FLUSHED,
653 CodecServer::CodecStatus::RUNNING, CodecServer::CodecStatus::END_OF_STREAM,
654 };
655 sptr<Surface> surface = CreateSurface();
656 if (surface != nullptr) {
657 EXPECT_CALL(*codecBaseMock_, SetOutputSurface(surface))
658 .Times(testList.size())
659 .WillRepeatedly(Return(AVCS_ERR_OK));
660
661 for (auto &val : testList) {
662 server_->status_ = val;
663 int32_t ret = server_->SetOutputSurface(surface);
664 EXPECT_EQ(ret, AVCS_ERR_OK) << "state: " << val << "\n";
665 }
666 }
667 }
668
669 /**
670 * @tc.name: SetOutputSurface_Valid_Test_002
671 * @tc.desc: codec SetOutputSurface
672 */
673 HWTEST_F(CodecServerUnitTest, SetOutputSurface_Valid_Test_002, TestSize.Level1)
674 {
675 CreateHCodecByMime();
676 server_->isModeConfirmed_ = false;
677 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
678 sptr<Surface> surface = CreateSurface();
679 if (surface != nullptr) {
680 EXPECT_CALL(*codecBaseMock_, SetOutputSurface(surface)).Times(1).WillOnce(Return(AVCS_ERR_OK));
681 int32_t ret = server_->SetOutputSurface(surface);
682 EXPECT_EQ(ret, AVCS_ERR_OK);
683 }
684 }
685
686 /**
687 * @tc.name: SetOutputSurface_Valid_Test_003
688 * @tc.desc: codec SetOutputSurface
689 */
690 HWTEST_F(CodecServerUnitTest, SetOutputSurface_Valid_Test_003, TestSize.Level1)
691 {
692 CreateHCodecByMime();
693 server_->postProcessing_ = std::make_unique<CodecServer::PostProcessingType>(server_->codecBase_);
694 server_->isModeConfirmed_ = false;
695 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
696 sptr<Surface> surface = CreateSurface();
697 if (surface != nullptr) {
698 EXPECT_CALL(*codecBaseMock_, SetOutputSurface(surface)).Times(0);
699 server_->SetOutputSurface(surface);
700 }
701 }
702
703 /**
704 * @tc.name: SetOutputSurface_Invalid_Test_001
705 * @tc.desc: SetOutputSurface in invalid mode
706 */
707 HWTEST_F(CodecServerUnitTest, SetOutputSurface_Invalid_Test_001, TestSize.Level1)
708 {
709 CreateHCodecByMime();
710 server_->isModeConfirmed_ = true;
711 server_->isSurfaceMode_ = false;
712 sptr<Surface> surface = CreateSurface();
713 if (surface != nullptr) {
714 int32_t ret = server_->SetOutputSurface(surface);
715 EXPECT_EQ(ret, AVCS_ERR_INVALID_OPERATION);
716 }
717 }
718
719 /**
720 * @tc.name: SetOutputSurface_Invalid_Test_002
721 * @tc.desc: SetOutputSurface in invalid state
722 */
723 HWTEST_F(CodecServerUnitTest, SetOutputSurface_Invalid_Test_002, TestSize.Level1)
724 {
725 CreateHCodecByMime();
726 server_->isModeConfirmed_ = true;
727 server_->isSurfaceMode_ = true;
728 std::vector<CodecServer::CodecStatus> testList = {
729 CodecServer::CodecStatus::INITIALIZED,
730 CodecServer::CodecStatus::UNINITIALIZED,
731 CodecServer::CodecStatus::ERROR,
732 };
733
734 sptr<Surface> surface = CreateSurface();
735 if (surface != nullptr) {
736 int32_t ret = server_->SetOutputSurface(surface);
737 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE);
738 }
739 }
740
741 /**
742 * @tc.name: SetOutputSurface_Invalid_Test_003
743 * @tc.desc: SetOutputSurface in invalid state
744 */
745 HWTEST_F(CodecServerUnitTest, SetOutputSurface_Invalid_Test_003, TestSize.Level1)
746 {
747 CreateHCodecByMime();
748 server_->isModeConfirmed_ = false;
749 std::vector<CodecServer::CodecStatus> testList = {
750 CodecServer::CodecStatus::INITIALIZED, CodecServer::CodecStatus::UNINITIALIZED,
751 CodecServer::CodecStatus::RUNNING, CodecServer::CodecStatus::END_OF_STREAM,
752 CodecServer::CodecStatus::ERROR, CodecServer::CodecStatus::FLUSHED,
753 };
754
755 sptr<Surface> surface = CreateSurface();
756 if (surface != nullptr) {
757 for (auto &val : testList) {
758 server_->status_ = val;
759 int32_t ret = server_->SetOutputSurface(surface);
760 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE) << "state: " << val << "\n";
761 }
762 }
763 }
764
765 /**
766 * @tc.name: SetOutputSurface_Invalid_Test_004
767 * @tc.desc: SetInputSurface with codecBase is nullptr
768 */
769 HWTEST_F(CodecServerUnitTest, SetOutputSurface_Invalid_Test_004, TestSize.Level1)
770 {
771 CreateHCodecByMime();
772 server_->isModeConfirmed_ = false;
773 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
774 server_->codecBase_ = nullptr;
775 sptr<Surface> surface = CreateSurface();
776 if (surface != nullptr) {
777 int32_t ret = server_->SetOutputSurface(surface);
778 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
779 }
780 }
781
782 /**
783 * @tc.name: QueueInputBuffer_Invalid_Test_001
784 * @tc.desc: QueueInputBuffer in invalid state
785 */
786 HWTEST_F(CodecServerUnitTest, QueueInputBuffer_Invalid_Test_001, TestSize.Level1)
787 {
788 CreateHCodecByMime();
789 uint32_t index = 1;
790 int32_t ret = server_->QueueInputBuffer(index);
791 EXPECT_EQ(ret, AVCS_ERR_UNSUPPORT);
792 }
793
794 /**
795 * @tc.name: QueueInputParameter_Invalid_Test_001
796 * @tc.desc: QueueInputParameter in invalid state
797 */
798 HWTEST_F(CodecServerUnitTest, QueueInputParameter_Invalid_Test_001, TestSize.Level1)
799 {
800 CreateHCodecByMime();
801 uint32_t index = 1;
802 int32_t ret = server_->QueueInputParameter(index);
803 EXPECT_EQ(ret, AVCS_ERR_UNSUPPORT);
804 }
805
806 /**
807 * @tc.name: GetOutputFormat_Valid_Test_001
808 * @tc.desc: codec GetOutputFormat
809 */
810 HWTEST_F(CodecServerUnitTest, GetOutputFormat_Valid_Test_001, TestSize.Level1)
811 {
812 CreateHCodecByMime();
813 server_->status_ = CodecServer::CodecStatus::UNINITIALIZED;
814 int32_t ret = server_->GetOutputFormat(validFormat_);
815 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE);
816 }
817
818 /**
819 * @tc.name: GetOutputFormat_Invalid_Test_001
820 * @tc.desc: GetOutputFormat in invalid state
821 */
822 HWTEST_F(CodecServerUnitTest, GetOutputFormat_Invalid_Test_001, TestSize.Level1)
823 {
824 std::vector<CodecServer::CodecStatus> testList = {
825 CodecServer::CodecStatus::INITIALIZED, CodecServer::CodecStatus::CONFIGURED,
826 CodecServer::CodecStatus::RUNNING, CodecServer::CodecStatus::END_OF_STREAM,
827 CodecServer::CodecStatus::ERROR, CodecServer::CodecStatus::FLUSHED,
828 };
829 CreateHCodecByMime();
830
831 EXPECT_CALL(*codecBaseMock_, GetOutputFormat())
832 .Times(testList.size())
833 .WillRepeatedly(Return(AVCS_ERR_OK));
834
835 for (auto &val : testList) {
836 server_->status_ = val;
837 int32_t ret = server_->GetOutputFormat(validFormat_);
838 EXPECT_EQ(ret, AVCS_ERR_OK) << "state: " << val << "\n";
839 }
840 }
841
842 /**
843 * @tc.name: GetOutputFormat_Invalid_Test_002
844 * @tc.desc: GetOutputFormat with codecBase is nullptr
845 */
846 HWTEST_F(CodecServerUnitTest, GetOutputFormat_Invalid_Test_002, TestSize.Level1)
847 {
848 CreateHCodecByMime();
849 server_->status_ = CodecServer::CodecStatus::RUNNING;
850 server_->codecBase_ = nullptr;
851 int32_t ret = server_->GetOutputFormat(validFormat_);
852 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
853 }
854
855 /**
856 * @tc.name: GetInputFormat_Valid_Test_001
857 * @tc.desc: codec GetInputFormat in valid state
858 */
859 HWTEST_F(CodecServerUnitTest, GetInputFormat_Valid_Test_001, TestSize.Level1)
860 {
861 CreateHCodecByMime();
862 std::vector<CodecServer::CodecStatus> testList = {
863 CodecServer::CodecStatus::CONFIGURED,
864 CodecServer::CodecStatus::RUNNING,
865 CodecServer::CodecStatus::FLUSHED,
866 CodecServer::CodecStatus::END_OF_STREAM,
867 };
868
869 EXPECT_CALL(*codecBaseMock_, GetInputFormat).Times(testList.size()).WillRepeatedly(Return(AVCS_ERR_OK));
870 for (auto &val : testList) {
871 server_->status_ = val;
872 int32_t ret = server_->GetInputFormat(validFormat_);
873 EXPECT_EQ(ret, AVCS_ERR_OK) << "state: " << val << "\n";
874 }
875 }
876
877 /**
878 * @tc.name: GetInputFormat_Invalid_Test_001
879 * @tc.desc: GetInputFormat in invalid state
880 */
881 HWTEST_F(CodecServerUnitTest, GetInputFormat_Invalid_Test_001, TestSize.Level1)
882 {
883 std::vector<CodecServer::CodecStatus> testList = {
884 CodecServer::CodecStatus::INITIALIZED,
885 CodecServer::CodecStatus::UNINITIALIZED,
886 CodecServer::CodecStatus::ERROR,
887 };
888 CreateHCodecByMime();
889 for (auto &val : testList) {
890 server_->status_ = val;
891 int32_t ret = server_->GetInputFormat(validFormat_);
892 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE) << "state: " << val << "\n";
893 }
894 }
895
896 /**
897 * @tc.name: GetInputFormat_Invalid_Test_002
898 * @tc.desc: GetInputFormat with codecBase is nullptr
899 */
900 HWTEST_F(CodecServerUnitTest, GetInputFormat_Invalid_Test_002, TestSize.Level1)
901 {
902 std::vector<CodecServer::CodecStatus> testList = {
903 CodecServer::CodecStatus::CONFIGURED,
904 CodecServer::CodecStatus::RUNNING,
905 CodecServer::CodecStatus::FLUSHED,
906 CodecServer::CodecStatus::END_OF_STREAM,
907 };
908 CreateHCodecByMime();
909 server_->codecBase_ = nullptr;
910 for (auto &val : testList) {
911 server_->status_ = val;
912 int32_t ret = server_->GetInputFormat(validFormat_);
913 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY) << "state: " << val << "\n";
914 }
915 }
916
917 /**
918 * @tc.name: OnOutputFormatChanged_Valid_Test_001
919 * @tc.desc: OnOutputFormatChanged videoCb_ is not nullptr
920 */
921 HWTEST_F(CodecServerUnitTest, OnOutputFormatChanged_Valid_Test_001, TestSize.Level1)
922 {
923 CreateHCodecByMime();
924 auto mock = std::make_shared<MediaCodecCallbackMock>();
925 server_->videoCb_ = mock;
926 EXPECT_CALL(*mock, OnOutputFormatChanged).Times(1);
927 server_->OnOutputFormatChanged(validFormat_);
928 server_->videoCb_ = nullptr;
929 }
930
931 /**
932 * @tc.name: OnOutputFormatChanged_Valid_Test_002
933 * @tc.desc: OnOutputFormatChanged codecCb_ is not nullptr, videoCb_ is nullptr
934 */
935 HWTEST_F(CodecServerUnitTest, OnOutputFormatChanged_Valid_Test_002, TestSize.Level1)
936 {
937 CreateHCodecByMime();
938 server_->videoCb_ = nullptr;
939 auto mock = std::make_shared<AVCodecCallbackMock>();
940 server_->codecCb_ = mock;
941 EXPECT_CALL(*mock, OnOutputFormatChanged).Times(1);
942 server_->OnOutputFormatChanged(validFormat_);
943 server_->codecCb_ = nullptr;
944 }
945
CreateAVSharedMemory(const int32_t size)946 std::shared_ptr<AVSharedMemory> CreateAVSharedMemory(const int32_t size)
947 {
948 return AVSharedMemoryBase::CreateFromLocal(size,
949 AVSharedMemory::Flags::FLAGS_READ_WRITE,
950 "buffer_converter_test");
951 }
952
953 /**
954 * @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_001
955 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is not nullptr
956 * 2. isCreateSurface_ is false
957 * 3. isSetParameterCb_ is true
958 */
959 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_001, TestSize.Level1)
960 {
961 auto mock = std::make_shared<AVCodecCallbackMock>();
962 server_->codecCb_ = mock;
963 server_->isCreateSurface_ = false;
964 server_->isSetParameterCb_ = true;
965 uint32_t index = 1;
966 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
967 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
968 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(1);
969 server_->OnInputBufferAvailable(index, buffer);
970 server_->codecCb_ = nullptr;
971 }
972
973 /**
974 * @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_002
975 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is not nullptr
976 * 2. isCreateSurface_ is false
977 * 3. isSetParameterCb_ is false
978 */
979 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_002, TestSize.Level1)
980 {
981 CreateHCodecByMime();
982 auto mock = std::make_shared<AVCodecCallbackMock>();
983 server_->codecCb_ = mock;
984 server_->isCreateSurface_ = false;
985 server_->isSetParameterCb_ = false;
986 uint32_t index = 1;
987 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
988 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
989 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(1);
990 server_->OnInputBufferAvailable(index, buffer);
991 server_->codecCb_ = nullptr;
992 }
993
994 /**
995 * @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_003
996 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is not nullptr
997 * 2. isCreateSurface_ is true
998 * 3. isSetParameterCb_ is false
999 */
1000 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_003, TestSize.Level1)
1001 {
1002 CreateHCodecByMime();
1003 auto mock = std::make_shared<AVCodecCallbackMock>();
1004 server_->codecCb_ = mock;
1005 server_->isCreateSurface_ = true;
1006 server_->isSetParameterCb_ = false;
1007 uint32_t index = 1;
1008 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
1009 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
1010 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(0);
1011 server_->OnInputBufferAvailable(index, buffer);
1012 server_->codecCb_ = nullptr;
1013 }
1014
1015 /**
1016 * @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_004
1017 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is not nullptr
1018 * 2. isCreateSurface_ is true
1019 * 3. isSetParameterCb_ is true
1020 */
1021 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_004, TestSize.Level1)
1022 {
1023 CreateHCodecByMime();
1024 auto mock = std::make_shared<AVCodecCallbackMock>();
1025 server_->codecCb_ = mock;
1026 server_->isCreateSurface_ = true;
1027 server_->isSetParameterCb_ = true;
1028 uint32_t index = 1;
1029 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
1030 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
1031 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(1);
1032 server_->OnInputBufferAvailable(index, buffer);
1033 server_->codecCb_ = nullptr;
1034 }
1035
1036 /**
1037 * @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_005
1038 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is nullptr
1039 * 2. isCreateSurface_ is true
1040 * 3. isSetParameterCb_ is false
1041 */
1042 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_005, TestSize.Level1)
1043 {
1044 CreateHCodecByMime();
1045 auto mock = std::make_shared<AVCodecCallbackMock>();
1046 server_->codecCb_ = nullptr;
1047 server_->isCreateSurface_ = true;
1048 server_->isSetParameterCb_ = false;
1049 uint32_t index = 1;
1050 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
1051 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
1052 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(0);
1053 server_->OnInputBufferAvailable(index, buffer);
1054 }
1055
1056 /**
1057 * @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_006
1058 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is nullptr
1059 * 2. isCreateSurface_ is true
1060 * 3. isSetParameterCb_ is true
1061 */
1062 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_006, TestSize.Level1)
1063 {
1064 CreateHCodecByMime();
1065 auto mock = std::make_shared<AVCodecCallbackMock>();
1066 server_->codecCb_ = nullptr;
1067 server_->isCreateSurface_ = true;
1068 server_->isSetParameterCb_ = true;
1069 uint32_t index = 1;
1070 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
1071 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
1072 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(0);
1073 server_->OnInputBufferAvailable(index, buffer);
1074 }
1075
1076 /* @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_007
1077 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is nullptr
1078 * 2. isCreateSurface_ is false
1079 * 3. isSetParameterCb_ is true
1080 */
1081 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_007, TestSize.Level1)
1082 {
1083 CreateHCodecByMime();
1084 auto mock = std::make_shared<AVCodecCallbackMock>();
1085 server_->codecCb_ = nullptr;
1086 server_->isCreateSurface_ = false;
1087 server_->isSetParameterCb_ = true;
1088 uint32_t index = 1;
1089 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
1090 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
1091 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(0);
1092 server_->OnInputBufferAvailable(index, buffer);
1093 }
1094
1095 /**
1096 * @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_008
1097 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is nullptr
1098 * 2. isCreateSurface_ is false
1099 * 3. isSetParameterCb_ is false
1100 */
1101 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_008, TestSize.Level1)
1102 {
1103 CreateHCodecByMime();
1104 auto mock = std::make_shared<AVCodecCallbackMock>();
1105 server_->codecCb_ = nullptr;
1106 server_->isCreateSurface_ = false;
1107 server_->isSetParameterCb_ = false;
1108 uint32_t index = 1;
1109 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
1110 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
1111 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(0);
1112 server_->OnInputBufferAvailable(index, buffer);
1113 }
1114
1115 /**
1116 * @tc.name: OnError_Valid_Test_001
1117 * @tc.desc: VCodecBaseCallback OnError test
1118 */
1119 HWTEST_F(CodecServerUnitTest, OnError_Valid_Test_001, TestSize.Level1)
1120 {
1121 CreateHCodecByMime();
1122 auto codecBaseCallback = std::make_shared<VCodecBaseCallback>(server_);
1123 AVCodecErrorType errorType = AVCODEC_ERROR_INTERNAL;
1124 int32_t errorCode = AVCS_ERR_OK;
1125 codecBaseCallback->OnError(errorType, errorCode);
1126 }
1127
1128 /**
1129 * @tc.name: DumpInfo_Valid_Test_001
1130 * @tc.desc: DumpInfo codec type is video
1131 */
1132 HWTEST_F(CodecServerUnitTest, DumpInfo_Valid_Test_001, TestSize.Level1)
1133 {
1134 CreateHCodecByMime();
1135 server_->forwardCaller_.processName = "DumpInfo_Valid_Test_001";
1136 int32_t fileFd = 0;
1137
1138 EXPECT_CALL(*codecBaseMock_, GetOutputFormat()).Times(1).WillOnce(Return(AVCS_ERR_OK));
1139 EXPECT_CALL(*codecBaseMock_, GetHidumperInfo()).Times(1);
1140 int32_t ret = server_->DumpInfo(fileFd);
1141 EXPECT_EQ(ret, AVCS_ERR_OK);
1142 }
1143
1144 /**
1145 * @tc.name: DrmVideoCencDecrypt_Test_001
1146 * @tc.desc: DrmVideoCencDecrypt function test
1147 * @tc.type: FUNC
1148 */
1149 HWTEST_F(CodecServerUnitTest, DrmVideoCencDecrypt_Test_001, TestSize.Level1)
1150 {
1151 CreateHCodecByMime();
1152 auto mock = std::make_shared<MediaCodecCallbackMock>();
1153 server_->videoCb_ = mock;
1154 server_->isCreateSurface_ = true;
1155 server_->isSetParameterCb_ = true;
1156 server_->drmDecryptor_ = std::make_shared<CodecDrmDecrypt>();
1157 uint32_t index = 0;
1158 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
1159 MemoryFlag memFlag = MEMORY_READ_WRITE;
1160 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(memFlag);
1161 if (avAllocator != nullptr) {
1162 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(avAllocator, testSize);
1163 buffer->memory_->SetSize(testSize - 1);
1164 server_->OnInputBufferAvailable(index, buffer);
1165 int32_t ret = server_->DrmVideoCencDecrypt(index);
1166 EXPECT_EQ(ret, AVCS_ERR_OK);
1167 server_->OnInputBufferAvailable(index, buffer);
1168 ret = server_->DrmVideoCencDecrypt(index);
1169 EXPECT_EQ(ret, AVCS_ERR_OK);
1170 }
1171 }
1172
1173 /**
1174 * @tc.name: NotifyBackGround_Valid_Test_001
1175 * @tc.desc: NotifyBackGround valid progress
1176 */
1177 HWTEST_F(CodecServerUnitTest, NotifyBackGround_Valid_Test_001, TestSize.Level1)
1178 {
1179 CreateHCodecByMime();
1180 server_->isModeConfirmed_ = true;
1181
1182 std::vector<CodecServer::CodecStatus> testList = {
1183 CodecServer::CodecStatus::RUNNING,
1184 CodecServer::CodecStatus::END_OF_STREAM,
1185 CodecServer::CodecStatus::FLUSHED,
1186 };
1187
1188 for (auto &val : testList) {
1189 server_->status_ = val;
1190 EXPECT_EQ(AVCS_ERR_OK, server_->NotifyMemoryRecycle());
1191 }
1192 }
1193
1194 /**
1195 * @tc.name: NotifyBackGround_Invalid_Test_001
1196 * @tc.desc: NotifyBackGround invalid progress - wrong status of codec
1197 */
1198 HWTEST_F(CodecServerUnitTest, NotifyBackGround_Invalid_Test_001, TestSize.Level1)
1199 {
1200 CreateHCodecByMime();
1201 server_->isModeConfirmed_ = true;
1202
1203 std::vector<CodecServer::CodecStatus> testList = {
1204 CodecServer::CodecStatus::INITIALIZED,
1205 CodecServer::CodecStatus::UNINITIALIZED,
1206 CodecServer::CodecStatus::ERROR,
1207 };
1208
1209 for (auto &val : testList) {
1210 server_->status_ = val;
1211 EXPECT_NE(AVCS_ERR_OK, server_->NotifyMemoryRecycle());
1212 }
1213 }
1214
1215 /**
1216 * @tc.name: NotifyForeGround_Valid_Test_001
1217 * @tc.desc: NotifyForeGround valid progress
1218 */
1219 HWTEST_F(CodecServerUnitTest, NotifyForeGround_Valid_Test_001, TestSize.Level1)
1220 {
1221 CreateHCodecByMime();
1222 server_->isModeConfirmed_ = true;
1223 EXPECT_EQ(AVCS_ERR_OK, server_->NotifyMemoryWriteBack());
1224 }
1225
1226 /**
1227 * @tc.name: MergeFormat_Valid_Test_001
1228 * @tc.desc: MergeFormat format key type FORMAT_TYPE_INT32
1229 */
1230 HWTEST_F(CodecParamCheckerTest, MergeFormat_Valid_Test_001, TestSize.Level1)
1231 {
1232 Format format;
1233 Format oldFormat;
1234 constexpr int32_t quality = 10;
1235 format.PutIntValue(MediaDescriptionKey::MD_KEY_QUALITY, quality);
1236
1237 CodecParamChecker codecParamChecker;
1238 codecParamChecker.MergeFormat(format, oldFormat);
1239
1240 int32_t oldFormatQuality = 0;
1241 bool ret = oldFormat.GetIntValue(MediaDescriptionKey::MD_KEY_QUALITY, oldFormatQuality);
1242 EXPECT_TRUE(ret);
1243 EXPECT_EQ(oldFormatQuality, quality);
1244
1245 format = Format();
1246 oldFormat = Format();
1247 }
1248
1249 /**
1250 * @tc.name: MergeFormat_Valid_Test_002
1251 * @tc.desc: MergeFormat format key type FORMAT_TYPE_INT64
1252 */
1253 HWTEST_F(CodecParamCheckerTest, MergeFormat_Valid_Test_002, TestSize.Level1)
1254 {
1255 Format format;
1256 Format oldFormat;
1257 constexpr int64_t bitrate = 300000;
1258 format.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, bitrate);
1259
1260 CodecParamChecker codecParamChecker;
1261 codecParamChecker.MergeFormat(format, oldFormat);
1262
1263 int64_t oldFormatBitrate = 0;
1264 bool ret = oldFormat.GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, oldFormatBitrate);
1265 EXPECT_TRUE(ret);
1266 EXPECT_EQ(oldFormatBitrate, bitrate);
1267
1268 format = Format();
1269 oldFormat = Format();
1270 }
1271
1272 /**
1273 * @tc.name: MergeFormat_Valid_Test_003
1274 * @tc.desc: MergeFormat format key type FORMAT_TYPE_DOUBLE
1275 */
1276 HWTEST_F(CodecParamCheckerTest, MergeFormat_Valid_Test_003, TestSize.Level1)
1277 {
1278 Format format;
1279 Format oldFormat;
1280 constexpr double framRate = 30.0;
1281 format.PutDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, framRate);
1282
1283 CodecParamChecker codecParamChecker;
1284 codecParamChecker.MergeFormat(format, oldFormat);
1285
1286 double oldFormatFramRate = 0;
1287 bool ret = oldFormat.GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, oldFormatFramRate);
1288 EXPECT_TRUE(ret);
1289 EXPECT_EQ(oldFormatFramRate, framRate);
1290
1291 format = Format();
1292 oldFormat = Format();
1293 }
1294 } // MediaAVCodec
1295 } // namespace