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