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 "i_keysession_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 sptr<Rosen::WindowOption> option = new Rosen::WindowOption();
516 option->SetWindowRect({0, 0, 1280, 1000}); // 1280: width, 1000: height
517 option->SetWindowType(Rosen::WindowType::WINDOW_TYPE_APP_LAUNCHING);
518 option->SetWindowMode(Rosen::WindowMode::WINDOW_MODE_FLOATING);
519 auto window = Rosen::Window::Create("vcodec_unittest", option);
520 if (window == nullptr || window->GetSurfaceNode() == nullptr) {
521 std::cout << "Fatal: Create window fail" << std::endl;
522 return nullptr;
523 }
524 window->Show();
525 return window->GetSurfaceNode()->GetSurface();
526 }
527
528 /**
529 * @tc.name: CreateInputSurface_Valid_Test_001
530 * @tc.desc: codec CreateInputSurface in valid state
531 */
532 HWTEST_F(CodecServerUnitTest, CreateInputSurface_Valid_Test_001, TestSize.Level1)
533 {
534 CreateHCodecByMime();
535 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
536 sptr<Surface> surface = CreateSurface();
537 if (surface != nullptr) {
538 EXPECT_CALL(*codecBaseMock_, CreateInputSurface()).Times(1).WillOnce(Return(surface));
539 sptr<Surface> ret = server_->CreateInputSurface();
540 EXPECT_EQ(ret, surface);
541 }
542 }
543
544 /**
545 * @tc.name: CreateInputSurface_Invalid_Test_001
546 * @tc.desc: CreateInputSurface in invalid state
547 */
548 HWTEST_F(CodecServerUnitTest, CreateInputSurface_Invalid_Test_001, TestSize.Level1)
549 {
550 std::vector<CodecServer::CodecStatus> testList = {
551 CodecServer::CodecStatus::INITIALIZED, CodecServer::CodecStatus::UNINITIALIZED,
552 CodecServer::CodecStatus::RUNNING, CodecServer::CodecStatus::END_OF_STREAM,
553 CodecServer::CodecStatus::ERROR, CodecServer::CodecStatus::FLUSHED,
554 };
555 CreateHCodecByMime();
556
557 for (auto &val : testList) {
558 server_->status_ = val;
559 sptr<Surface> ret = server_->CreateInputSurface();
560 EXPECT_EQ(ret, nullptr) << "state: " << val << "\n";
561 }
562 }
563
564 /**
565 * @tc.name: CreateInputSurface_Invalid_Test_002
566 * @tc.desc: CreateInputSurface with codecBase is nullptr
567 */
568 HWTEST_F(CodecServerUnitTest, CreateInputSurface_Invalid_Test_002, TestSize.Level1)
569 {
570 CreateHCodecByMime();
571 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
572 server_->codecBase_ = nullptr;
573 sptr<Surface> ret = server_->CreateInputSurface();
574 EXPECT_EQ(ret, nullptr);
575 }
576
577 /**
578 * @tc.name: SetInputSurface_Valid_Test_001
579 * @tc.desc: codec SetInputSurface
580 */
581 HWTEST_F(CodecServerUnitTest, SetInputSurface_Valid_Test_001, TestSize.Level1)
582 {
583 CreateHCodecByMime();
584 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
585 sptr<Surface> surface = CreateSurface();
586 if (surface != nullptr) {
587 EXPECT_CALL(*codecBaseMock_, SetInputSurface(surface)).Times(1).WillOnce(Return(AVCS_ERR_OK));
588 int32_t ret = server_->SetInputSurface(surface);
589 EXPECT_EQ(ret, AVCS_ERR_OK);
590 }
591 }
592
593 /**
594 * @tc.name: SetInputSurface_Valid_Test_002
595 * @tc.desc: codec SetInputSurface
596 */
597 HWTEST_F(CodecServerUnitTest, SetInputSurface_Valid_Test_002, TestSize.Level1)
598 {
599 CreateHCodecByMime();
600 server_->isModeConfirmed_ = false;
601 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
602 sptr<Surface> surface = CreateSurface();
603 if (surface != nullptr) {
604 EXPECT_CALL(*codecBaseMock_, SetInputSurface(surface)).Times(1).WillOnce(Return(AVCS_ERR_OK));
605 int32_t ret = server_->SetInputSurface(surface);
606 EXPECT_EQ(ret, AVCS_ERR_OK);
607 }
608 }
609
610 /**
611 * @tc.name: SetInputSurface_Invalid_Test_001
612 * @tc.desc: SetInputSurface in invalid state
613 */
614 HWTEST_F(CodecServerUnitTest, SetInputSurface_Invalid_Test_001, TestSize.Level1)
615 {
616 std::vector<CodecServer::CodecStatus> testList = {
617 CodecServer::CodecStatus::INITIALIZED, CodecServer::CodecStatus::UNINITIALIZED,
618 CodecServer::CodecStatus::RUNNING, CodecServer::CodecStatus::END_OF_STREAM,
619 CodecServer::CodecStatus::ERROR, CodecServer::CodecStatus::FLUSHED,
620 };
621 CreateHCodecByMime();
622
623 sptr<Surface> surface = CreateSurface();
624 if (surface != nullptr) {
625 for (auto &val : testList) {
626 server_->status_ = val;
627 int32_t ret = server_->SetInputSurface(surface);
628 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE) << "state: " << val << "\n";
629 }
630 }
631 }
632
633 /**
634 * @tc.name: SetInputSurface_Invalid_Test_002
635 * @tc.desc: SetInputSurface with codecBase is nullptr
636 */
637 HWTEST_F(CodecServerUnitTest, SetInputSurface_Invalid_Test_002, TestSize.Level1)
638 {
639 CreateHCodecByMime();
640 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
641 server_->codecBase_ = nullptr;
642 sptr<Surface> surface = CreateSurface();
643 if (surface != nullptr) {
644 int32_t ret = server_->SetInputSurface(surface);
645 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
646 }
647 }
648
649 /**
650 * @tc.name: SetOutputSurface_Valid_Test_001
651 * @tc.desc: codec SetOutputSurface
652 */
653 HWTEST_F(CodecServerUnitTest, SetOutputSurface_Valid_Test_001, TestSize.Level1)
654 {
655 CreateHCodecByMime();
656 server_->isModeConfirmed_ = true;
657 server_->isSurfaceMode_ = true;
658
659 std::vector<CodecServer::CodecStatus> testList = {
660 CodecServer::CodecStatus::CONFIGURED, CodecServer::CodecStatus::FLUSHED,
661 CodecServer::CodecStatus::RUNNING, CodecServer::CodecStatus::END_OF_STREAM,
662 };
663 sptr<Surface> surface = CreateSurface();
664 if (surface != nullptr) {
665 EXPECT_CALL(*codecBaseMock_, SetOutputSurface(surface))
666 .Times(testList.size())
667 .WillRepeatedly(Return(AVCS_ERR_OK));
668
669 for (auto &val : testList) {
670 server_->status_ = val;
671 int32_t ret = server_->SetOutputSurface(surface);
672 EXPECT_EQ(ret, AVCS_ERR_OK) << "state: " << val << "\n";
673 }
674 }
675 }
676
677 /**
678 * @tc.name: SetOutputSurface_Valid_Test_002
679 * @tc.desc: codec SetOutputSurface
680 */
681 HWTEST_F(CodecServerUnitTest, SetOutputSurface_Valid_Test_002, TestSize.Level1)
682 {
683 CreateHCodecByMime();
684 server_->isModeConfirmed_ = false;
685 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
686 sptr<Surface> surface = CreateSurface();
687 if (surface != nullptr) {
688 EXPECT_CALL(*codecBaseMock_, SetOutputSurface(surface)).Times(1).WillOnce(Return(AVCS_ERR_OK));
689 int32_t ret = server_->SetOutputSurface(surface);
690 EXPECT_EQ(ret, AVCS_ERR_OK);
691 }
692 }
693
694 /**
695 * @tc.name: SetOutputSurface_Valid_Test_003
696 * @tc.desc: codec SetOutputSurface
697 */
698 HWTEST_F(CodecServerUnitTest, SetOutputSurface_Valid_Test_003, TestSize.Level1)
699 {
700 CreateHCodecByMime();
701 server_->postProcessing_ = std::make_unique<CodecServer::PostProcessingType>(server_->codecBase_);
702 server_->isModeConfirmed_ = false;
703 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
704 sptr<Surface> surface = CreateSurface();
705 if (surface != nullptr) {
706 EXPECT_CALL(*codecBaseMock_, SetOutputSurface(surface)).Times(1).WillOnce(Return(AVCS_ERR_OK));
707 int32_t ret = server_->SetOutputSurface(surface);
708 EXPECT_EQ(ret, AVCS_ERR_OK);
709 }
710 }
711
712 /**
713 * @tc.name: SetOutputSurface_Invalid_Test_001
714 * @tc.desc: SetOutputSurface in invalid mode
715 */
716 HWTEST_F(CodecServerUnitTest, SetOutputSurface_Invalid_Test_001, TestSize.Level1)
717 {
718 CreateHCodecByMime();
719 server_->isModeConfirmed_ = true;
720 server_->isSurfaceMode_ = false;
721 sptr<Surface> surface = CreateSurface();
722 if (surface != nullptr) {
723 int32_t ret = server_->SetOutputSurface(surface);
724 EXPECT_EQ(ret, AVCS_ERR_INVALID_OPERATION);
725 }
726 }
727
728 /**
729 * @tc.name: SetOutputSurface_Invalid_Test_002
730 * @tc.desc: SetOutputSurface in invalid state
731 */
732 HWTEST_F(CodecServerUnitTest, SetOutputSurface_Invalid_Test_002, TestSize.Level1)
733 {
734 CreateHCodecByMime();
735 server_->isModeConfirmed_ = true;
736 server_->isSurfaceMode_ = true;
737 std::vector<CodecServer::CodecStatus> testList = {
738 CodecServer::CodecStatus::INITIALIZED,
739 CodecServer::CodecStatus::UNINITIALIZED,
740 CodecServer::CodecStatus::ERROR,
741 };
742
743 sptr<Surface> surface = CreateSurface();
744 if (surface != nullptr) {
745 int32_t ret = server_->SetOutputSurface(surface);
746 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE);
747 }
748 }
749
750 /**
751 * @tc.name: SetOutputSurface_Invalid_Test_003
752 * @tc.desc: SetOutputSurface in invalid state
753 */
754 HWTEST_F(CodecServerUnitTest, SetOutputSurface_Invalid_Test_003, TestSize.Level1)
755 {
756 CreateHCodecByMime();
757 server_->isModeConfirmed_ = false;
758 std::vector<CodecServer::CodecStatus> testList = {
759 CodecServer::CodecStatus::INITIALIZED, CodecServer::CodecStatus::UNINITIALIZED,
760 CodecServer::CodecStatus::RUNNING, CodecServer::CodecStatus::END_OF_STREAM,
761 CodecServer::CodecStatus::ERROR, CodecServer::CodecStatus::FLUSHED,
762 };
763
764 sptr<Surface> surface = CreateSurface();
765 if (surface != nullptr) {
766 for (auto &val : testList) {
767 server_->status_ = val;
768 int32_t ret = server_->SetOutputSurface(surface);
769 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE) << "state: " << val << "\n";
770 }
771 }
772 }
773
774 /**
775 * @tc.name: SetOutputSurface_Invalid_Test_004
776 * @tc.desc: SetInputSurface with codecBase is nullptr
777 */
778 HWTEST_F(CodecServerUnitTest, SetOutputSurface_Invalid_Test_004, TestSize.Level1)
779 {
780 CreateHCodecByMime();
781 server_->isModeConfirmed_ = false;
782 server_->status_ = CodecServer::CodecStatus::CONFIGURED;
783 server_->codecBase_ = nullptr;
784 sptr<Surface> surface = CreateSurface();
785 if (surface != nullptr) {
786 int32_t ret = server_->SetOutputSurface(surface);
787 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
788 }
789 }
790
791 /**
792 * @tc.name: QueueInputBuffer_Invalid_Test_001
793 * @tc.desc: QueueInputBuffer in invalid state
794 */
795 HWTEST_F(CodecServerUnitTest, QueueInputBuffer_Invalid_Test_001, TestSize.Level1)
796 {
797 CreateHCodecByMime();
798 uint32_t index = 1;
799 int32_t ret = server_->QueueInputBuffer(index);
800 EXPECT_EQ(ret, AVCS_ERR_UNSUPPORT);
801 }
802
803 /**
804 * @tc.name: QueueInputParameter_Invalid_Test_001
805 * @tc.desc: QueueInputParameter in invalid state
806 */
807 HWTEST_F(CodecServerUnitTest, QueueInputParameter_Invalid_Test_001, TestSize.Level1)
808 {
809 CreateHCodecByMime();
810 uint32_t index = 1;
811 int32_t ret = server_->QueueInputParameter(index);
812 EXPECT_EQ(ret, AVCS_ERR_UNSUPPORT);
813 }
814
815 /**
816 * @tc.name: GetOutputFormat_Valid_Test_001
817 * @tc.desc: codec GetOutputFormat
818 */
819 HWTEST_F(CodecServerUnitTest, GetOutputFormat_Valid_Test_001, TestSize.Level1)
820 {
821 CreateHCodecByMime();
822 server_->status_ = CodecServer::CodecStatus::UNINITIALIZED;
823 int32_t ret = server_->GetOutputFormat(validFormat_);
824 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE);
825 }
826
827 /**
828 * @tc.name: GetOutputFormat_Invalid_Test_001
829 * @tc.desc: GetOutputFormat in invalid state
830 */
831 HWTEST_F(CodecServerUnitTest, GetOutputFormat_Invalid_Test_001, TestSize.Level1)
832 {
833 std::vector<CodecServer::CodecStatus> testList = {
834 CodecServer::CodecStatus::INITIALIZED, CodecServer::CodecStatus::CONFIGURED,
835 CodecServer::CodecStatus::RUNNING, CodecServer::CodecStatus::END_OF_STREAM,
836 CodecServer::CodecStatus::ERROR, CodecServer::CodecStatus::FLUSHED,
837 };
838 CreateHCodecByMime();
839
840 EXPECT_CALL(*codecBaseMock_, GetOutputFormat())
841 .Times(testList.size())
842 .WillRepeatedly(Return(AVCS_ERR_OK));
843
844 for (auto &val : testList) {
845 server_->status_ = val;
846 int32_t ret = server_->GetOutputFormat(validFormat_);
847 EXPECT_EQ(ret, AVCS_ERR_OK) << "state: " << val << "\n";
848 }
849 }
850
851 /**
852 * @tc.name: GetOutputFormat_Invalid_Test_002
853 * @tc.desc: GetOutputFormat with codecBase is nullptr
854 */
855 HWTEST_F(CodecServerUnitTest, GetOutputFormat_Invalid_Test_002, TestSize.Level1)
856 {
857 CreateHCodecByMime();
858 server_->status_ = CodecServer::CodecStatus::RUNNING;
859 server_->codecBase_ = nullptr;
860 int32_t ret = server_->GetOutputFormat(validFormat_);
861 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY);
862 }
863
864 /**
865 * @tc.name: GetInputFormat_Valid_Test_001
866 * @tc.desc: codec GetInputFormat in valid state
867 */
868 HWTEST_F(CodecServerUnitTest, GetInputFormat_Valid_Test_001, TestSize.Level1)
869 {
870 CreateHCodecByMime();
871 std::vector<CodecServer::CodecStatus> testList = {
872 CodecServer::CodecStatus::CONFIGURED,
873 CodecServer::CodecStatus::RUNNING,
874 CodecServer::CodecStatus::FLUSHED,
875 CodecServer::CodecStatus::END_OF_STREAM,
876 };
877
878 EXPECT_CALL(*codecBaseMock_, GetInputFormat).Times(testList.size()).WillRepeatedly(Return(AVCS_ERR_OK));
879 for (auto &val : testList) {
880 server_->status_ = val;
881 int32_t ret = server_->GetInputFormat(validFormat_);
882 EXPECT_EQ(ret, AVCS_ERR_OK) << "state: " << val << "\n";
883 }
884 }
885
886 /**
887 * @tc.name: GetInputFormat_Invalid_Test_001
888 * @tc.desc: GetInputFormat in invalid state
889 */
890 HWTEST_F(CodecServerUnitTest, GetInputFormat_Invalid_Test_001, TestSize.Level1)
891 {
892 std::vector<CodecServer::CodecStatus> testList = {
893 CodecServer::CodecStatus::INITIALIZED,
894 CodecServer::CodecStatus::UNINITIALIZED,
895 CodecServer::CodecStatus::ERROR,
896 };
897 CreateHCodecByMime();
898 for (auto &val : testList) {
899 server_->status_ = val;
900 int32_t ret = server_->GetInputFormat(validFormat_);
901 EXPECT_EQ(ret, AVCS_ERR_INVALID_STATE) << "state: " << val << "\n";
902 }
903 }
904
905 /**
906 * @tc.name: GetInputFormat_Invalid_Test_002
907 * @tc.desc: GetInputFormat with codecBase is nullptr
908 */
909 HWTEST_F(CodecServerUnitTest, GetInputFormat_Invalid_Test_002, TestSize.Level1)
910 {
911 std::vector<CodecServer::CodecStatus> testList = {
912 CodecServer::CodecStatus::CONFIGURED,
913 CodecServer::CodecStatus::RUNNING,
914 CodecServer::CodecStatus::FLUSHED,
915 CodecServer::CodecStatus::END_OF_STREAM,
916 };
917 CreateHCodecByMime();
918 server_->codecBase_ = nullptr;
919 for (auto &val : testList) {
920 server_->status_ = val;
921 int32_t ret = server_->GetInputFormat(validFormat_);
922 EXPECT_EQ(ret, AVCS_ERR_NO_MEMORY) << "state: " << val << "\n";
923 }
924 }
925
926 /**
927 * @tc.name: OnOutputFormatChanged_Valid_Test_001
928 * @tc.desc: OnOutputFormatChanged videoCb_ is not nullptr
929 */
930 HWTEST_F(CodecServerUnitTest, OnOutputFormatChanged_Valid_Test_001, TestSize.Level1)
931 {
932 CreateHCodecByMime();
933 auto mock = std::make_shared<MediaCodecCallbackMock>();
934 server_->videoCb_ = mock;
935 EXPECT_CALL(*mock, OnOutputFormatChanged).Times(1);
936 server_->OnOutputFormatChanged(validFormat_);
937 server_->videoCb_ = nullptr;
938 }
939
940 /**
941 * @tc.name: OnOutputFormatChanged_Valid_Test_002
942 * @tc.desc: OnOutputFormatChanged codecCb_ is not nullptr, videoCb_ is nullptr
943 */
944 HWTEST_F(CodecServerUnitTest, OnOutputFormatChanged_Valid_Test_002, TestSize.Level1)
945 {
946 CreateHCodecByMime();
947 server_->videoCb_ = nullptr;
948 auto mock = std::make_shared<AVCodecCallbackMock>();
949 server_->codecCb_ = mock;
950 EXPECT_CALL(*mock, OnOutputFormatChanged).Times(1);
951 server_->OnOutputFormatChanged(validFormat_);
952 server_->codecCb_ = nullptr;
953 }
954
CreateAVSharedMemory(const int32_t size)955 std::shared_ptr<AVSharedMemory> CreateAVSharedMemory(const int32_t size)
956 {
957 return AVSharedMemoryBase::CreateFromLocal(size,
958 AVSharedMemory::Flags::FLAGS_READ_WRITE,
959 "buffer_converter_test");
960 }
961
962 /**
963 * @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_001
964 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is not nullptr
965 * 2. isCreateSurface_ is false
966 * 3. isSetParameterCb_ is true
967 */
968 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_001, TestSize.Level1)
969 {
970 auto mock = std::make_shared<AVCodecCallbackMock>();
971 server_->codecCb_ = mock;
972 server_->isCreateSurface_ = false;
973 server_->isSetParameterCb_ = true;
974 uint32_t index = 1;
975 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
976 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
977 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(1);
978 server_->OnInputBufferAvailable(index, buffer);
979 server_->codecCb_ = nullptr;
980 }
981
982 /**
983 * @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_002
984 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is not nullptr
985 * 2. isCreateSurface_ is false
986 * 3. isSetParameterCb_ is false
987 */
988 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_002, TestSize.Level1)
989 {
990 CreateHCodecByMime();
991 auto mock = std::make_shared<AVCodecCallbackMock>();
992 server_->codecCb_ = mock;
993 server_->isCreateSurface_ = false;
994 server_->isSetParameterCb_ = false;
995 uint32_t index = 1;
996 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
997 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
998 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(1);
999 server_->OnInputBufferAvailable(index, buffer);
1000 server_->codecCb_ = nullptr;
1001 }
1002
1003 /**
1004 * @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_003
1005 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is not nullptr
1006 * 2. isCreateSurface_ is true
1007 * 3. isSetParameterCb_ is false
1008 */
1009 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_003, TestSize.Level1)
1010 {
1011 CreateHCodecByMime();
1012 auto mock = std::make_shared<AVCodecCallbackMock>();
1013 server_->codecCb_ = mock;
1014 server_->isCreateSurface_ = true;
1015 server_->isSetParameterCb_ = false;
1016 uint32_t index = 1;
1017 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
1018 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
1019 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(0);
1020 server_->OnInputBufferAvailable(index, buffer);
1021 server_->codecCb_ = nullptr;
1022 }
1023
1024 /**
1025 * @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_004
1026 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is not nullptr
1027 * 2. isCreateSurface_ is true
1028 * 3. isSetParameterCb_ is true
1029 */
1030 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_004, TestSize.Level1)
1031 {
1032 CreateHCodecByMime();
1033 auto mock = std::make_shared<AVCodecCallbackMock>();
1034 server_->codecCb_ = mock;
1035 server_->isCreateSurface_ = true;
1036 server_->isSetParameterCb_ = true;
1037 uint32_t index = 1;
1038 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
1039 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
1040 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(1);
1041 server_->OnInputBufferAvailable(index, buffer);
1042 server_->codecCb_ = nullptr;
1043 }
1044
1045 /**
1046 * @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_005
1047 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is nullptr
1048 * 2. isCreateSurface_ is true
1049 * 3. isSetParameterCb_ is false
1050 */
1051 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_005, TestSize.Level1)
1052 {
1053 CreateHCodecByMime();
1054 auto mock = std::make_shared<AVCodecCallbackMock>();
1055 server_->codecCb_ = nullptr;
1056 server_->isCreateSurface_ = true;
1057 server_->isSetParameterCb_ = false;
1058 uint32_t index = 1;
1059 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
1060 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
1061 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(0);
1062 server_->OnInputBufferAvailable(index, buffer);
1063 }
1064
1065 /**
1066 * @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_006
1067 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is nullptr
1068 * 2. isCreateSurface_ is true
1069 * 3. isSetParameterCb_ is true
1070 */
1071 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_006, TestSize.Level1)
1072 {
1073 CreateHCodecByMime();
1074 auto mock = std::make_shared<AVCodecCallbackMock>();
1075 server_->codecCb_ = nullptr;
1076 server_->isCreateSurface_ = true;
1077 server_->isSetParameterCb_ = true;
1078 uint32_t index = 1;
1079 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
1080 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
1081 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(0);
1082 server_->OnInputBufferAvailable(index, buffer);
1083 }
1084
1085 /* @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_007
1086 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is nullptr
1087 * 2. isCreateSurface_ is false
1088 * 3. isSetParameterCb_ is true
1089 */
1090 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_007, TestSize.Level1)
1091 {
1092 CreateHCodecByMime();
1093 auto mock = std::make_shared<AVCodecCallbackMock>();
1094 server_->codecCb_ = nullptr;
1095 server_->isCreateSurface_ = false;
1096 server_->isSetParameterCb_ = true;
1097 uint32_t index = 1;
1098 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
1099 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
1100 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(0);
1101 server_->OnInputBufferAvailable(index, buffer);
1102 }
1103
1104 /**
1105 * @tc.name: OnInputBufferAvailable_AVSharedMemory_Test_008
1106 * @tc.desc: 1. OnInputBufferAvailable codecCb_ is nullptr
1107 * 2. isCreateSurface_ is false
1108 * 3. isSetParameterCb_ is false
1109 */
1110 HWTEST_F(CodecServerUnitTest, OnInputBufferAvailable_AVSharedMemory_Test_008, TestSize.Level1)
1111 {
1112 CreateHCodecByMime();
1113 auto mock = std::make_shared<AVCodecCallbackMock>();
1114 server_->codecCb_ = nullptr;
1115 server_->isCreateSurface_ = false;
1116 server_->isSetParameterCb_ = false;
1117 uint32_t index = 1;
1118 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
1119 std::shared_ptr<AVSharedMemory> buffer = CreateAVSharedMemory(testSize);
1120 EXPECT_CALL(*mock, OnInputBufferAvailable).Times(0);
1121 server_->OnInputBufferAvailable(index, buffer);
1122 }
1123
1124 /**
1125 * @tc.name: OnError_Valid_Test_001
1126 * @tc.desc: VCodecBaseCallback OnError test
1127 */
1128 HWTEST_F(CodecServerUnitTest, OnError_Valid_Test_001, TestSize.Level1)
1129 {
1130 CreateHCodecByMime();
1131 auto codecBaseCallback = std::make_shared<VCodecBaseCallback>(server_);
1132 AVCodecErrorType errorType = AVCODEC_ERROR_INTERNAL;
1133 int32_t errorCode = AVCS_ERR_OK;
1134 codecBaseCallback->OnError(errorType, errorCode);
1135 EXPECT_EQ(errorCode, AVCS_ERR_OK);
1136 }
1137
1138 /**
1139 * @tc.name: DumpInfo_Valid_Test_001
1140 * @tc.desc: DumpInfo codec type is video
1141 */
1142 HWTEST_F(CodecServerUnitTest, DumpInfo_Valid_Test_001, TestSize.Level1)
1143 {
1144 CreateHCodecByMime();
1145 server_->forwardCaller_.processName = "DumpInfo_Valid_Test_001";
1146 int32_t fileFd = 0;
1147
1148 EXPECT_CALL(*codecBaseMock_, GetOutputFormat()).Times(1).WillOnce(Return(AVCS_ERR_OK));
1149 EXPECT_CALL(*codecBaseMock_, GetHidumperInfo()).Times(1);
1150 int32_t ret = server_->DumpInfo(fileFd);
1151 EXPECT_EQ(ret, AVCS_ERR_OK);
1152 }
1153
1154 /**
1155 * @tc.name: DrmVideoCencDecrypt_Test_001
1156 * @tc.desc: DrmVideoCencDecrypt function test
1157 * @tc.type: FUNC
1158 */
1159 HWTEST_F(CodecServerUnitTest, DrmVideoCencDecrypt_Test_001, TestSize.Level1)
1160 {
1161 CreateHCodecByMime();
1162 auto mock = std::make_shared<MediaCodecCallbackMock>();
1163 server_->videoCb_ = mock;
1164 server_->isCreateSurface_ = true;
1165 server_->isSetParameterCb_ = true;
1166 server_->drmDecryptor_ = std::make_shared<CodecDrmDecrypt>();
1167 uint32_t index = 0;
1168 int32_t testSize = DEFAULT_HEIGHT * DEFAULT_WIDTH * 3 / 2; // NV12 YUVI420
1169 MemoryFlag memFlag = MEMORY_READ_WRITE;
1170 std::shared_ptr<AVAllocator> avAllocator = AVAllocatorFactory::CreateSharedAllocator(memFlag);
1171 if (avAllocator != nullptr) {
1172 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(avAllocator, testSize);
1173 buffer->memory_->SetSize(testSize - 1);
1174 server_->OnInputBufferAvailable(index, buffer);
1175 int32_t ret = server_->DrmVideoCencDecrypt(index);
1176 EXPECT_EQ(ret, AVCS_ERR_OK);
1177 server_->OnInputBufferAvailable(index, buffer);
1178 ret = server_->DrmVideoCencDecrypt(index);
1179 EXPECT_EQ(ret, AVCS_ERR_OK);
1180 }
1181 }
1182
1183 /**
1184 * @tc.name: NotifyBackGround_Valid_Test_001
1185 * @tc.desc: NotifyBackGround valid progress
1186 */
1187 HWTEST_F(CodecServerUnitTest, NotifyBackGround_Valid_Test_001, TestSize.Level1)
1188 {
1189 CreateHCodecByMime();
1190 server_->isModeConfirmed_ = true;
1191
1192 std::vector<CodecServer::CodecStatus> testList = {
1193 CodecServer::CodecStatus::RUNNING,
1194 CodecServer::CodecStatus::END_OF_STREAM,
1195 CodecServer::CodecStatus::FLUSHED,
1196 };
1197
1198 for (auto &val : testList) {
1199 server_->status_ = val;
1200 server_->isFreezedFlag_ = false;
1201 server_->NotifyBackGround();
1202 EXPECT_TRUE(server_->isFreezedFlag_);
1203 }
1204 }
1205
1206 /**
1207 * @tc.name: NotifyBackGround_Invalid_Test_001
1208 * @tc.desc: NotifyBackGround invalid progress - wrong status of codec
1209 */
1210 HWTEST_F(CodecServerUnitTest, NotifyBackGround_Invalid_Test_001, TestSize.Level1)
1211 {
1212 CreateHCodecByMime();
1213 server_->isModeConfirmed_ = true;
1214
1215 std::vector<CodecServer::CodecStatus> testList = {
1216 CodecServer::CodecStatus::INITIALIZED,
1217 CodecServer::CodecStatus::UNINITIALIZED,
1218 CodecServer::CodecStatus::ERROR,
1219 };
1220
1221 for (auto &val : testList) {
1222 server_->status_ = val;
1223 server_->isFreezedFlag_ = false;
1224 server_->NotifyBackGround();
1225 EXPECT_FALSE(server_->isFreezedFlag_);
1226 }
1227 }
1228
1229 /**
1230 * @tc.name: NotifyForeGround_Valid_Test_001
1231 * @tc.desc: NotifyForeGround valid progress
1232 */
1233 HWTEST_F(CodecServerUnitTest, NotifyForeGround_Valid_Test_001, TestSize.Level1)
1234 {
1235 CreateHCodecByMime();
1236 server_->isModeConfirmed_ = true;
1237 server_->isFreezedFlag_ = true;
1238 server_->NotifyForeGround();
1239 EXPECT_FALSE(server_->isFreezedFlag_);
1240 }
1241
1242 /**
1243 * @tc.name: MergeFormat_Valid_Test_001
1244 * @tc.desc: MergeFormat format key type FORMAT_TYPE_INT32
1245 */
1246 HWTEST_F(CodecParamCheckerTest, MergeFormat_Valid_Test_001, TestSize.Level1)
1247 {
1248 Format format;
1249 Format oldFormat;
1250 constexpr int32_t quality = 10;
1251 format.PutIntValue(MediaDescriptionKey::MD_KEY_QUALITY, quality);
1252
1253 CodecParamChecker codecParamChecker;
1254 codecParamChecker.MergeFormat(format, oldFormat);
1255
1256 int32_t oldFormatQuality = 0;
1257 bool ret = oldFormat.GetIntValue(MediaDescriptionKey::MD_KEY_QUALITY, oldFormatQuality);
1258 EXPECT_TRUE(ret);
1259 EXPECT_EQ(oldFormatQuality, quality);
1260
1261 format = Format();
1262 oldFormat = Format();
1263 }
1264
1265 /**
1266 * @tc.name: MergeFormat_Valid_Test_002
1267 * @tc.desc: MergeFormat format key type FORMAT_TYPE_INT64
1268 */
1269 HWTEST_F(CodecParamCheckerTest, MergeFormat_Valid_Test_002, TestSize.Level1)
1270 {
1271 Format format;
1272 Format oldFormat;
1273 constexpr int64_t bitrate = 300000;
1274 format.PutLongValue(MediaDescriptionKey::MD_KEY_BITRATE, bitrate);
1275
1276 CodecParamChecker codecParamChecker;
1277 codecParamChecker.MergeFormat(format, oldFormat);
1278
1279 int64_t oldFormatBitrate = 0;
1280 bool ret = oldFormat.GetLongValue(MediaDescriptionKey::MD_KEY_BITRATE, oldFormatBitrate);
1281 EXPECT_TRUE(ret);
1282 EXPECT_EQ(oldFormatBitrate, bitrate);
1283
1284 format = Format();
1285 oldFormat = Format();
1286 }
1287
1288 /**
1289 * @tc.name: MergeFormat_Valid_Test_003
1290 * @tc.desc: MergeFormat format key type FORMAT_TYPE_DOUBLE
1291 */
1292 HWTEST_F(CodecParamCheckerTest, MergeFormat_Valid_Test_003, TestSize.Level1)
1293 {
1294 Format format;
1295 Format oldFormat;
1296 constexpr double framRate = 30.0;
1297 format.PutDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, framRate);
1298
1299 CodecParamChecker codecParamChecker;
1300 codecParamChecker.MergeFormat(format, oldFormat);
1301
1302 double oldFormatFramRate = 0;
1303 bool ret = oldFormat.GetDoubleValue(MediaDescriptionKey::MD_KEY_FRAME_RATE, oldFormatFramRate);
1304 EXPECT_TRUE(ret);
1305 EXPECT_EQ(oldFormatFramRate, framRate);
1306
1307 format = Format();;
1308 oldFormat = Format();
1309 }
1310 } // MediaAVCodec
1311 } // namespace