1 /*
2 * Copyright (c) 2025-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "camera_common_utils_unittest.h"
16
17 #include <chrono>
18 #include <gtest/gtest.h>
19 #include <thread>
20
21 #include "camera_dynamic_loader.h"
22 #include "camera_log.h"
23 #include "dp_log.h"
24 #include "camera_simple_timer.h"
25 #include "av_codec_proxy.h"
26 #include "av_codec_adapter.h"
27 #include "sample_info.h"
28 #include "image_source_proxy.h"
29 #include "media_manager_proxy.h"
30 #include "ipc_file_descriptor.h"
31 #include "moving_photo_proxy.h"
32 #include "camera_server_photo_proxy.h"
33 #include "picture_proxy.h"
34
35 using namespace OHOS::CameraStandard;
36 using namespace testing::ext;
37
38 namespace OHOS {
39 namespace CameraStandard {
40
41 constexpr uint32_t MAX_SOURCE_SIZE = 300 * 1024 * 1024;
42 constexpr int VIDEO_REQUEST_FD_ID = 1;
43 static const int64_t VIDEO_FRAMERATE = 1280;
44
SetUpTestCase(void)45 void CameraCommonUtilsUnitTest::SetUpTestCase(void)
46 {}
47
TearDownTestCase(void)48 void CameraCommonUtilsUnitTest::TearDownTestCase(void)
49 {}
50
SetUp(void)51 void CameraCommonUtilsUnitTest::SetUp(void)
52 {}
53
TearDown(void)54 void CameraCommonUtilsUnitTest::TearDown(void)
55 {}
56
57 class CoderCallback : public MediaCodecCallback {
58 public:
CoderCallback()59 CoderCallback() {}
~CoderCallback()60 ~CoderCallback() {}
OnError(MediaAVCodec::AVCodecErrorType errorType,int32_t errorCode)61 void OnError(MediaAVCodec::AVCodecErrorType errorType, int32_t errorCode) {}
OnOutputFormatChanged(const Format & format)62 void OnOutputFormatChanged(const Format &format) {}
OnInputBufferAvailable(uint32_t index,std::shared_ptr<AVBuffer> buffer)63 void OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer) {}
OnOutputBufferAvailable(uint32_t index,std::shared_ptr<AVBuffer> buffer)64 void OnOutputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer) {}
65 };
66
67 class AVSourceTest : public AVSource {
68 public:
AVSourceTest()69 AVSourceTest() {}
~AVSourceTest()70 ~AVSourceTest() {}
GetSourceFormat(OHOS::Media::Format & format)71 int32_t GetSourceFormat(OHOS::Media::Format &format)
72 {
73 return 0;
74 }
GetTrackFormat(OHOS::Media::Format & format,uint32_t trackIndex)75 int32_t GetTrackFormat(OHOS::Media::Format &format, uint32_t trackIndex)
76 {
77 return 0;
78 }
GetUserMeta(OHOS::Media::Format & format)79 int32_t GetUserMeta(OHOS::Media::Format &format)
80 {
81 return 0;
82 }
83 };
84
85 /*
86 * Feature: SimpleTimer
87 * Function: Test start task functionality
88 * SubFunction: NA
89 * FunctionPoints: NA
90 * EnvConditions: NA
91 * CaseDescription: Test starting a task normally. The first start should return true, and starting again while running
92 * should return false.
93 */
94 HWTEST_F(CameraCommonUtilsUnitTest, SimpleTimer_StartTask_Normal, TestSize.Level0)
95 {
__anon480971ce0102() 96 SimpleTimer timer([]() {});
97 EXPECT_TRUE(timer.StartTask(1000)); // First start, should return true
98 EXPECT_FALSE(timer.StartTask(1000)); // Already running, should return false
99 }
100
101 /*
102 * Feature: SimpleTimer
103 * Function: Test cancel task functionality
104 * SubFunction: NA
105 * FunctionPoints: NA
106 * EnvConditions: NA
107 * CaseDescription: Test canceling a task after starting it. The task should be canceled successfully.
108 */
109 HWTEST_F(CameraCommonUtilsUnitTest, SimpleTimer_StartTask_CancelAndRestart, TestSize.Level0)
110 {
__anon480971ce0202() 111 SimpleTimer timer([]() {});
112 EXPECT_TRUE(timer.StartTask(1000)); // Start the timer
113 EXPECT_TRUE(timer.CancelTask()); // Cancel the timer
114 EXPECT_TRUE(timer.StartTask(1000)); // Restart, should return true
115 }
116
117 /*
118 * Feature: SimpleTimer
119 * Function: Test cancel task functionality
120 * SubFunction: NA
121 * FunctionPoints: NA
122 * EnvConditions: NA
123 * CaseDescription: Test canceling a task normally. The task should be canceled successfully.
124 */
125 HWTEST_F(CameraCommonUtilsUnitTest, SimpleTimer_CancelTask_Normal, TestSize.Level0)
126 {
__anon480971ce0302() 127 SimpleTimer timer([]() {});
128 EXPECT_TRUE(timer.StartTask(1000)); // Start the timer
129 EXPECT_TRUE(timer.CancelTask()); // Cancel the timer, should return true
130 }
131
132 /*
133 * Feature: SimpleTimer
134 * Function: Test cancel task functionality
135 * SubFunction: NA
136 * FunctionPoints: NA
137 * EnvConditions: NA
138 * CaseDescription: Test canceling a task when it is not running. The cancel operation should return false.
139 */
140 HWTEST_F(CameraCommonUtilsUnitTest, SimpleTimer_CancelTask_WhenNotRunning, TestSize.Level0)
141 {
__anon480971ce0402() 142 SimpleTimer timer([]() {});
143 EXPECT_FALSE(timer.CancelTask()); // Timer is not running, should return false
144 }
145
146 /*
147 * Feature: SimpleTimer
148 * Function: Test interruptable sleep functionality
149 * SubFunction: NA
150 * FunctionPoints: NA
151 * EnvConditions: NA
152 * CaseDescription: Test interruptable sleep functionality. The task should complete and trigger the callback.
153 */
154 HWTEST_F(CameraCommonUtilsUnitTest, SimpleTimer_InterruptableSleep_Normal, TestSize.Level0)
155 {
156 std::atomic<bool> flag(false);
__anon480971ce0502() 157 SimpleTimer timer([&]() { flag = true; });
158
159 // Start the task
160 EXPECT_TRUE(timer.StartTask(100));
161
162 // Wait for the task to complete
163 std::this_thread::sleep_for(std::chrono::milliseconds(200));
164
165 // Check if the callback was executed
166 EXPECT_TRUE(flag);
167 }
168
169 /*
170 * Feature: SimpleTimer
171 * Function: Test interruptable sleep functionality
172 * SubFunction: NA
173 * FunctionPoints: NA
174 * EnvConditions: NA
175 * CaseDescription: Test canceling a task during interruptable sleep. The task should be canceled, and the callback
176 * should not be triggered.
177 */
178 HWTEST_F(CameraCommonUtilsUnitTest, SimpleTimer_InterruptableSleep_Cancel, TestSize.Level0)
179 {
180 std::atomic<bool> flag(false);
__anon480971ce0602() 181 SimpleTimer timer([&]() { flag = true; });
182
183 // Start the task
184 std::thread taskThread(&SimpleTimer::StartTask, &timer, 1000);
185 std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Wait for the task to enter the waiting state
186
187 // Cancel the task
188 EXPECT_TRUE(timer.CancelTask());
189
190 // Wait for the task thread to finish
191 taskThread.join();
192
193 // Check if the callback was executed
194 EXPECT_FALSE(flag);
195 }
196
197 /*
198 * Feature: SimpleTimer
199 * Function: Test destructor behavior
200 * SubFunction: NA
201 * FunctionPoints: NA
202 * EnvConditions: NA
203 * CaseDescription: Test the behavior of the destructor. The task should be automatically canceled when the timer is
204 * destroyed.
205 */
206 HWTEST_F(CameraCommonUtilsUnitTest, SimpleTimer_Destructor_Normal, TestSize.Level0)
207 {
208 std::atomic<bool> flag(false);
209
210 {
__anon480971ce0702() 211 SimpleTimer timer([&]() { flag = true; });
212 // Start the task
213 EXPECT_TRUE(timer.StartTask(1000));
214 } // Destructor automatically cleans up
215
216 // Wait for the task to complete or be canceled
217 std::this_thread::sleep_for(std::chrono::milliseconds(3000));
218
219 // Check if the callback was executed
220 EXPECT_FALSE(flag);
221 }
222
223 /*
224 * Feature: SimpleTimer
225 * Function: Test destructor behavior
226 * SubFunction: NA
227 * FunctionPoints: NA
228 * EnvConditions: NA
229 * CaseDescription: Test canceling a task during destruction. The task should be canceled, and the callback should not
230 * be triggered.
231 */
232 HWTEST_F(CameraCommonUtilsUnitTest, SimpleTimer_Destructor_CancelOnDestruct, TestSize.Level0)
233 {
234 std::atomic<bool> flag(false);
235 {
__anon480971ce0802() 236 SimpleTimer timer([&]() { flag = true; });
237 EXPECT_TRUE(timer.StartTask(1000)); // Start the task
238 } // Destructor automatically cleans up
239
240 // Wait for the task to complete
241 std::this_thread::sleep_for(std::chrono::milliseconds(100));
242
243 // Check if the callback was executed
244 EXPECT_FALSE(flag);
245 }
246
247 /*
248 * Feature: SimpleTimer
249 * Function: Test timeout functionality
250 * SubFunction: NA
251 * FunctionPoints: NA
252 * EnvConditions: NA
253 * CaseDescription: Test the timeout functionality with a zero timeout. The task should complete immediately and trigger
254 * the callback.
255 */
256 HWTEST_F(CameraCommonUtilsUnitTest, SimpleTimer_Timeout_Zero, TestSize.Level0)
257 {
258 std::atomic<bool> flag(false);
__anon480971ce0902() 259 SimpleTimer timer([&]() { flag = true; });
260
261 // Start the task
262 EXPECT_TRUE(timer.StartTask(0));
263
264 // Wait for the task to complete
265 std::this_thread::sleep_for(std::chrono::milliseconds(100));
266
267 // Check if the callback was executed
268 EXPECT_TRUE(flag);
269 }
270
271 /*
272 * Feature: SimpleTimer
273 * Function: Test timeout functionality
274 * SubFunction: NA
275 * FunctionPoints: NA
276 * EnvConditions: NA
277 * CaseDescription: Test canceling a task with a large timeout. The task should be canceled, and the callback should not
278 * be triggered.
279 */
280 HWTEST_F(CameraCommonUtilsUnitTest, SimpleTimer_Timeout_Large, TestSize.Level0)
281 {
282 std::atomic<bool> flag(false);
__anon480971ce0a02() 283 SimpleTimer timer([&]() { flag = true; });
284
285 // Start the task
286 std::thread taskThread(&SimpleTimer::StartTask, &timer, 10000);
287 std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Wait for the task to enter the waiting state
288
289 // Cancel the task
290 EXPECT_TRUE(timer.CancelTask());
291
292 // Wait for the task thread to finish
293 taskThread.join();
294
295 // Check if the callback was executed
296 EXPECT_FALSE(flag);
297 }
298
299 /*
300 * Feature: CameraDynamicLoader
301 * Function: Test get dynamic library functionality
302 * SubFunction: NA
303 * FunctionPoints: NA
304 * EnvConditions: NA
305 * CaseDescription: Test getting a dynamic library. The first load should succeed, and the second load should return the
306 * cached instance.
307 */
308 HWTEST_F(CameraCommonUtilsUnitTest, CameraDynamicLoader_TestGetDynamiclib, TestSize.Level0)
309 {
310 // First load
311 auto dynamiclib1 = CameraDynamicLoader::GetDynamiclib(MEDIA_LIB_SO);
312 EXPECT_NE(dynamiclib1, nullptr);
313 EXPECT_TRUE(dynamiclib1->IsLoaded());
314
315 // Second load, should get from cache
316 auto dynamiclib2 = CameraDynamicLoader::GetDynamiclib(MEDIA_LIB_SO);
317 EXPECT_NE(dynamiclib2, nullptr);
318 EXPECT_TRUE(dynamiclib2->IsLoaded());
319 EXPECT_EQ(dynamiclib1.get(), dynamiclib2.get());
320 }
321
322 /*
323 * Feature: CameraDynamicLoader
324 * Function: Test async loading functionality
325 * SubFunction: NA
326 * FunctionPoints: NA
327 * EnvConditions: NA
328 * CaseDescription: Test async loading of a dynamic library. The library should be loaded successfully.
329 */
330 HWTEST_F(CameraCommonUtilsUnitTest, CameraDynamicLoader_TestLoadDynamiclibAsync, TestSize.Level0)
331 {
332 // Async load
333 CameraDynamicLoader::LoadDynamiclibAsync(MEDIA_LIB_SO);
334
335 // Wait for async loading to complete
336 std::this_thread::sleep_for(std::chrono::milliseconds(100));
337
338 // Verify the dynamic library is loaded
339 auto dynamiclib = CameraDynamicLoader::GetDynamiclib(MEDIA_LIB_SO);
340 EXPECT_NE(dynamiclib, nullptr);
341 EXPECT_TRUE(dynamiclib->IsLoaded());
342 }
343
344 /*
345 * Feature: CameraDynamicLoader
346 * Function: Test delayed free functionality
347 * SubFunction: NA
348 * FunctionPoints: NA
349 * EnvConditions: NA
350 * CaseDescription: Test delayed freeing of a dynamic library. The library should be released after the delay.
351 */
352 HWTEST_F(CameraCommonUtilsUnitTest, CameraDynamicLoader_TestFreeDynamicLibDelayed, TestSize.Level0)
353 {
354 // Load the dynamic library
355 auto dynamiclib = CameraDynamicLoader::GetDynamiclib(MEDIA_LIB_SO);
356 EXPECT_NE(dynamiclib, nullptr);
357 EXPECT_TRUE(dynamiclib->IsLoaded());
358
359 // Delayed free
360 CameraDynamicLoader::FreeDynamicLibDelayed(MEDIA_LIB_SO, 500);
361
362 // Wait for the delay
363 std::this_thread::sleep_for(std::chrono::milliseconds(600));
364
365 // Verify the dynamic library has been freed
366 auto dynamiclibAfterFree = CameraDynamicLoader::GetDynamiclib(MEDIA_LIB_SO);
367 EXPECT_NE(dynamiclibAfterFree, nullptr);
368 EXPECT_TRUE(dynamiclibAfterFree->IsLoaded());
369 }
370
371 /*
372 * Feature: CameraDynamicLoader
373 * Function: Test cancel delayed free functionality
374 * SubFunction: NA
375 * FunctionPoints: NA
376 * EnvConditions: NA
377 * CaseDescription: Test canceling delayed free of a dynamic library. The library should remain loaded after
378 * cancellation.
379 */
380 HWTEST_F(CameraCommonUtilsUnitTest, CameraDynamicLoader_TestCancelFreeDynamicLibDelayed, TestSize.Level0)
381 {
382 // Load the dynamic library
383 auto dynamiclib = CameraDynamicLoader::GetDynamiclib(MEDIA_LIB_SO);
384 EXPECT_NE(dynamiclib, nullptr);
385 EXPECT_TRUE(dynamiclib->IsLoaded());
386
387 // Delayed free
388 CameraDynamicLoader::FreeDynamicLibDelayed(MEDIA_LIB_SO, 500);
389
390 // Cancel delayed free
391 CameraDynamicLoader::CancelFreeDynamicLibDelayed(MEDIA_LIB_SO);
392
393 // Verify the dynamic library remains loaded
394 auto dynamiclibAfterCancel = CameraDynamicLoader::GetDynamiclib(MEDIA_LIB_SO);
395 EXPECT_NE(dynamiclibAfterCancel, nullptr);
396 EXPECT_TRUE(dynamiclibAfterCancel->IsLoaded());
397 }
398
399 /*
400 * Feature: CameraDynamicLoader
401 * Function: Test free dynamiclib without lock
402 * SubFunction: NA
403 * FunctionPoints: NA
404 * EnvConditions: NA
405 * CaseDescription: Test freeing a dynamic library without a lock. The library should be released successfully.
406 */
407 HWTEST_F(CameraCommonUtilsUnitTest, CameraDynamicLoader_TestFreeDynamiclibNoLock, TestSize.Level0)
408 {
409 // Load the dynamic library
410 auto dynamiclib = CameraDynamicLoader::GetDynamiclib(MEDIA_LIB_SO);
411 EXPECT_NE(dynamiclib, nullptr);
412 EXPECT_TRUE(dynamiclib->IsLoaded());
413
414 // Free the dynamic library without a lock
415 CameraDynamicLoader::FreeDynamiclibNoLock(MEDIA_LIB_SO);
416
417 // Verify the dynamic library has been freed
418 auto dynamiclibAfterFree = CameraDynamicLoader::GetDynamiclib(MEDIA_LIB_SO);
419 EXPECT_NE(dynamiclibAfterFree, nullptr);
420 EXPECT_TRUE(dynamiclibAfterFree->IsLoaded());
421 }
422
423 /*
424 * Feature: CameraDynamicLoader
425 * Function: Test get function functionality
426 * SubFunction: NA
427 * FunctionPoints: NA
428 * EnvConditions: NA
429 * CaseDescription: Test getting a function from a dynamic library. The function pointer should not be null.
430 */
431 HWTEST_F(CameraCommonUtilsUnitTest, CameraDynamicLoader_TestGetFunction, TestSize.Level0)
432 {
433 // Load the dynamic library
434 auto dynamiclib = CameraDynamicLoader::GetDynamiclib(MEDIA_LIB_SO);
435 EXPECT_NE(dynamiclib, nullptr);
436 EXPECT_TRUE(dynamiclib->IsLoaded());
437
438 // Get the function
439 void *function = dynamiclib->GetFunction("createPhotoAssetIntf");
440 EXPECT_NE(function, nullptr);
441 }
442
443 /*
444 * Feature: CameraDynamicLoader
445 * Function: Test error cases
446 * SubFunction: NA
447 * FunctionPoints: NA
448 * EnvConditions: NA
449 * CaseDescription: Test error cases for dynamic library operations, such as loading a non-existent library and getting
450 * a non-existent function.
451 */
452 HWTEST_F(CameraCommonUtilsUnitTest, CameraDynamicLoader_TestErrorCases, TestSize.Level0)
453 {
454 // Test loading a non-existent dynamic library
455 auto dynamiclib = CameraDynamicLoader::GetDynamiclib("__camera_nonexistent.so");
456 EXPECT_EQ(dynamiclib, nullptr);
457
458 // Test getting a non-existent function
459 auto validDynamiclib = CameraDynamicLoader::GetDynamiclib(MEDIA_LIB_SO);
460 EXPECT_NE(validDynamiclib, nullptr);
461 void *function = validDynamiclib->GetFunction("__camera_nonexistent_function");
462 EXPECT_EQ(function, nullptr);
463 }
464
465 /*
466 * Feature: AVCodecProxy
467 * Function: Test AVMuxerSetParameter and AVMuxerSetUserMeta
468 * SubFunction: NA
469 * FunctionPoints: NA
470 * EnvConditions: NA
471 * CaseDescription: Test AVMuxerSetParameter and AVMuxerSetUserMeta when AVMuter create fail.
472 */
473 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_001, TestSize.Level0)
474 {
475 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_001 start");
476 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
477 ASSERT_NE(avCodecProxy, nullptr);
478 avCodecProxy->CreateAVMuxer(-1, static_cast<Media::Plugins::OutputFormat>(0));
479 std::shared_ptr<Meta> param = std::make_shared<Meta>();
480 int32_t ret = avCodecProxy->AVMuxerSetParameter(param);
481 EXPECT_EQ(ret, AV_ERR_FAILED);
482 ret = avCodecProxy->AVMuxerSetUserMeta(param);
483 EXPECT_EQ(ret, AV_ERR_FAILED);
484 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_001 End");
485 }
486
487 /*
488 * Feature: AVCodecProxy
489 * Function: Test AVMuxerSetParameter
490 * SubFunction: NA
491 * FunctionPoints: NA
492 * EnvConditions: NA
493 * CaseDescription: Test AVMuxerSetParameter when parameter is nullptr.
494 */
495 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_002, TestSize.Level0)
496 {
497 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_002 start");
498 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
499 ASSERT_NE(avCodecProxy, nullptr);
500 std::shared_ptr<Meta> param = nullptr;
501 int32_t ret = avCodecProxy->AVMuxerSetParameter(param);
502 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
503 avCodecProxy->avcodecIntf_ = nullptr;
504 ret = avCodecProxy->AVMuxerSetParameter(param);
505 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
506 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_002 End");
507 }
508
509 /*
510 * Feature: AVCodecProxy
511 * Function: Test AVMuxerSetUserMeta
512 * SubFunction: NA
513 * FunctionPoints: NA
514 * EnvConditions: NA
515 * CaseDescription: Test AVMuxerSetUserMeta when parameter is nullptr.
516 */
517 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_003, TestSize.Level0)
518 {
519 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_003 Start");
520 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
521 ASSERT_NE(avCodecProxy, nullptr);
522 std::shared_ptr<Meta> param = nullptr;
523 int32_t ret = avCodecProxy->AVMuxerSetUserMeta(param);
524 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
525 avCodecProxy->avcodecIntf_ = nullptr;
526 ret = avCodecProxy->AVMuxerSetUserMeta(param);
527 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
528 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_003 End");
529 }
530
531 /*
532 * Feature: AVCodecProxy
533 * Function: Test AVMuxer related interfaces
534 * SubFunction: NA
535 * FunctionPoints: NA
536 * EnvConditions: NA
537 * CaseDescription: Test AVMuxer related interfaces when AVMuter create fail.
538 */
539 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_004, TestSize.Level0)
540 {
541 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_004 start");
542 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
543 ASSERT_NE(avCodecProxy, nullptr);
544 avCodecProxy->CreateAVMuxer(-1, static_cast<Media::Plugins::OutputFormat>(0));
545
546 std::shared_ptr<Meta> trackDesc = std::make_shared<Meta>();
547 int32_t ret = avCodecProxy->AVMuxerStart();
548 EXPECT_EQ(ret, AV_ERR_FAILED);
549 int32_t trackIndex = 1;
550 ret = avCodecProxy->AVMuxerAddTrack(trackIndex, trackDesc);
551 EXPECT_EQ(ret, AV_ERR_FAILED);
552 std::shared_ptr<AVBuffer> sample = std::make_shared<AVBuffer>();
553 ret = avCodecProxy->AVMuxerWriteSample(1, sample);
554 EXPECT_EQ(ret, AV_ERR_FAILED);
555 ret = avCodecProxy->AVMuxerStop();
556 EXPECT_EQ(ret, AV_ERR_FAILED);
557 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_004 End");
558 }
559
560 /*
561 * Feature: AVCodecProxy
562 * Function: Test AVMuxer related interfaces
563 * SubFunction: NA
564 * FunctionPoints: NA
565 * EnvConditions: NA
566 * CaseDescription: Test AVMuxer related interfaces when parameter is nullptr.
567 */
568 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_005, TestSize.Level0)
569 {
570 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_005 start");
571 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
572 ASSERT_NE(avCodecProxy, nullptr);
573 std::shared_ptr<Meta> trackDesc = nullptr;
574 int32_t trackIndex = 1;
575 int32_t ret = avCodecProxy->AVMuxerAddTrack(trackIndex, trackDesc);
576 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
577 std::shared_ptr<AVBuffer> sample = nullptr;
578 ret = avCodecProxy->AVMuxerWriteSample(1, sample);
579 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
580
581 avCodecProxy->avcodecIntf_ = nullptr;
582 ret = avCodecProxy->AVMuxerStart();
583 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
584 ret = avCodecProxy->AVMuxerAddTrack(trackIndex, trackDesc);
585 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
586 ret = avCodecProxy->AVMuxerWriteSample(1, sample);
587 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
588 ret = avCodecProxy->AVMuxerStop();
589 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
590 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_005 End");
591 }
592
593 /*
594 * Feature: AVCodecProxy
595 * Function: Test AVCodecVideoEncoder
596 * SubFunction: NA
597 * FunctionPoints: NA
598 * EnvConditions: NA
599 * CaseDescription: Test AVCodecVideoEncoder when AVCodecVideoEncoder has not been created.
600 */
601 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_006, TestSize.Level0)
602 {
603 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_006 start");
604 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
605 ASSERT_NE(avCodecProxy, nullptr);
606 int32_t ret = avCodecProxy->AVCodecVideoEncoderStart();
607 EXPECT_EQ(ret, AV_ERR_FAILED);
608 ret = avCodecProxy->AVCodecVideoEncoderStop();
609 EXPECT_EQ(ret, AV_ERR_FAILED);
610 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_006 End");
611 }
612
613 /*
614 * Feature: AVCodecProxy
615 * Function: Test AVCodecVideoEncoder
616 * SubFunction: NA
617 * FunctionPoints: NA
618 * EnvConditions: NA
619 * CaseDescription: Test AVCodecVideoEncoder when paramenter is normal.
620 */
621 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_007, TestSize.Level0)
622 {
623 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_007 Start");
624 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
625 ASSERT_NE(avCodecProxy, nullptr);
626 int32_t ret = avCodecProxy->CreateAVCodecVideoEncoder(MIME_VIDEO_AVC.data());
627 EXPECT_EQ(ret, AV_ERR_OK);
628 ret = avCodecProxy->AVCodecVideoEncoderPrepare();
629 EXPECT_EQ(ret, AV_ERR_OK);
630 bool isExisted = avCodecProxy->IsVideoEncoderExisted();
631 EXPECT_TRUE(isExisted);
632 ret = avCodecProxy->AVCodecVideoEncoderRelease();
633 EXPECT_EQ(ret, AV_ERR_OK);
634 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_007 End");
635 }
636
637 /*
638 * Feature: AVCodecProxy
639 * Function: Test AVCodecVideoEncoder
640 * SubFunction: NA
641 * FunctionPoints: NA
642 * EnvConditions: NA
643 * CaseDescription: Test Test AVCodecVideoEncoder when parameter is nullptr.
644 */
645 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_008, TestSize.Level0)
646 {
647 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_008 start");
648 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
649 ASSERT_NE(avCodecProxy, nullptr);
650 int32_t ret = avCodecProxy->CreateAVCodecVideoEncoder(MIME_VIDEO_AVC.data());
651 EXPECT_EQ(ret, AV_ERR_OK);
652 avCodecProxy->avcodecIntf_ = nullptr;
653 bool isExisted = avCodecProxy->IsVideoEncoderExisted();
654 EXPECT_FALSE(isExisted);
655 ret = avCodecProxy->AVCodecVideoEncoderPrepare();
656 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
657 ret = avCodecProxy->AVCodecVideoEncoderStart();
658 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
659 ret = avCodecProxy->AVCodecVideoEncoderStop();
660 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
661 ret = avCodecProxy->AVCodecVideoEncoderRelease();
662 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
663 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_008 End");
664 }
665
666 /*
667 * Feature: AVCodecProxy
668 * Function: Test AVCodecVideoEncoder
669 * SubFunction: NA
670 * FunctionPoints: NA
671 * EnvConditions: NA
672 * CaseDescription: Test AVCodecVideoEncoder when AVCodecVideoEncoder has not been created.
673 */
674 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_009, TestSize.Level0)
675 {
676 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_009 start");
677 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
678 ASSERT_NE(avCodecProxy, nullptr);
679 bool isExisted = avCodecProxy->IsVideoEncoderExisted();
680 EXPECT_FALSE(isExisted);
681 int32_t ret = avCodecProxy->AVCodecVideoEncoderPrepare();
682 EXPECT_EQ(ret, AV_ERR_FAILED);
683 ret = avCodecProxy->AVCodecVideoEncoderStart();
684 EXPECT_EQ(ret, AV_ERR_FAILED);
685 ret = avCodecProxy->AVCodecVideoEncoderStop();
686 EXPECT_EQ(ret, AV_ERR_FAILED);
687 ret = avCodecProxy->AVCodecVideoEncoderRelease();
688 EXPECT_EQ(ret, AV_ERR_FAILED);
689 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_009 End");
690 }
691
692 /*
693 * Feature: AVCodecProxy
694 * Function: Test AVCodecVideoEncoder
695 * SubFunction: NA
696 * FunctionPoints: NA
697 * EnvConditions: NA
698 * CaseDescription: Test AVCodecVideoEncoder when AVCodecVideoEncoder has not been created.
699 */
700 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_010, TestSize.Level0)
701 {
702 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_010 start");
703 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
704 ASSERT_NE(avCodecProxy, nullptr);
705 sptr<Surface> surface = avCodecProxy->CreateInputSurface();
706 EXPECT_EQ(surface, nullptr);
707 int32_t ret = avCodecProxy->QueueInputBuffer(1);
708 EXPECT_EQ(ret, AV_ERR_FAILED);
709 ret = avCodecProxy->AVCodecVideoEncoderNotifyEos();
710 EXPECT_EQ(ret, AV_ERR_FAILED);
711 ret = avCodecProxy->ReleaseOutputBuffer(1);
712 EXPECT_EQ(ret, AV_ERR_FAILED);
713 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_010 End");
714 }
715
716 /*
717 * Feature: AVCodecProxy
718 * Function: Test AVCodecVideoEncoder
719 * SubFunction: NA
720 * FunctionPoints: NA
721 * EnvConditions: NA
722 * CaseDescription: Test AVCodecVideoEncoder when parameter is nullptr.
723 */
724 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_011, TestSize.Level0)
725 {
726 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_011 start");
727 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
728 ASSERT_NE(avCodecProxy, nullptr);
729 int32_t ret = avCodecProxy->CreateAVCodecVideoEncoder(MIME_VIDEO_AVC.data());
730 EXPECT_EQ(ret, AV_ERR_OK);
731 avCodecProxy->avcodecIntf_ = nullptr;
732 sptr<Surface> surface = avCodecProxy->CreateInputSurface();
733 EXPECT_EQ(surface, nullptr);
734 ret = avCodecProxy->QueueInputBuffer(1);
735 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
736 ret = avCodecProxy->AVCodecVideoEncoderNotifyEos();
737 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
738 ret = avCodecProxy->ReleaseOutputBuffer(1);
739 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
740 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_011 End");
741 }
742
743 /*
744 * Feature: AVCodecProxy
745 * Function: Test AVCodecVideoEncoderSetCallback
746 * SubFunction: NA
747 * FunctionPoints: NA
748 * EnvConditions: NA
749 * CaseDescription: Test AVCodecVideoEncoderSetCallback when param is normal.
750 */
751 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_012, TestSize.Level0)
752 {
753 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_012 Start");
754 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
755 ASSERT_NE(avCodecProxy, nullptr);
756 int32_t ret = avCodecProxy->CreateAVCodecVideoEncoder(MIME_VIDEO_AVC.data());
757 EXPECT_EQ(ret, AV_ERR_OK);
758 std::shared_ptr<MediaCodecCallback> callback = std::make_shared<CoderCallback>();
759 ret = avCodecProxy->AVCodecVideoEncoderSetCallback(callback);
760 EXPECT_EQ(ret, AV_ERR_OK);
761 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_012 End");
762 }
763
764 /*
765 * Feature: AVCodecProxy
766 * Function: Test AVCodecVideoEncoder
767 * SubFunction: NA
768 * FunctionPoints: NA
769 * EnvConditions: NA
770 * CaseDescription: Test AVCodecVideoEncoder when parameter is nullptr.
771 */
772 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_013, TestSize.Level0)
773 {
774 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_013 Start");
775 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
776 ASSERT_NE(avCodecProxy, nullptr);
777 int32_t ret = avCodecProxy->CreateAVCodecVideoEncoder(MIME_VIDEO_AVC.data());
778 EXPECT_EQ(ret, AV_ERR_OK);
779 avCodecProxy->avcodecIntf_ = nullptr;
780 Format format;
781 ret = avCodecProxy->AVCodecVideoEncoderSetParameter(format);
782 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
783 ret = avCodecProxy->AVCodecVideoEncoderConfigure(format);
784 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
785 std::shared_ptr<MediaCodecCallback> callback = std::make_shared<CoderCallback>();
786 ret = avCodecProxy->AVCodecVideoEncoderSetCallback(callback);
787 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
788 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_013 End");
789 }
790
791 /*
792 * Feature: AVCodecProxy
793 * Function: Test AVCodecVideoEncoder
794 * SubFunction: NA
795 * FunctionPoints: NA
796 * EnvConditions: NA
797 * CaseDescription: Test AVCodecVideoEncoder when AVCodecVideoEncoder has not been created.
798 */
799 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_014, TestSize.Level0)
800 {
801 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_014 Start");
802 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
803 ASSERT_NE(avCodecProxy, nullptr);
804 Format format;
805 int32_t ret = avCodecProxy->AVCodecVideoEncoderSetParameter(format);
806 EXPECT_EQ(ret, AV_ERR_FAILED);
807 ret = avCodecProxy->AVCodecVideoEncoderConfigure(format);
808 EXPECT_EQ(ret, AV_ERR_FAILED);
809 std::shared_ptr<MediaCodecCallback> callback = std::make_shared<CoderCallback>();
810 ret = avCodecProxy->AVCodecVideoEncoderSetCallback(callback);
811 EXPECT_EQ(ret, AV_ERR_FAILED);
812 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_014 End");
813 }
814
815 /*
816 * Feature: AVCodecProxy
817 * Function: Test AVSource
818 * SubFunction: NA
819 * FunctionPoints: NA
820 * EnvConditions: NA
821 * CaseDescription: Test AVSource when param is nullptr.
822 */
823 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_015, TestSize.Level0)
824 {
825 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_015 Start");
826 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
827 ASSERT_NE(avCodecProxy, nullptr);
828 avCodecProxy->avcodecIntf_ = nullptr;
829 Format format;
830 int32_t ret = avCodecProxy->AVSourceGetSourceFormat(format);
831 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
832 ret = avCodecProxy->AVSourceGetUserMeta(format);
833 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
834 ret = avCodecProxy->AVSourceGetTrackFormat(format, 1);
835 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
836 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_015 End");
837 }
838
839 /*
840 * Feature: AVCodecProxy
841 * Function: Test AVSource
842 * SubFunction: NA
843 * FunctionPoints: NA
844 * EnvConditions: NA
845 * CaseDescription: Test AVSource when param is normal.
846 */
847 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_016, TestSize.Level0)
848 {
849 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_016 Start");
850 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
851 ASSERT_NE(avCodecProxy, nullptr);
852 std::shared_ptr<AVSource> source = std::make_shared<AVSourceTest>();
853 ASSERT_NE(source, nullptr);
854 std::shared_ptr<AVBuffer> sample = std::make_shared<AVBuffer>();
855 ASSERT_NE(sample, nullptr);
856 source->mediaDemuxer = std::make_shared<Media::MediaDemuxer>();
857 ASSERT_NE(source->mediaDemuxer, nullptr);
858 avCodecProxy->CreateAVDemuxer(source);
859 int32_t ret = avCodecProxy->AVDemuxerSeekToTime(1, static_cast<SeekMode>(0));
860 EXPECT_EQ(ret, AV_ERR_OK);
861 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_016 End");
862 }
863
864 /*
865 * Feature: AVCodecProxy
866 * Function: Test AVDemuxer
867 * SubFunction: NA
868 * FunctionPoints: NA
869 * EnvConditions: NA
870 * CaseDescription: Test AVDemuxer when param is nullptr.
871 */
872 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_017, TestSize.Level0)
873 {
874 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_017 Start");
875 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
876 ASSERT_NE(avCodecProxy, nullptr);
877 std::shared_ptr<AVSource> source = std::make_shared<AVSourceTest>();
878 ASSERT_NE(source, nullptr);
879 avCodecProxy->CreateAVDemuxer(source);
880 std::shared_ptr<AVBuffer> sample = nullptr;
881 int32_t ret = avCodecProxy->ReadSampleBuffer(1, sample);
882 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
883
884 sample = std::make_shared<AVBuffer>();
885 ASSERT_NE(sample, nullptr);
886 avCodecProxy->avcodecIntf_ = nullptr;
887 avCodecProxy->CreateAVDemuxer(source);
888 ret = avCodecProxy->ReadSampleBuffer(1, sample);
889 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
890 ret = avCodecProxy->AVDemuxerSeekToTime(1, static_cast<SeekMode>(0));
891 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
892 ret = avCodecProxy->AVDemuxerSelectTrackByID(1);
893 EXPECT_EQ(ret, AV_ERR_INVALID_VAL);
894 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_017 End");
895 }
896
897 /*
898 * Feature: AVCodecProxy
899 * Function: Test AVDemuxer
900 * SubFunction: NA
901 * FunctionPoints: NA
902 * EnvConditions: NA
903 * CaseDescription: Test AVDemuxer when not CreateAVMuxer
904 */
905 HWTEST_F(CameraCommonUtilsUnitTest, CameraAVCodecProxy_Test_018, TestSize.Level0)
906 {
907 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_018 Start");
908 auto avCodecProxy = AVCodecProxy::CreateAVCodecProxy();
909 ASSERT_NE(avCodecProxy, nullptr);
910 std::shared_ptr<AVSource> source = std::make_shared<AVSourceTest>();
911 ASSERT_NE(source, nullptr);
912 std::shared_ptr<AVBuffer> sample = std::make_shared<AVBuffer>();
913 ASSERT_NE(sample, nullptr);
914 int32_t ret = avCodecProxy->ReadSampleBuffer(1, sample);
915 EXPECT_EQ(ret, AV_ERR_FAILED);
916 ret = avCodecProxy->AVDemuxerSeekToTime(1, static_cast<SeekMode>(0));
917 EXPECT_EQ(ret, AV_ERR_FAILED);
918 ret = avCodecProxy->AVDemuxerSelectTrackByID(1);
919 EXPECT_EQ(ret, AV_ERR_FAILED);
920 MEDIA_INFO_LOG("CameraAVCodecProxy_Test_018 End");
921 }
922
923 /*
924 * Feature: ImageSourceProxy
925 * Function: Test ImageSource
926 * SubFunction: NA
927 * FunctionPoints: NA
928 * EnvConditions: NA
929 * CaseDescription: Test ImageSource when param is normal.
930 */
931 HWTEST_F(CameraCommonUtilsUnitTest, CameraImageSourceProxy_Test_001, TestSize.Level0)
932 {
933 MEDIA_INFO_LOG("CameraImageSourceProxy_Test_001 Start");
934 auto imageSourceProxy = ImageSourceProxy::CreateImageSourceProxy();
935 ASSERT_NE(imageSourceProxy, nullptr);
936
937 uint32_t errorCode = 0;
938 Media::SourceOptions opts;
939 size_t width = 256;
940 size_t height = 256;
941 size_t blockNum = ((width + 4 - 1) / 4) * ((height + 4 - 1) / 4);
942 size_t size = blockNum * 16 + 16;
943 uint8_t* data = (uint8_t*)malloc(size);
944 int32_t ret = imageSourceProxy->CreateImageSource(data, size, opts, errorCode);
945 EXPECT_EQ(ret, 0);
946 EXPECT_EQ(errorCode, 0);
947 MEDIA_INFO_LOG("CameraImageSourceProxy_Test_001 End");
948 }
949
950 /*
951 * Feature: ImageSourceProxy
952 * Function: Test ImageSource
953 * SubFunction: NA
954 * FunctionPoints: NA
955 * EnvConditions: NA
956 * CaseDescription: Test ImageSource when ImageSource not be Created;
957 */
958 HWTEST_F(CameraCommonUtilsUnitTest, CameraImageSourceProxy_Test_002, TestSize.Level0)
959 {
960 MEDIA_INFO_LOG("CameraImageSourceProxy_Test_002 Start");
961 auto imageSourceProxy = ImageSourceProxy::CreateImageSourceProxy();
962 ASSERT_NE(imageSourceProxy, nullptr);
963
964 uint32_t errorCode = 0;
965 Media::DecodeOptions decodeOpts;
966 std::unique_ptr<Media::PixelMap> pixelMap = imageSourceProxy->CreatePixelMap(decodeOpts, errorCode);
967 EXPECT_EQ(pixelMap, nullptr);
968 MEDIA_INFO_LOG("CameraImageSourceProxy_Test_002 End");
969 }
970
971
972 /*
973 * Feature: ImageSourceProxy
974 * Function: Test ImageSource
975 * SubFunction: NA
976 * FunctionPoints: NA
977 * EnvConditions: NA
978 * CaseDescription: Test ImageSource when param is nullptr;
979 */
980 HWTEST_F(CameraCommonUtilsUnitTest, CameraImageSourceProxy_Test_003, TestSize.Level0)
981 {
982 MEDIA_INFO_LOG("CameraImageSourceProxy_Test_003 Start");
983 auto imageSourceProxy = ImageSourceProxy::CreateImageSourceProxy();
984 ASSERT_NE(imageSourceProxy, nullptr);
985 imageSourceProxy->imageSourceIntf_ = nullptr;
986 uint32_t errorCode = 0;
987 Media::SourceOptions opts;
988 size_t width = 256;
989 size_t height = 256;
990 size_t blockNum = ((width + 4 - 1) / 4) * ((height + 4 - 1) / 4);
991 size_t size = blockNum * 16 + 16;
992 uint8_t* data = (uint8_t*)malloc(size);
993 int32_t ret = imageSourceProxy->CreateImageSource(data, size, opts, errorCode);
994 EXPECT_EQ(ret, -1);
995 Media::DecodeOptions decodeOpts;
996 std::unique_ptr<Media::PixelMap> pixelMap = imageSourceProxy->CreatePixelMap(decodeOpts, errorCode);
997 EXPECT_EQ(pixelMap, nullptr);
998 MEDIA_INFO_LOG("CameraImageSourceProxy_Test_003 End");
999 }
1000
1001 /*
1002 * Feature: ImageSourceProxy
1003 * Function: Test CreateImageSource
1004 * SubFunction: NA
1005 * FunctionPoints: NA
1006 * EnvConditions: NA
1007 * CaseDescription: Test CreateImageSource when size is too large.
1008 */
1009 HWTEST_F(CameraCommonUtilsUnitTest, CameraImageSourceProxy_Test_004, TestSize.Level0)
1010 {
1011 MEDIA_INFO_LOG("CameraImageSourceProxy_Test_004 Start");
1012 auto imageSourceProxy = ImageSourceProxy::CreateImageSourceProxy();
1013 ASSERT_NE(imageSourceProxy, nullptr);
1014 imageSourceProxy->imageSourceIntf_ = nullptr;
1015 uint32_t errorCode = 0;
1016 Media::SourceOptions opts;
1017 size_t size = MAX_SOURCE_SIZE + 1;
1018 uint8_t* data = (uint8_t*)malloc(size);
1019 int32_t ret = imageSourceProxy->CreateImageSource(data, size, opts, errorCode);
1020 EXPECT_EQ(ret, -1);
1021 MEDIA_INFO_LOG("CameraImageSourceProxy_Test_004 End");
1022 }
1023
1024 /*
1025 * Feature: MediaManagerProxy
1026 * Function: Test MpegManager
1027 * SubFunction: NA
1028 * FunctionPoints: NA
1029 * EnvConditions: NA
1030 * CaseDescription: Test MpegManager when param is normal.
1031 */
1032 HWTEST_F(CameraCommonUtilsUnitTest, CameraMediaManagerProxy_Test_001, TestSize.Level0)
1033 {
1034 MEDIA_INFO_LOG("CameraMediaManagerProxy_Test_001 Start");
1035 auto mediaManagerProxy = DeferredProcessing::MediaManagerProxy::CreateMediaManagerProxy();
1036 ASSERT_NE(mediaManagerProxy, nullptr);
1037
1038 uint8_t randomNum = 1;
1039 std::vector<std::string> testStrings = {"test1", "test2"};
1040 std::string requestId(testStrings[randomNum % testStrings.size()]);
1041 sptr<IPCFileDescriptor> inputFd = sptr<IPCFileDescriptor>::MakeSptr(dup(VIDEO_REQUEST_FD_ID));
1042 ASSERT_NE(inputFd, nullptr);
1043 mediaManagerProxy->MpegAcquire(requestId, inputFd);
1044 EXPECT_EQ(mediaManagerProxy->MpegRelease(), DP_OK);
1045 MEDIA_INFO_LOG("CameraMediaManagerProxy_Test_001 End");
1046 }
1047
1048 /*
1049 * Feature: MediaManagerProxy
1050 * Function: Test MpegManager
1051 * SubFunction: NA
1052 * FunctionPoints: NA
1053 * EnvConditions: NA
1054 * CaseDescription: Test MpegManager when param is nullptr.
1055 */
1056 HWTEST_F(CameraCommonUtilsUnitTest, CameraMediaManagerProxy_Test_002, TestSize.Level0)
1057 {
1058 MEDIA_INFO_LOG("CameraMediaManagerProxy_Test_002 Start");
1059 auto mediaManagerProxy = DeferredProcessing::MediaManagerProxy::CreateMediaManagerProxy();
1060 ASSERT_NE(mediaManagerProxy, nullptr);
1061 mediaManagerProxy->mediaManagerIntf_ = nullptr;
1062 uint8_t randomNum = 1;
1063 std::vector<std::string> testStrings = {"test1", "test2"};
1064 std::string requestId(testStrings[randomNum % testStrings.size()]);
1065 sptr<IPCFileDescriptor> inputFd = sptr<IPCFileDescriptor>::MakeSptr(dup(VIDEO_REQUEST_FD_ID));
1066 ASSERT_NE(inputFd, nullptr);
1067 mediaManagerProxy->MpegAcquire(requestId, inputFd);
1068
1069 int32_t ret = mediaManagerProxy->MpegUnInit(1);
1070 EXPECT_EQ(ret, DP_ERR);
1071 EXPECT_EQ(mediaManagerProxy->MpegRelease(), DP_ERR);
1072 MEDIA_INFO_LOG("CameraMediaManagerProxy_Test_002 End");
1073 }
1074
1075 /*
1076 * Feature: MediaManagerProxy
1077 * Function: Test CreateImageSource
1078 * SubFunction: NA
1079 * FunctionPoints: NA
1080 * EnvConditions: NA
1081 * CaseDescription: Test CreateImageSource when param is nullptr.
1082 */
1083 HWTEST_F(CameraCommonUtilsUnitTest, CameraMediaManagerProxy_Test_003, TestSize.Level0)
1084 {
1085 MEDIA_INFO_LOG("CameraMediaManagerProxy_Test_003 Start");
1086 auto mediaManagerProxy = DeferredProcessing::MediaManagerProxy::CreateMediaManagerProxy();
1087 ASSERT_NE(mediaManagerProxy, nullptr);
1088 mediaManagerProxy->mediaManagerIntf_ = nullptr;
1089 sptr<IPCFileDescriptor> fd = mediaManagerProxy->MpegGetResultFd();
1090 EXPECT_EQ(fd, nullptr);
1091
1092 sptr<Surface> surface = mediaManagerProxy->MpegGetSurface();
1093 EXPECT_EQ(surface, nullptr);
1094 surface = mediaManagerProxy->MpegGetMakerSurface();
1095 EXPECT_EQ(surface, nullptr);
1096 MEDIA_INFO_LOG("CameraMediaManagerProxy_Test_003 End");
1097 }
1098
1099 /*
1100 * Feature: MediaManagerProxy
1101 * Function: Test CreateImageSource
1102 * SubFunction: NA
1103 * FunctionPoints: NA
1104 * EnvConditions: NA
1105 * CaseDescription: Test CreateImageSource when param is normal.
1106 */
1107 HWTEST_F(CameraCommonUtilsUnitTest, CameraMediaManagerProxy_Test_004, TestSize.Level0)
1108 {
1109 MEDIA_INFO_LOG("CameraMediaManagerProxy_Test_004 Start");
1110 auto mediaManagerProxy = DeferredProcessing::MediaManagerProxy::CreateMediaManagerProxy();
1111 ASSERT_NE(mediaManagerProxy, nullptr);
1112 uint8_t randomNum = 1;
1113 std::vector<std::string> testStrings = {"test1", "test2"};
1114 std::string requestId(testStrings[randomNum % testStrings.size()]);
1115 sptr<IPCFileDescriptor> inputFd = sptr<IPCFileDescriptor>::MakeSptr(dup(VIDEO_REQUEST_FD_ID));
1116 ASSERT_NE(inputFd, nullptr);
1117 mediaManagerProxy->MpegAcquire(requestId, inputFd);
1118 std::unique_ptr<DeferredProcessing::MediaUserInfo> userInfo = std::make_unique<DeferredProcessing::MediaUserInfo>();
1119 mediaManagerProxy->MpegAddUserMeta(std::move(userInfo));
1120
1121 uint64_t ret = mediaManagerProxy->MpegGetProcessTimeStamp();
1122 EXPECT_EQ(ret, DP_OK);
1123 mediaManagerProxy->MpegSetMarkSize(1);
1124 EXPECT_EQ(mediaManagerProxy->MpegRelease(), DP_OK);
1125 MEDIA_INFO_LOG("CameraMediaManagerProxy_Test_004 End");
1126 }
1127
1128 /*
1129 * Feature: MediaManagerProxy
1130 * Function: Test CreateImageSource
1131 * SubFunction: NA
1132 * FunctionPoints: NA
1133 * EnvConditions: NA
1134 * CaseDescription: Test CreateImageSource when param is nullptr.
1135 */
1136 HWTEST_F(CameraCommonUtilsUnitTest, CameraMediaManagerProxy_Test_005, TestSize.Level0)
1137 {
1138 MEDIA_INFO_LOG("CameraMediaManagerProxy_Test_005 Start");
1139 auto mediaManagerProxy = DeferredProcessing::MediaManagerProxy::CreateMediaManagerProxy();
1140 ASSERT_NE(mediaManagerProxy, nullptr);
1141 mediaManagerProxy->mediaManagerIntf_ = nullptr;
1142 std::unique_ptr<DeferredProcessing::MediaUserInfo> userInfo = std::make_unique<DeferredProcessing::MediaUserInfo>();
1143 mediaManagerProxy->MpegAddUserMeta(std::move(userInfo));
1144
1145 uint64_t ret = mediaManagerProxy->MpegGetProcessTimeStamp();
1146 EXPECT_EQ(ret, 0);
1147 mediaManagerProxy->MpegSetMarkSize(1);
1148 MEDIA_INFO_LOG("CameraMediaManagerProxy_Test_005 End");
1149 }
1150
1151 /*
1152 * Feature: MovingPhotoVideoCacheProxy
1153 * Function: Test GetFrameCachedResult
1154 * SubFunction: NA
1155 * FunctionPoints: NA
1156 * EnvConditions: NA
1157 * CaseDescription: Test GetFrameCachedResult
1158 */
1159 HWTEST_F(CameraCommonUtilsUnitTest, CameraMovingPhotoProxy_Test_001, TestSize.Level0)
1160 {
1161 MEDIA_INFO_LOG("CameraMovingPhotoProxy_Test_001 Start");
1162 auto movingPhotoVideoCacheProxy = MovingPhotoVideoCacheProxy::CreateMovingPhotoVideoCacheProxy();
1163 ASSERT_NE(movingPhotoVideoCacheProxy, nullptr);
1164 EXPECT_NE(movingPhotoVideoCacheProxy->movingPhotoVideoCacheIntf_, nullptr);
1165 auto aVCodecTaskManagerProxy = AvcodecTaskManagerProxy::CreateAvcodecTaskManagerProxy();
1166 ASSERT_NE(aVCodecTaskManagerProxy, nullptr);
1167 ASSERT_NE(aVCodecTaskManagerProxy->avcodecTaskManagerIntf_, nullptr);
1168
1169 auto audioCapturerSessionProxy = AudioCapturerSessionProxy::CreateAudioCapturerSessionProxy();
1170 ASSERT_NE(audioCapturerSessionProxy, nullptr);
1171 EXPECT_NE(audioCapturerSessionProxy->audioCapturerSessionIntf_, nullptr);
1172 int32_t retCode = audioCapturerSessionProxy->CreateAudioSession();
1173 EXPECT_EQ(retCode, 0);
1174
1175 VideoCodecType type = static_cast<VideoCodecType>(0);
1176 int32_t colorSpace = 0;
1177 retCode = aVCodecTaskManagerProxy->CreateAvcodecTaskManager(
1178 audioCapturerSessionProxy, type, colorSpace);
1179 EXPECT_EQ(retCode, 0);
1180
1181 retCode = movingPhotoVideoCacheProxy->CreateMovingPhotoVideoCache(
1182 aVCodecTaskManagerProxy);
1183 EXPECT_EQ(retCode, 0);
1184 std::vector<sptr<FrameRecord>> frameRecords;
1185 uint64_t taskName = 0;
1186 int32_t rotation = 0;
1187 int32_t captureId = 0;
1188 movingPhotoVideoCacheProxy->GetFrameCachedResult(frameRecords, taskName, rotation, captureId);
1189 EXPECT_NE(frameRecords.empty(), false);
1190
1191 movingPhotoVideoCacheProxy->movingPhotoVideoCacheIntf_ = nullptr;
1192 movingPhotoVideoCacheProxy->CreateMovingPhotoVideoCache(aVCodecTaskManagerProxy->avcodecTaskManagerIntf_);
1193 movingPhotoVideoCacheProxy->GetFrameCachedResult(frameRecords, taskName, rotation, captureId);
1194 EXPECT_EQ(frameRecords.empty(), true);
1195 MEDIA_INFO_LOG("CameraMovingPhotoProxy_Test_001 End");
1196 }
1197
1198 /*
1199 * Feature: MovingPhotoVideoCacheProxy
1200 * Function: Test OnDrainFrameRecord
1201 * SubFunction: NA
1202 * FunctionPoints: NA
1203 * EnvConditions: NA
1204 * CaseDescription: Test OnDrainFrameRecord
1205 */
1206 HWTEST_F(CameraCommonUtilsUnitTest, CameraMovingPhotoProxy_Test_002, TestSize.Level0)
1207 {
1208 MEDIA_INFO_LOG("CameraMovingPhotoProxy_Test_002 Start");
1209 auto movingPhotoVideoCacheProxy = MovingPhotoVideoCacheProxy::CreateMovingPhotoVideoCacheProxy();
1210 ASSERT_NE(movingPhotoVideoCacheProxy, nullptr);
1211 EXPECT_NE(movingPhotoVideoCacheProxy->movingPhotoVideoCacheIntf_, nullptr);
1212 auto aVCodecTaskManagerProxy = AvcodecTaskManagerProxy::CreateAvcodecTaskManagerProxy();
1213 ASSERT_NE(aVCodecTaskManagerProxy, nullptr);
1214 EXPECT_NE(aVCodecTaskManagerProxy->avcodecTaskManagerIntf_, nullptr);
1215
1216 auto audioCapturerSessionProxy = AudioCapturerSessionProxy::CreateAudioCapturerSessionProxy();
1217 ASSERT_NE(audioCapturerSessionProxy, nullptr);
1218 EXPECT_NE(audioCapturerSessionProxy->audioCapturerSessionIntf_, nullptr);
1219 int32_t retCode = audioCapturerSessionProxy->CreateAudioSession();
1220 EXPECT_EQ(retCode, 0);
1221
1222 VideoCodecType type = static_cast<VideoCodecType>(0);
1223 int32_t colorSpace = 0;
1224 retCode = aVCodecTaskManagerProxy->CreateAvcodecTaskManager(
1225 audioCapturerSessionProxy, type, colorSpace);
1226 EXPECT_EQ(retCode, 0);
1227
1228 int32_t ret = movingPhotoVideoCacheProxy->CreateMovingPhotoVideoCache(
1229 aVCodecTaskManagerProxy);
1230 EXPECT_EQ(ret, 0);
1231 sptr<SurfaceBuffer> videoBuffer = SurfaceBuffer::Create();
1232 int64_t timestamp = 0;
1233 GraphicTransformType types = GraphicTransformType::GRAPHIC_FLIP_H_ROT90;
1234 sptr<FrameRecord> frame = new FrameRecord(videoBuffer, timestamp, types);
1235 movingPhotoVideoCacheProxy->OnDrainFrameRecord(frame);
1236
1237 movingPhotoVideoCacheProxy->movingPhotoVideoCacheIntf_ = nullptr;
1238 movingPhotoVideoCacheProxy->OnDrainFrameRecord(frame);
1239 MEDIA_INFO_LOG("CameraMovingPhotoProxy_Test_002 End");
1240 }
1241
1242 /*
1243 * Feature: AudioCapturerSessionProxy
1244 * Function: Test StartAudioCapture
1245 * SubFunction: NA
1246 * FunctionPoints: NA
1247 * EnvConditions: NA
1248 * CaseDescription: Test StartAudioCapture
1249 */
1250 HWTEST_F(CameraCommonUtilsUnitTest, CameraMovingPhotoProxy_Test_003, TestSize.Level0)
1251 {
1252 MEDIA_INFO_LOG("CameraMovingPhotoProxy_Test_003 Start");
1253 auto audioCapturerSessionProxy = AudioCapturerSessionProxy::CreateAudioCapturerSessionProxy();
1254 ASSERT_NE(audioCapturerSessionProxy, nullptr);
1255 EXPECT_NE(audioCapturerSessionProxy->audioCapturerSessionIntf_, nullptr);
1256 int32_t retCode = audioCapturerSessionProxy->CreateAudioSession();
1257 EXPECT_EQ(retCode, 0);
1258 bool ret = audioCapturerSessionProxy->StartAudioCapture();
1259 EXPECT_EQ(ret, true);
1260 audioCapturerSessionProxy->StopAudioCapture();
1261
1262 audioCapturerSessionProxy->audioCapturerSessionIntf_ = nullptr;
1263 audioCapturerSessionProxy->CreateAudioSession();
1264 ret = audioCapturerSessionProxy->StartAudioCapture();
1265 EXPECT_EQ(ret, false);
1266 audioCapturerSessionProxy->StopAudioCapture();
1267 MEDIA_INFO_LOG("CameraMovingPhotoProxy_Test_003 End");
1268 }
1269
1270 /*
1271 * Feature: AvcodecTaskManagerProxy
1272 * Function: Test TaskManagerInsertEndTime
1273 * SubFunction: NA
1274 * FunctionPoints: NA
1275 * EnvConditions: NA
1276 * CaseDescription: Test TaskManagerInsertEndTime
1277 */
1278 HWTEST_F(CameraCommonUtilsUnitTest, CameraMovingPhotoProxy_Test_004, TestSize.Level0)
1279 {
1280 MEDIA_INFO_LOG("CameraMovingPhotoProxy_Test_004 Start");
1281 auto aVCodecTaskManagerProxy = AvcodecTaskManagerProxy::CreateAvcodecTaskManagerProxy();
1282 ASSERT_NE(aVCodecTaskManagerProxy, nullptr);
1283 EXPECT_NE(aVCodecTaskManagerProxy->avcodecTaskManagerIntf_, nullptr);
1284
1285 auto audioCapturerSessionProxy = AudioCapturerSessionProxy::CreateAudioCapturerSessionProxy();
1286 ASSERT_NE(audioCapturerSessionProxy, nullptr);
1287 EXPECT_NE(audioCapturerSessionProxy->audioCapturerSessionIntf_, nullptr);
1288 VideoCodecType type = static_cast<VideoCodecType>(0);
1289 int32_t retCode = audioCapturerSessionProxy->CreateAudioSession();
1290 EXPECT_EQ(retCode, 0);
1291 int32_t colorSpace = 0;
1292 retCode = aVCodecTaskManagerProxy->CreateAvcodecTaskManager(
1293 audioCapturerSessionProxy, type, colorSpace);
1294 EXPECT_EQ(retCode, 0);
1295 int32_t captureId = 0;
1296 int64_t startTimeStamp = 0;
1297 int64_t endTimeStamp = 1;
1298 bool ret = aVCodecTaskManagerProxy->TaskManagerInsertStartTime(captureId, startTimeStamp);
1299 EXPECT_TRUE(ret);
1300 ret = aVCodecTaskManagerProxy->TaskManagerInsertEndTime(captureId, endTimeStamp);
1301 EXPECT_TRUE(ret);
1302
1303 aVCodecTaskManagerProxy->avcodecTaskManagerIntf_ = nullptr;
1304 ret = aVCodecTaskManagerProxy->TaskManagerInsertStartTime(captureId, startTimeStamp);
1305 EXPECT_FALSE(ret);
1306 ret = aVCodecTaskManagerProxy->TaskManagerInsertEndTime(captureId, endTimeStamp);
1307 EXPECT_FALSE(ret);
1308 MEDIA_INFO_LOG("CameraMovingPhotoProxy_Test_004 End");
1309 }
1310
1311 /*
1312 * Feature: AvcodecTaskManagerProxy
1313 * Function: Test isEmptyVideoFdMap
1314 * SubFunction: NA
1315 * FunctionPoints: NA
1316 * EnvConditions: NA
1317 * CaseDescription: Test isEmptyVideoFdMap
1318 */
1319 HWTEST_F(CameraCommonUtilsUnitTest, CameraMovingPhotoProxy_Test_005, TestSize.Level0)
1320 {
1321 MEDIA_INFO_LOG("CameraMovingPhotoProxy_Test_005 Start");
1322 auto aVCodecTaskManagerProxy = AvcodecTaskManagerProxy::CreateAvcodecTaskManagerProxy();
1323 ASSERT_NE(aVCodecTaskManagerProxy, nullptr);
1324 EXPECT_NE(aVCodecTaskManagerProxy->avcodecTaskManagerIntf_, nullptr);
1325
1326 auto audioCapturerSessionProxy = AudioCapturerSessionProxy::CreateAudioCapturerSessionProxy();
1327 ASSERT_NE(audioCapturerSessionProxy, nullptr);
1328 EXPECT_NE(audioCapturerSessionProxy->audioCapturerSessionIntf_, nullptr);
1329 VideoCodecType type = static_cast<VideoCodecType>(0);
1330 int32_t retCode = audioCapturerSessionProxy->CreateAudioSession();
1331 EXPECT_EQ(retCode, 0);
1332 int32_t colorSpace = 0;
1333 retCode = aVCodecTaskManagerProxy->CreateAvcodecTaskManager(
1334 audioCapturerSessionProxy, type, colorSpace);
1335 EXPECT_EQ(retCode, 0);
1336 auto ret = aVCodecTaskManagerProxy->isEmptyVideoFdMap();
1337 EXPECT_EQ(ret, true);
1338 MEDIA_INFO_LOG("CameraMovingPhotoProxy_Test_005 End");
1339 }
1340
1341 /*
1342 * Feature: AvcodecTaskManagerProxy
1343 * Function: Test AvcodecTaskManager
1344 * SubFunction: NA
1345 * FunctionPoints: NA
1346 * EnvConditions: NA
1347 * CaseDescription: Test AvcodecTaskManager when param is noraml.
1348 */
1349 HWTEST_F(CameraCommonUtilsUnitTest, CameraMovingPhotoProxy_Test_006, TestSize.Level0)
1350 {
1351 MEDIA_INFO_LOG("CameraMovingPhotoProxy_Test_006 Start");
1352 auto aVCodecTaskManagerProxy = AvcodecTaskManagerProxy::CreateAvcodecTaskManagerProxy();
1353 ASSERT_NE(aVCodecTaskManagerProxy, nullptr);
1354 EXPECT_NE(aVCodecTaskManagerProxy->avcodecTaskManagerIntf_, nullptr);
1355
1356 auto audioCapturerSessionProxy = AudioCapturerSessionProxy::CreateAudioCapturerSessionProxy();
1357 ASSERT_NE(audioCapturerSessionProxy, nullptr);
1358 EXPECT_NE(audioCapturerSessionProxy->audioCapturerSessionIntf_, nullptr);
1359 int32_t retCode = audioCapturerSessionProxy->CreateAudioSession();
1360 EXPECT_EQ(retCode, 0);
1361 VideoCodecType type = static_cast<VideoCodecType>(0);
1362 int32_t colorSpace = 0;
1363 retCode = aVCodecTaskManagerProxy->CreateAvcodecTaskManager(
1364 audioCapturerSessionProxy, type, colorSpace);
1365 EXPECT_EQ(retCode, 0);
1366 std::vector<sptr<FrameRecord>> frameRecords;
1367 uint64_t taskName = 0;
1368 int32_t rotation = 0;
1369 int32_t captureId = 0;
1370 aVCodecTaskManagerProxy->DoMuxerVideo(frameRecords, taskName, rotation, captureId);
1371 sptr<SurfaceBuffer> videoBuffer = SurfaceBuffer::Create();
1372 ASSERT_NE(videoBuffer, nullptr);
1373 int64_t timestamp = VIDEO_FRAMERATE;
1374 GraphicTransformType graphicType = GRAPHIC_ROTATE_90;
1375 sptr<FrameRecord> frameRecord =
1376 new(std::nothrow) FrameRecord(videoBuffer, timestamp, graphicType);
1377 CacheCbFunc cacheCallback;
1378 aVCodecTaskManagerProxy->EncodeVideoBuffer(frameRecord, cacheCallback);
1379 uint32_t preBufferCount = 0;
1380 uint32_t postBufferCount = 0;
1381 aVCodecTaskManagerProxy->SetVideoBufferDuration(preBufferCount, postBufferCount);
1382 timestamp = 0;
1383 std::shared_ptr<PhotoAssetIntf> photoAssetProxy;
1384 captureId = 0;
1385 aVCodecTaskManagerProxy->SetVideoFd(timestamp, photoAssetProxy, captureId);
1386 MEDIA_INFO_LOG("CameraMovingPhotoProxy_Test_006 End");
1387 }
1388
1389 /*
1390 * Feature: AvcodecTaskManagerProxy
1391 * Function: Test AvcodecTaskManager
1392 * SubFunction: NA
1393 * FunctionPoints: NA
1394 * EnvConditions: NA
1395 * CaseDescription: Test AvcodecTaskManager when param is nullptr.
1396 */
1397 HWTEST_F(CameraCommonUtilsUnitTest, CameraMovingPhotoProxy_Test_007, TestSize.Level0)
1398 {
1399 MEDIA_INFO_LOG("CameraMovingPhotoProxy_Test_019 Start");
1400 auto aVCodecTaskManagerProxy = AvcodecTaskManagerProxy::CreateAvcodecTaskManagerProxy();
1401 ASSERT_NE(aVCodecTaskManagerProxy, nullptr);
1402 EXPECT_NE(aVCodecTaskManagerProxy->avcodecTaskManagerIntf_, nullptr);
1403
1404 aVCodecTaskManagerProxy->avcodecTaskManagerIntf_ = nullptr;
1405 std::vector<sptr<FrameRecord>> frameRecords;
1406 aVCodecTaskManagerProxy->DoMuxerVideo(frameRecords, 0, 0, 0);
1407 sptr<SurfaceBuffer> videoBuffer = SurfaceBuffer::Create();
1408 ASSERT_NE(videoBuffer, nullptr);
1409 int64_t timestamp = VIDEO_FRAMERATE;
1410 GraphicTransformType type = GRAPHIC_ROTATE_90;
1411 sptr<FrameRecord> frameRecord =
1412 new(std::nothrow) FrameRecord(videoBuffer, timestamp, type);
1413 CacheCbFunc cacheCallback;
1414 aVCodecTaskManagerProxy->EncodeVideoBuffer(frameRecord, cacheCallback);
1415 std::shared_ptr<PhotoAssetIntf> photoAssetProxy;
1416 aVCodecTaskManagerProxy->SetVideoFd(0, photoAssetProxy, 0);
1417 aVCodecTaskManagerProxy->SetVideoBufferDuration(0, 0);
1418 int32_t ret = aVCodecTaskManagerProxy->isEmptyVideoFdMap();
1419 EXPECT_EQ(ret, true);
1420 MEDIA_INFO_LOG("CameraMovingPhotoProxy_Test_007 End");
1421 }
1422
1423 /*
1424 * Feature: PictureProxy
1425 * Function: Test PictureProxy related interface
1426 * SubFunction: NA
1427 * FunctionPoints: NA
1428 * EnvConditions: NA
1429 * CaseDescription: Test PictureProxy related interface when param is nullptr.
1430 */
1431 HWTEST_F(CameraCommonUtilsUnitTest, CameraPictureProxy_Test_001, TestSize.Level0)
1432 {
1433 MEDIA_INFO_LOG("CameraPictureProxy_Test_001 Start");
1434 auto pictureProxy = PictureProxy::CreatePictureProxy();
1435 ASSERT_NE(pictureProxy, nullptr);
1436
1437 pictureProxy->pictureIntf_ = nullptr;
1438 sptr<SurfaceBuffer> surfaceBuffer = SurfaceBuffer::Create();
1439 pictureProxy->CreateWithDeepCopySurfaceBuffer(surfaceBuffer);
1440 pictureProxy->SetAuxiliaryPicture(surfaceBuffer, static_cast<CameraAuxiliaryPictureType>(0));
1441
1442 Parcel data;
1443 bool isMarshalling = pictureProxy->Marshalling(data);
1444 EXPECT_FALSE(isMarshalling);
1445
1446 pictureProxy->UnmarshallingPicture(data);
1447 MEDIA_INFO_LOG("CameraPictureProxy_Test_001 End");
1448 }
1449
1450 /*
1451 * Feature: PictureProxy
1452 * Function: Test SetExifMetadata and SetMaintenanceData
1453 * SubFunction: NA
1454 * FunctionPoints: NA
1455 * EnvConditions: NA
1456 * CaseDescription: Test SetExifMetadata and SetMaintenanceData when param is nullptr.
1457 */
1458 HWTEST_F(CameraCommonUtilsUnitTest, CameraPictureProxy_Test_002, TestSize.Level0)
1459 {
1460 MEDIA_INFO_LOG("CameraPictureProxy_Test_002 Start");
1461 auto pictureProxy = PictureProxy::CreatePictureProxy();
1462 ASSERT_NE(pictureProxy, nullptr);
1463 pictureProxy->pictureIntf_ = nullptr;
1464 sptr<SurfaceBuffer> surfaceBuffer1 = SurfaceBuffer::Create();
1465 int32_t retCode = pictureProxy->SetExifMetadata(surfaceBuffer1);
1466 EXPECT_EQ(retCode, -1);
1467 sptr<SurfaceBuffer> surfaceBuffer2 = SurfaceBuffer::Create();
1468 bool ret = pictureProxy->SetMaintenanceData(surfaceBuffer2);
1469 EXPECT_FALSE(ret);
1470 pictureProxy->RotatePicture();
1471 MEDIA_INFO_LOG("CameraPictureProxy_Test_002 End");
1472 }
1473
1474 /*
1475 * Feature: PictureProxy
1476 * Function: Test SetExifMetadata and SetMaintenanceData
1477 * SubFunction: NA
1478 * FunctionPoints: NA
1479 * EnvConditions: NA
1480 * CaseDescription: Test SetExifMetadata and SetMaintenanceData when param is normal.
1481 */
1482 HWTEST_F(CameraCommonUtilsUnitTest, CameraPictureProxy_Test_003, TestSize.Level0)
1483 {
1484 MEDIA_INFO_LOG("CameraPictureProxy_Test_003 Start");
1485 auto pictureProxy = PictureProxy::CreatePictureProxy();
1486 ASSERT_NE(pictureProxy, nullptr);
1487 ASSERT_NE(pictureProxy->pictureIntf_, nullptr);
1488
1489 sptr<SurfaceBuffer> pictureSurfaceBuffer = SurfaceBuffer::Create();
1490 pictureProxy->Create(pictureSurfaceBuffer);
1491
1492 sptr<SurfaceBuffer> surfaceBuffer1 = SurfaceBuffer::Create();
1493 pictureProxy->SetExifMetadata(surfaceBuffer1);
1494 sptr<SurfaceBuffer> surfaceBuffer2 = SurfaceBuffer::Create();
1495 bool ret = pictureProxy->SetMaintenanceData(surfaceBuffer2);
1496 EXPECT_TRUE(ret);
1497 pictureProxy->RotatePicture();
1498 MEDIA_INFO_LOG("CameraPictureProxy_Test_003 End");
1499 }
1500
1501 /*
1502 * Feature: PictureProxy
1503 * Function: Test PictureProxy related interface
1504 * SubFunction: NA
1505 * FunctionPoints: NA
1506 * EnvConditions: NA
1507 * CaseDescription: Test PictureProxy related interface when param is normal.
1508 */
1509 HWTEST_F(CameraCommonUtilsUnitTest, CameraPictureProxy_Test_004, TestSize.Level0)
1510 {
1511 MEDIA_INFO_LOG("CameraPictureProxy_Test_004 Start");
1512 auto pictureProxy = PictureProxy::CreatePictureProxy();
1513 ASSERT_NE(pictureProxy, nullptr);
1514 ASSERT_NE(pictureProxy->pictureIntf_, nullptr);
1515
1516 sptr<SurfaceBuffer> pictureSurfaceBuffer = SurfaceBuffer::Create();
1517 pictureProxy->Create(pictureSurfaceBuffer);
1518
1519 sptr<SurfaceBuffer> surfaceBuffer = SurfaceBuffer::Create();
1520 pictureProxy->CreateWithDeepCopySurfaceBuffer(surfaceBuffer);
1521 pictureProxy->SetAuxiliaryPicture(surfaceBuffer, static_cast<CameraAuxiliaryPictureType>(0));
1522
1523 Parcel data;
1524 pictureProxy->Marshalling(data);
1525 pictureProxy->UnmarshallingPicture(data);
1526 MEDIA_INFO_LOG("CameraPictureProxy_Test_004 End");
1527 }
1528 } // namespace CameraStandard
1529 } // namespace OHOS