1 /*
2 * Copyright (c) 2021-2022 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
16 #include "camera_framework_unittest.h"
17 #include "camera_util.h"
18 #include "gmock/gmock.h"
19 #include "input/camera_input.h"
20 #include "surface.h"
21 #include "test_common.h"
22
23 #include "ipc_skeleton.h"
24 #include "access_token.h"
25 #include "hap_token_info.h"
26 #include "accesstoken_kit.h"
27 #include "token_setproc.h"
28 #include "metadata_utils.h"
29 #include "nativetoken_kit.h"
30
31 using namespace testing::ext;
32 using ::testing::A;
33 using ::testing::InSequence;
34 using ::testing::Mock;
35 using ::testing::Return;
36 using ::testing::_;
37
38 namespace OHOS {
39 namespace CameraStandard {
40 using namespace OHOS::HDI::Camera::V1_0;
41 class MockStreamOperator : public IStreamOperator {
42 public:
MockStreamOperator()43 MockStreamOperator()
44 {
45 ON_CALL(*this, CreateStreams(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
46 ON_CALL(*this, ReleaseStreams(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
47 ON_CALL(*this, CommitStreams(_, _)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
48 ON_CALL(*this, Capture(_, _, _)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
49 ON_CALL(*this, CancelCapture(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
50 ON_CALL(*this, IsStreamsSupported(_, _, A<const std::shared_ptr<StreamInfo> &>(), _))
51 .WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
52 ON_CALL(*this, IsStreamsSupported(_, _, A<const std::vector<StreamInfo> &>(), _))
53 .WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
54 ON_CALL(*this, GetStreamAttributes(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
55 ON_CALL(*this, AttachBufferQueue(_, _)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
56 ON_CALL(*this, DetachBufferQueue(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
57 ON_CALL(*this, ChangeToOfflineStream(_, _, _)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
58 }
~MockStreamOperator()59 ~MockStreamOperator() {}
60 MOCK_METHOD1(CreateStreams, int32_t(
61 const std::vector<StreamInfo>& streamInfos));
62 MOCK_METHOD1(ReleaseStreams, int32_t(const std::vector<int32_t>& streamIds));
63 MOCK_METHOD1(CancelCapture, int32_t(int32_t captureId));
64 MOCK_METHOD1(GetStreamAttributes, int32_t(
65 std::vector<StreamAttribute>& attributes));
66 MOCK_METHOD1(DetachBufferQueue, int32_t(int32_t streamId));
67 MOCK_METHOD2(CommitStreams, int32_t(OperationMode mode, const std::vector<uint8_t>& modeSetting));
68 MOCK_METHOD2(AttachBufferQueue, int32_t(int32_t streamId,
69 const sptr<BufferProducerSequenceable>& bufferProducer));
70 MOCK_METHOD3(Capture, int32_t(int32_t captureId, const CaptureInfo& info, bool isStreaming));
71 MOCK_METHOD3(ChangeToOfflineStream, int32_t(const std::vector<int32_t>& streamIds,
72 const sptr<IStreamOperatorCallback>& callbackObj, sptr<IOfflineStreamOperator>& offlineOperator));
73 MOCK_METHOD4(IsStreamsSupported, int32_t(OperationMode mode,
74 const std::shared_ptr<OHOS::Camera::CameraMetadata> &modeSetting,
75 const std::shared_ptr<StreamInfo> &info, StreamSupportType &type));
76 MOCK_METHOD4(IsStreamsSupported, int32_t(OperationMode mode, const std::vector<uint8_t>& modeSetting,
77 const std::vector<StreamInfo>& infos, StreamSupportType& type));
78 };
79
80 class MockCameraDevice : public ICameraDevice {
81 public:
MockCameraDevice()82 MockCameraDevice()
83 {
84 streamOperator = new MockStreamOperator();
85 ON_CALL(*this, GetStreamOperator).WillByDefault([this](
86 const OHOS::sptr<IStreamOperatorCallback> &callback,
87 OHOS::sptr<IStreamOperator> &pStreamOperator) {
88 pStreamOperator = streamOperator;
89 return HDI::Camera::V1_0::NO_ERROR;
90 });
91 ON_CALL(*this, UpdateSettings(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
92 ON_CALL(*this, SetResultMode(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
93 ON_CALL(*this, GetEnabledResults(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
94 ON_CALL(*this, EnableResult(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
95 ON_CALL(*this, DisableResult(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
96 ON_CALL(*this, Open()).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
97 ON_CALL(*this, Close()).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
98 }
~MockCameraDevice()99 ~MockCameraDevice() {}
100 MOCK_METHOD0(Open, int32_t());
101 MOCK_METHOD0(Close, int32_t());
102 MOCK_METHOD1(UpdateSettings, int32_t(const std::vector<uint8_t>& settings));
103 MOCK_METHOD1(SetResultMode, int32_t(ResultCallbackMode mode));
104 MOCK_METHOD1(GetEnabledResults, int32_t(std::vector<int32_t>& results));
105 MOCK_METHOD1(EnableResult, int32_t(const std::vector<int32_t>& results));
106 MOCK_METHOD1(DisableResult, int32_t(const std::vector<int32_t>& results));
107 MOCK_METHOD2(GetStreamOperator, int32_t(const sptr<IStreamOperatorCallback>& callbackObj,
108 sptr<IStreamOperator>& streamOperator));
109 sptr<MockStreamOperator> streamOperator;
110 };
111
112 class MockHCameraHostManager : public HCameraHostManager {
113 public:
MockHCameraHostManager(StatusCallback * statusCallback)114 explicit MockHCameraHostManager(StatusCallback* statusCallback) : HCameraHostManager(statusCallback)
115 {
116 cameraDevice = new MockCameraDevice();
117 ON_CALL(*this, GetCameras).WillByDefault([this](std::vector<std::string> &cameraIds) {
118 cameraIds.emplace_back("cam0");
119 return CAMERA_OK;
120 });
121 ON_CALL(*this, GetCameraAbility).WillByDefault([this](std::string &cameraId,
122 std::shared_ptr<OHOS::Camera::CameraMetadata> &ability) {
123 int32_t itemCount = 10;
124 int32_t dataSize = 100;
125 ability = std::make_shared<OHOS::Camera::CameraMetadata>(itemCount, dataSize);
126 int32_t streams[9] = {
127 OHOS_CAMERA_FORMAT_YCRCB_420_SP, CameraFrameworkUnitTest::PREVIEW_DEFAULT_WIDTH,
128 CameraFrameworkUnitTest::PREVIEW_DEFAULT_HEIGHT, OHOS_CAMERA_FORMAT_YCRCB_420_SP,
129 CameraFrameworkUnitTest::VIDEO_DEFAULT_WIDTH, CameraFrameworkUnitTest::VIDEO_DEFAULT_HEIGHT,
130 OHOS_CAMERA_FORMAT_JPEG, CameraFrameworkUnitTest::PHOTO_DEFAULT_WIDTH,
131 CameraFrameworkUnitTest::PHOTO_DEFAULT_HEIGHT
132 };
133 ability->addEntry(OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, streams,
134 sizeof(streams) / sizeof(streams[0]));
135 int32_t compensationRange[2] = {-2, 3};
136 ability->addEntry(OHOS_CONTROL_AE_COMPENSATION_RANGE, compensationRange,
137 sizeof(compensationRange) / sizeof(compensationRange[0]));
138 float focalLength = 1.5;
139 ability->addEntry(OHOS_ABILITY_FOCAL_LENGTH, &focalLength, sizeof(float));
140 return CAMERA_OK;
141 });
142 ON_CALL(*this, OpenCameraDevice).WillByDefault([this](std::string &cameraId,
143 const sptr<ICameraDeviceCallback> &callback,
144 sptr<ICameraDevice> &pDevice) {
145 pDevice = cameraDevice;
146 return CAMERA_OK;
147 });
148 ON_CALL(*this, SetFlashlight(_, _)).WillByDefault(Return(CAMERA_OK));
149 ON_CALL(*this, SetCallback(_)).WillByDefault(Return(CAMERA_OK));
150 }
~MockHCameraHostManager()151 ~MockHCameraHostManager() {}
152 MOCK_METHOD1(GetCameras, int32_t(std::vector<std::string> &cameraIds));
153 MOCK_METHOD1(SetCallback, int32_t(sptr<ICameraHostCallback> &callback));
154 MOCK_METHOD2(GetCameraAbility, int32_t(std::string &cameraId,
155 std::shared_ptr<OHOS::Camera::CameraMetadata> &ability));
156 MOCK_METHOD2(SetFlashlight, int32_t(const std::string &cameraId, bool isEnable));
157 MOCK_METHOD3(OpenCameraDevice, int32_t(std::string &cameraId,
158 const sptr<ICameraDeviceCallback> &callback, sptr<ICameraDevice> &pDevice));
159 sptr<MockCameraDevice> cameraDevice;
160 };
161
162 class FakeHCameraService : public HCameraService {
163 public:
FakeHCameraService(sptr<HCameraHostManager> hostManager)164 explicit FakeHCameraService(sptr<HCameraHostManager> hostManager) : HCameraService(hostManager) {}
~FakeHCameraService()165 ~FakeHCameraService() {}
166 };
167
168 class FakeCameraManager : public CameraManager {
169 public:
FakeCameraManager(sptr<HCameraService> service)170 explicit FakeCameraManager(sptr<HCameraService> service) : CameraManager(service) {}
~FakeCameraManager()171 ~FakeCameraManager() {}
172 };
173
CreatePhotoOutput(int32_t width,int32_t height)174 sptr<CaptureOutput> CameraFrameworkUnitTest::CreatePhotoOutput(int32_t width, int32_t height)
175 {
176 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
177 if (surface == nullptr) {
178 return nullptr;
179 }
180 CameraFormat photoFormat = CAMERA_FORMAT_JPEG;
181 Size photoSize;
182 photoSize.width = width;
183 photoSize.height = height;
184 Profile photoProfile = Profile(photoFormat, photoSize);
185 return cameraManager->CreatePhotoOutput(photoProfile, surface);
186 }
187
CreatePreviewOutput(int32_t width,int32_t height)188 sptr<CaptureOutput> CameraFrameworkUnitTest::CreatePreviewOutput(int32_t width, int32_t height)
189 {
190 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
191 if (surface == nullptr) {
192 return nullptr;
193 }
194 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
195 Size previewSize;
196 previewSize.width = width;
197 previewSize.height = height;
198 Profile previewProfile = Profile(previewFormat, previewSize);
199 return cameraManager->CreatePreviewOutput(previewProfile, surface);
200 }
201
CreateVideoOutput(int32_t width,int32_t height)202 sptr<CaptureOutput> CameraFrameworkUnitTest::CreateVideoOutput(int32_t width, int32_t height)
203 {
204 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
205 if (surface == nullptr) {
206 return nullptr;
207 }
208 CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
209 Size videoSize;
210 videoSize.width = width;
211 videoSize.height = height;
212 std::vector<int32_t> videoFramerates = {30, 30};
213 VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates);
214 return cameraManager->CreateVideoOutput(videoProfile, surface);
215 }
216
SetUpTestCase(void)217 void CameraFrameworkUnitTest::SetUpTestCase(void) {}
218
TearDownTestCase(void)219 void CameraFrameworkUnitTest::TearDownTestCase(void) {}
220
SetUp()221 void CameraFrameworkUnitTest::SetUp()
222 {
223 // set native token
224 uint64_t tokenId;
225 const char *perms[2];
226 perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
227 perms[1] = "ohos.permission.CAMERA";
228 NativeTokenInfoParams infoInstance = {
229 .dcapsNum = 0,
230 .permsNum = 2,
231 .aclsNum = 0,
232 .dcaps = NULL,
233 .perms = perms,
234 .acls = NULL,
235 .processName = "native_camera_tdd",
236 .aplStr = "system_basic",
237 };
238 tokenId = GetAccessTokenId(&infoInstance);
239 SetSelfTokenID(tokenId);
240 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
241
242 mockCameraHostManager = new MockHCameraHostManager(nullptr);
243 mockCameraDevice = mockCameraHostManager->cameraDevice;
244 mockStreamOperator = mockCameraDevice->streamOperator;
245 cameraManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager));
246 }
247
TearDown()248 void CameraFrameworkUnitTest::TearDown()
249 {
250 Mock::AllowLeak(mockCameraHostManager);
251 Mock::AllowLeak(mockCameraDevice);
252 Mock::AllowLeak(mockStreamOperator);
253 }
254
255 MATCHER_P(matchCaptureSetting, captureSetting, "Match Capture Setting")
256 {
257 std::vector<uint8_t> result;
258 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(captureSetting, result);
259 return (arg.captureSetting_ == result);
260 }
261
262 /*
263 * Feature: Framework
264 * Function: Test get cameras
265 * SubFunction: NA
266 * FunctionPoints: NA
267 * EnvConditions: NA
268 * CaseDescription: Test get cameras
269 */
270 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_001, TestSize.Level0)
271 {
272 InSequence s;
273 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
274 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
275 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
276 ASSERT_TRUE(cameras.size() != 0);
277 }
278
279 /*
280 * Feature: Framework
281 * Function: Test create input
282 * SubFunction: NA
283 * FunctionPoints: NA
284 * EnvConditions: NA
285 * CaseDescription: Test create input
286 */
287 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_002, TestSize.Level0)
288 {
289 InSequence s;
290 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
291 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
292 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
293 ASSERT_TRUE(cameras.size() != 0);
294 sptr<CameraInput> input = cameraManager->CreateCameraInput(cameras[0]);
295 ASSERT_NE(input, nullptr);
296
297 ASSERT_NE(input->GetCameraDevice(), nullptr);
298
299 input->Release();
300 }
301
302 /*
303 * Feature: Framework
304 * Function: Test create session
305 * SubFunction: NA
306 * FunctionPoints: NA
307 * EnvConditions: NA
308 * CaseDescription: Test create session
309 */
310 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_003, TestSize.Level0)
311 {
312 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
313 ASSERT_NE(session, nullptr);
314 session->Release();
315 }
316
317 /*
318 * Feature: Framework
319 * Function: Test create preview output
320 * SubFunction: NA
321 * FunctionPoints: NA
322 * EnvConditions: NA
323 * CaseDescription: Test create preview output
324 */
325 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_004, TestSize.Level0)
326 {
327 int32_t width = PREVIEW_DEFAULT_WIDTH;
328 int32_t height = PREVIEW_DEFAULT_HEIGHT;
329 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
330 Size previewSize;
331 previewSize.width = width;
332 previewSize.height = height;
333 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
334 Profile previewProfile = Profile(previewFormat, previewSize);
335 sptr<CaptureOutput> preview = cameraManager->CreatePreviewOutput(previewProfile, surface);
336 ASSERT_NE(preview, nullptr);
337 preview->Release();
338 }
339
340 /*
341 * Feature: Framework
342 * Function: Test create preview output with surface as null
343 * SubFunction: NA
344 * FunctionPoints: NA
345 * EnvConditions: NA
346 * CaseDescription: Test create preview output with surface as null
347 */
348 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_005, TestSize.Level0)
349 {
350 int32_t width = PREVIEW_DEFAULT_WIDTH;
351 int32_t height = PREVIEW_DEFAULT_HEIGHT;
352 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
353 Size previewSize;
354 previewSize.width = width;
355 previewSize.height = height;
356 Profile previewProfile = Profile(previewFormat, previewSize);
357 sptr<Surface> surface = nullptr;
358 sptr<CaptureOutput> preview = cameraManager->CreatePreviewOutput(previewProfile, surface);
359 ASSERT_EQ(preview, nullptr);
360 }
361
362
363 /*
364 * Feature: Framework
365 * Function: Test create photo output
366 * SubFunction: NA
367 * FunctionPoints: NA
368 * EnvConditions: NA
369 * CaseDescription: Test create photo output
370 */
371 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_011, TestSize.Level0)
372 {
373 int32_t width = PHOTO_DEFAULT_WIDTH;
374 int32_t height = PHOTO_DEFAULT_HEIGHT;
375 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
376 CameraFormat photoFormat = CAMERA_FORMAT_JPEG;
377 Size photoSize;
378 photoSize.width = width;
379 photoSize.height = height;
380 Profile photoProfile = Profile(photoFormat, photoSize);
381 sptr<PhotoOutput> photo = cameraManager->CreatePhotoOutput(photoProfile, surface);
382 ASSERT_NE(photo, nullptr);
383 photo->Release();
384 }
385
386 /*
387 * Feature: Framework
388 * Function: Test create photo output with surface as null
389 * SubFunction: NA
390 * FunctionPoints: NA
391 * EnvConditions: NA
392 * CaseDescription: Test create photo output with surface as null
393 */
394 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_012, TestSize.Level0)
395 {
396 int32_t width = PHOTO_DEFAULT_WIDTH;
397 int32_t height = PHOTO_DEFAULT_HEIGHT;
398 CameraFormat photoFormat = CAMERA_FORMAT_JPEG;
399 Size photoSize;
400 photoSize.width = width;
401 photoSize.height = height;
402 Profile photoProfile = Profile(photoFormat, photoSize);
403 sptr<Surface> surface = nullptr;
404 sptr<PhotoOutput> photo = cameraManager->CreatePhotoOutput(photoProfile, surface);
405 ASSERT_EQ(photo, nullptr);
406 }
407
408 /*
409 * Feature: Framework
410 * Function: Test create video output
411 * SubFunction: NA
412 * FunctionPoints: NA
413 * EnvConditions: NA
414 * CaseDescription: Test create video output
415 */
416 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_015, TestSize.Level0)
417 {
418 int32_t width = VIDEO_DEFAULT_WIDTH;
419 int32_t height = VIDEO_DEFAULT_HEIGHT;
420 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
421 CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
422 Size videoSize;
423 videoSize.width = width;
424 videoSize.height = height;
425 std::vector<int32_t> videoFramerates = {30, 30};
426 VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates);
427 sptr<VideoOutput> video = cameraManager->CreateVideoOutput(videoProfile, surface);
428 ASSERT_NE(video, nullptr);
429 video->Release();
430 }
431
432 /*
433 * Feature: Framework
434 * Function: Test create video output with surface as null
435 * SubFunction: NA
436 * FunctionPoints: NA
437 * EnvConditions: NA
438 * CaseDescription: Test create video output with surface as null
439 */
440 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_016, TestSize.Level0)
441 {
442 int32_t width = VIDEO_DEFAULT_WIDTH;
443 int32_t height = VIDEO_DEFAULT_HEIGHT;
444 CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
445 sptr<Surface> surface = nullptr;
446 Size videoSize;
447 videoSize.width = width;
448 videoSize.height = height;
449 std::vector<int32_t> videoFramerates = {30, 30};
450 VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates);
451 sptr<VideoOutput> video = cameraManager->CreateVideoOutput(videoProfile, surface);
452 ASSERT_EQ(video, nullptr);
453 }
454
455 /*
456 * Feature: Framework
457 * Function: Test manager callback
458 * SubFunction: NA
459 * FunctionPoints: NA
460 * EnvConditions: NA
461 * CaseDescription: Test manager callback
462 */
463 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_019, TestSize.Level0)
464 {
465 std::shared_ptr<TestCameraMngerCallback> setCallback = std::make_shared<TestCameraMngerCallback>("MgrCallback");
466 cameraManager->SetCallback(setCallback);
467 std::shared_ptr<CameraManagerCallback> getCallback = cameraManager->GetApplicationCallback();
468 ASSERT_EQ(setCallback, getCallback);
469 }
470
471 /*
472 * Feature: Framework
473 * Function: Test set camera parameters
474 * SubFunction: NA
475 * FunctionPoints: NA
476 * EnvConditions: NA
477 * CaseDescription: Test set camera parameters zoom, focus, flash & exposure
478 */
479 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_020, TestSize.Level0)
480 {
481 InSequence s;
482 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
483 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
484 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
485
486 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
487 ASSERT_NE(input, nullptr);
488
489 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
490 ASSERT_NE(session, nullptr);
491 int32_t ret = session->AddInput(input);
492 ASSERT_NE(ret, 0);
493
494 session->LockForControl();
495
496 std::vector<float> zoomRatioRange = session->GetZoomRatioRange();
497 if (!zoomRatioRange.empty()) {
498 session->SetZoomRatio(zoomRatioRange[0]);
499 }
500
501 std::vector<int32_t> exposurebiasRange = session->GetExposureBiasRange();
502 if (!exposurebiasRange.empty()) {
503 session->SetExposureBias(exposurebiasRange[0]);
504 }
505
506 FlashMode flash = FLASH_MODE_ALWAYS_OPEN;
507 session->SetFlashMode(flash);
508
509 FocusMode focus = FOCUS_MODE_AUTO;
510 session->SetFocusMode(focus);
511
512 ExposureMode exposure = EXPOSURE_MODE_AUTO;
513 session->SetExposureMode(exposure);
514
515 session->UnlockForControl();
516
517 if (!zoomRatioRange.empty()) {
518 EXPECT_EQ(session->GetZoomRatio(), zoomRatioRange[0]);
519 }
520
521 if (!exposurebiasRange.empty()) {
522 EXPECT_EQ(session->GetExposureValue(), exposurebiasRange[0]);
523 }
524
525 EXPECT_EQ(session->GetFlashMode(), flash);
526 EXPECT_EQ(session->GetFocusMode(), focus);
527 EXPECT_EQ(session->GetExposureMode(), exposure);
528 }
529
530 /*
531 * Feature: Framework
532 * Function: Test input callback
533 * SubFunction: NA
534 * FunctionPoints: NA
535 * EnvConditions: NA
536 * CaseDescription: Test input callback
537 */
538 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_021, TestSize.Level0)
539 {
540 InSequence s;
541 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
542 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
543 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
544
545 sptr<CameraInput> input = cameraManager->CreateCameraInput(cameras[0]);
546 ASSERT_NE(input, nullptr);
547
548 std::shared_ptr<TestDeviceCallback> setCallback = std::make_shared<TestDeviceCallback>("InputCallback");
549 input->SetErrorCallback(setCallback);
550 std::shared_ptr<ErrorCallback> getCallback = input->GetErrorCallback();
551 ASSERT_EQ(setCallback, getCallback);
552 }
553
554 /*
555 * Feature: Framework
556 * Function: Test preview callback
557 * SubFunction: NA
558 * FunctionPoints: NA
559 * EnvConditions: NA
560 * CaseDescription: Test preview callback
561 */
562 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_022, TestSize.Level0)
563 {
564 sptr<CaptureOutput> preview = CreatePreviewOutput();
565 ASSERT_NE(preview, nullptr);
566
567 std::shared_ptr<PreviewStateCallback> setCallback =
568 std::make_shared<TestPreviewOutputCallback>("PreviewStateCallback");
569 ((sptr<PreviewOutput> &)preview)->SetCallback(setCallback);
570 std::shared_ptr<PreviewStateCallback> getCallback = ((sptr<PreviewOutput> &)preview)->GetApplicationCallback();
571 ASSERT_EQ(setCallback, getCallback);
572 }
573
574 /*
575 * Feature: Framework
576 * Function: Test photo callback
577 * SubFunction: NA
578 * FunctionPoints: NA
579 * EnvConditions: NA
580 * CaseDescription: Test photo callback
581 */
582 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_023, TestSize.Level0)
583 {
584 sptr<CaptureOutput> photo = CreatePhotoOutput();
585 ASSERT_NE(photo, nullptr);
586
587 std::shared_ptr<PhotoStateCallback> setCallback = std::make_shared<TestPhotoOutputCallback>("PhotoStateCallback");
588 ((sptr<PhotoOutput> &)photo)->SetCallback(setCallback);
589 std::shared_ptr<PhotoStateCallback> getCallback = ((sptr<PhotoOutput> &)photo)->GetApplicationCallback();
590 ASSERT_EQ(setCallback, getCallback);
591 }
592
593 /*
594 * Feature: Framework
595 * Function: Test video callback
596 * SubFunction: NA
597 * FunctionPoints: NA
598 * EnvConditions: NA
599 * CaseDescription: Test video callback
600 */
601 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_024, TestSize.Level0)
602 {
603 sptr<CaptureOutput> video = CreateVideoOutput();
604 ASSERT_NE(video, nullptr);
605
606 std::shared_ptr<VideoStateCallback> setCallback = std::make_shared<TestVideoOutputCallback>("VideoStateCallback");
607 ((sptr<VideoOutput> &)video)->SetCallback(setCallback);
608 std::shared_ptr<VideoStateCallback> getCallback = ((sptr<VideoOutput> &)video)->GetApplicationCallback();
609 ASSERT_EQ(setCallback, getCallback);
610 }
611
612 /*
613 * Feature: Framework
614 * Function: Test capture session add input with invalid value
615 * SubFunction: NA
616 * FunctionPoints: NA
617 * EnvConditions: NA
618 * CaseDescription: Test capture session add input with invalid value
619 */
620 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_025, TestSize.Level0)
621 {
622 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
623 ASSERT_NE(session, nullptr);
624
625 int32_t ret = session->BeginConfig();
626 EXPECT_EQ(ret, 0);
627
628 sptr<CaptureInput> input = nullptr;
629 ret = session->AddInput(input);
630 EXPECT_NE(ret, 0);
631 }
632
633 /*
634 * Feature: Framework
635 * Function: Test capture session add output with invalid value
636 * SubFunction: NA
637 * FunctionPoints: NA
638 * EnvConditions: NA
639 * CaseDescription: Test capture session add output with invalid value
640 */
641 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_026, TestSize.Level0)
642 {
643 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
644 ASSERT_NE(session, nullptr);
645
646 int32_t ret = session->BeginConfig();
647 EXPECT_EQ(ret, 0);
648
649 sptr<CaptureOutput> preview = nullptr;
650 ret = session->AddOutput(preview);
651 EXPECT_NE(ret, 0);
652 }
653
654 /*
655 * Feature: Framework
656 * Function: Test capture session commit config without adding input
657 * SubFunction: NA
658 * FunctionPoints: NA
659 * EnvConditions: NA
660 * CaseDescription: Test capture session commit config without adding input
661 */
662 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_027, TestSize.Level0)
663 {
664 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
665 ASSERT_NE(session, nullptr);
666
667 int32_t ret = session->BeginConfig();
668 EXPECT_EQ(ret, 0);
669
670 sptr<CaptureOutput> preview = CreatePreviewOutput();
671 ASSERT_NE(preview, nullptr);
672
673 ret = session->AddOutput(preview);
674 EXPECT_EQ(ret, 0);
675
676 ret = session->CommitConfig();
677 EXPECT_NE(ret, 0);
678 }
679
680 /*
681 * Feature: Framework
682 * Function: Test capture session commit config without adding output
683 * SubFunction: NA
684 * FunctionPoints: NA
685 * EnvConditions: NA
686 * CaseDescription: Test capture session commit config without adding output
687 */
688 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_028, TestSize.Level0)
689 {
690 InSequence s;
691 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
692 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
693 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
694
695 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
696 ASSERT_NE(input, nullptr);
697
698 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
699 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
700 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
701 camInput->GetCameraDevice()->Open();
702
703 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
704 ASSERT_NE(session, nullptr);
705
706 int32_t ret = session->BeginConfig();
707 EXPECT_EQ(ret, 0);
708
709 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
710 ret = session->AddInput(input);
711 EXPECT_EQ(ret, 0);
712
713 ret = session->CommitConfig();
714 EXPECT_NE(ret, 0);
715 }
716
717 /*
718 * Feature: Framework
719 * Function: Test capture session without begin config
720 * SubFunction: NA
721 * FunctionPoints: NA
722 * EnvConditions: NA
723 * CaseDescription: Test capture session without begin config
724 */
725 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_029, TestSize.Level0)
726 {
727 InSequence s;
728 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
729 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
730 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
731
732 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
733 ASSERT_NE(input, nullptr);
734
735 sptr<CaptureOutput> photo = CreatePhotoOutput();
736 ASSERT_NE(photo, nullptr);
737
738 sptr<CaptureOutput> preview = CreatePreviewOutput();
739 ASSERT_NE(preview, nullptr);
740
741 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
742 ASSERT_NE(session, nullptr);
743
744 int32_t ret = session->AddInput(input);
745 EXPECT_NE(ret, 0);
746
747 ret = session->AddOutput(preview);
748 EXPECT_NE(ret, 0);
749
750 ret = session->AddOutput(photo);
751 EXPECT_NE(ret, 0);
752
753 ret = session->CommitConfig();
754 EXPECT_NE(ret, 0);
755
756 ret = session->Start();
757 EXPECT_NE(ret, 0);
758
759 ret = ((sptr<PreviewOutput> &)preview)->Start();
760 EXPECT_NE(ret, 0);
761
762 ret = ((sptr<PhotoOutput> &)photo)->Capture();
763 EXPECT_NE(ret, 0);
764
765 ret = ((sptr<PreviewOutput> &)preview)->Stop();
766 EXPECT_NE(ret, 0);
767
768 ret = session->Stop();
769 EXPECT_NE(ret, 0);
770 }
771
772 /*
773 * Feature: Framework
774 * Function: Test capture session start and stop without adding preview output
775 * SubFunction: NA
776 * FunctionPoints: NA
777 * EnvConditions: NA
778 * CaseDescription: Test capture session start and stop without adding preview output
779 */
780 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_030, TestSize.Level0)
781 {
782 InSequence s;
783 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
784 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
785 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
786
787 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
788 ASSERT_NE(input, nullptr);
789
790 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
791 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
792 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
793 camInput->GetCameraDevice()->Open();
794
795 sptr<CaptureOutput> photo = CreatePhotoOutput();
796 ASSERT_NE(photo, nullptr);
797
798 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
799 ASSERT_NE(session, nullptr);
800
801 int32_t ret = session->BeginConfig();
802 EXPECT_EQ(ret, 0);
803
804 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
805 ret = session->AddInput(input);
806 EXPECT_EQ(ret, 0);
807
808 ret = session->AddOutput(photo);
809 EXPECT_EQ(ret, 0);
810
811 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
812 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
813 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
814 ret = session->CommitConfig();
815 EXPECT_EQ(ret, 0);
816
817 EXPECT_CALL(*mockStreamOperator, Capture(_, _, true)).Times(0);
818 ret = session->Start();
819 EXPECT_EQ(ret, 0);
820
821 EXPECT_CALL(*mockStreamOperator, CancelCapture(_)).Times(0);
822
823 ret = session->Stop();
824 EXPECT_EQ(ret, 0);
825
826 EXPECT_CALL(*mockStreamOperator, ReleaseStreams(_));
827 EXPECT_CALL(*mockCameraDevice, Close());
828 session->Release();
829 }
830
831 /*
832 * Feature: Framework
833 * Function: Test session with preview + photo
834 * SubFunction: NA
835 * FunctionPoints: NA
836 * EnvConditions: NA
837 * CaseDescription: Test session with preview + photo
838 */
839 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_031, TestSize.Level0)
840 {
841 InSequence s;
842 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
843 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
844 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
845
846 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
847 ASSERT_NE(input, nullptr);
848
849 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
850 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
851 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
852 camInput->GetCameraDevice()->Open();
853
854 sptr<CaptureOutput> preview = CreatePreviewOutput();
855 ASSERT_NE(preview, nullptr);
856
857 sptr<CaptureOutput> photo = CreatePhotoOutput();
858 ASSERT_NE(photo, nullptr);
859
860 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
861 ASSERT_NE(session, nullptr);
862
863 int32_t ret = session->BeginConfig();
864 EXPECT_EQ(ret, 0);
865
866 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
867 ret = session->AddInput(input);
868 EXPECT_EQ(ret, 0);
869
870 ret = session->AddOutput(preview);
871 EXPECT_EQ(ret, 0);
872
873 ret = session->AddOutput(photo);
874 EXPECT_EQ(ret, 0);
875
876 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
877 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
878 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
879 ret = session->CommitConfig();
880 EXPECT_EQ(ret, 0);
881
882 EXPECT_CALL(*mockStreamOperator, Capture(1, _, true));
883 ret = session->Start();
884 EXPECT_EQ(ret, 0);
885
886 EXPECT_CALL(*mockStreamOperator, Capture(2, _, false));
887 ret = ((sptr<PhotoOutput> &)photo)->Capture();
888 EXPECT_EQ(ret, 0);
889
890 EXPECT_CALL(*mockStreamOperator, CancelCapture(1));
891 ret = ((sptr<PreviewOutput> &)preview)->Stop();
892 EXPECT_EQ(ret, 0);
893
894 EXPECT_CALL(*mockStreamOperator, ReleaseStreams(_));
895 EXPECT_CALL(*mockCameraDevice, Close());
896 session->Release();
897 }
898
899 /*
900 * Feature: Framework
901 * Function: Test session with preview + photo with camera configuration
902 * SubFunction: NA
903 * FunctionPoints: NA
904 * EnvConditions: NA
905 * CaseDescription: Test session with preview + photo with camera configuration
906 */
907 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_032, TestSize.Level0)
908 {
909 InSequence s;
910 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
911 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
912 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
913
914 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
915 ASSERT_NE(input, nullptr);
916
917 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
918 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
919 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
920 camInput->GetCameraDevice()->Open();
921
922 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
923 ASSERT_NE(session, nullptr);
924
925 std::vector<float> zoomRatioRange = session->GetZoomRatioRange();
926 if (!zoomRatioRange.empty()) {
927 session->LockForControl();
928 session->SetZoomRatio(zoomRatioRange[0]);
929 session->UnlockForControl();
930 }
931
932 sptr<CaptureOutput> preview = CreatePreviewOutput();
933 ASSERT_NE(preview, nullptr);
934
935 sptr<CaptureOutput> photo = CreatePhotoOutput();
936 ASSERT_NE(photo, nullptr);
937
938 int32_t ret = session->BeginConfig();
939 EXPECT_EQ(ret, 0);
940
941 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
942 ret = session->AddInput(input);
943 EXPECT_EQ(ret, 0);
944
945 ret = session->AddOutput(preview);
946 EXPECT_EQ(ret, 0);
947
948 ret = session->AddOutput(photo);
949 EXPECT_EQ(ret, 0);
950
951 if (!zoomRatioRange.empty()) {
952 EXPECT_CALL(*mockCameraDevice, UpdateSettings(_));
953 }
954 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
955 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
956 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
957 ret = session->CommitConfig();
958 EXPECT_EQ(ret, 0);
959
960 EXPECT_CALL(*mockStreamOperator, ReleaseStreams(_));
961 EXPECT_CALL(*mockCameraDevice, Close());
962 session->Release();
963 }
964
965 /*
966 * Feature: Framework
967 * Function: Test session with preview + video
968 * SubFunction: NA
969 * FunctionPoints: NA
970 * EnvConditions: NA
971 * CaseDescription: Test session with preview + video
972 */
973 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_033, TestSize.Level0)
974 {
975 InSequence s;
976 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
977 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
978 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
979
980 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
981 ASSERT_NE(input, nullptr);
982
983 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
984 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
985 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
986 camInput->GetCameraDevice()->Open();
987
988 sptr<CaptureOutput> preview = CreatePreviewOutput();
989 ASSERT_NE(preview, nullptr);
990
991 sptr<CaptureOutput> video = CreateVideoOutput();
992 ASSERT_NE(video, nullptr);
993
994 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
995 ASSERT_NE(session, nullptr);
996
997 int32_t ret = session->BeginConfig();
998 EXPECT_EQ(ret, 0);
999
1000 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
1001 ret = session->AddInput(input);
1002 EXPECT_EQ(ret, 0);
1003
1004 ret = session->AddOutput(preview);
1005 EXPECT_EQ(ret, 0);
1006
1007 ret = session->AddOutput(video);
1008 EXPECT_EQ(ret, 0);
1009
1010 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
1011 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
1012 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
1013 ret = session->CommitConfig();
1014 EXPECT_EQ(ret, 0);
1015
1016 EXPECT_CALL(*mockStreamOperator, Capture(3, _, true));
1017 ret = session->Start();
1018 EXPECT_EQ(ret, 0);
1019
1020 EXPECT_CALL(*mockStreamOperator, Capture(4, _, true));
1021 ret = ((sptr<VideoOutput> &)video)->Start();
1022 EXPECT_EQ(ret, 0);
1023
1024 EXPECT_CALL(*mockStreamOperator, CancelCapture(4));
1025 ret = ((sptr<VideoOutput> &)video)->Stop();
1026 EXPECT_EQ(ret, 0);
1027
1028 EXPECT_CALL(*mockStreamOperator, CancelCapture(3));
1029 ret = ((sptr<PreviewOutput> &)preview)->Stop();
1030 EXPECT_EQ(ret, 0);
1031
1032 EXPECT_CALL(*mockStreamOperator, ReleaseStreams(_));
1033 EXPECT_CALL(*mockCameraDevice, Close());
1034 session->Release();
1035 ((sptr<VideoOutput> &)video)->Release();
1036 }
1037
1038 /*
1039 * Feature: Framework
1040 * Function: Test capture session remove output with null
1041 * SubFunction: NA
1042 * FunctionPoints: NA
1043 * EnvConditions: NA
1044 * CaseDescription: Test capture session remove output with null
1045 */
1046 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_034, TestSize.Level0)
1047 {
1048 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1049 ASSERT_NE(session, nullptr);
1050
1051 int32_t ret = session->BeginConfig();
1052 EXPECT_EQ(ret, 0);
1053
1054 sptr<CaptureOutput> output = nullptr;
1055 ret = session->RemoveOutput(output);
1056 EXPECT_NE(ret, 0);
1057 }
1058
1059 /*
1060 * Feature: Framework
1061 * Function: Test capture session remove output
1062 * SubFunction: NA
1063 * FunctionPoints: NA
1064 * EnvConditions: NA
1065 * CaseDescription: Test capture session remove output
1066 */
1067 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_035, TestSize.Level0)
1068 {
1069 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1070 ASSERT_NE(session, nullptr);
1071
1072 sptr<CaptureOutput> video = CreateVideoOutput();
1073 ASSERT_NE(video, nullptr);
1074
1075 int32_t ret = session->BeginConfig();
1076 EXPECT_EQ(ret, 0);
1077
1078 ret = session->AddOutput(video);
1079 EXPECT_EQ(ret, 0);
1080
1081 ret = session->RemoveOutput(video);
1082 EXPECT_EQ(ret, 0);
1083 }
1084
1085 /*
1086 * Feature: Framework
1087 * Function: Test capture session remove input with null
1088 * SubFunction: NA
1089 * FunctionPoints: NA
1090 * EnvConditions: NA
1091 * CaseDescription: Test capture session remove input with null
1092 */
1093 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_036, TestSize.Level0)
1094 {
1095 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1096 ASSERT_NE(session, nullptr);
1097
1098 int32_t ret = session->BeginConfig();
1099 EXPECT_EQ(ret, 0);
1100
1101 sptr<CaptureInput> input = nullptr;
1102 ret = session->RemoveInput(input);
1103 EXPECT_NE(ret, 0);
1104 }
1105
1106 /*
1107 * Feature: Framework
1108 * Function: Test capture session remove input
1109 * SubFunction: NA
1110 * FunctionPoints: NA
1111 * EnvConditions: NA
1112 * CaseDescription: Test capture session remove input
1113 */
1114 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_037, TestSize.Level0)
1115 {
1116 InSequence s;
1117 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1118 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1119 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1120
1121 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1122 ASSERT_NE(input, nullptr);
1123
1124 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
1125 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1126 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1127 camInput->GetCameraDevice()->Open();
1128
1129 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1130 ASSERT_NE(session, nullptr);
1131
1132 int32_t ret = session->BeginConfig();
1133 EXPECT_EQ(ret, 0);
1134
1135 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
1136 ret = session->AddInput(input);
1137 EXPECT_EQ(ret, 0);
1138
1139 ret = session->RemoveInput(input);
1140 EXPECT_EQ(ret, 0);
1141 }
1142
1143 /*
1144 * Feature: Framework
1145 * Function: Test photo capture with photo settings
1146 * SubFunction: NA
1147 * FunctionPoints: NA
1148 * EnvConditions: NA
1149 * CaseDescription: Test photo capture with photo settings
1150 */
1151 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_038, TestSize.Level0)
1152 {
1153 InSequence s;
1154 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1155 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1156 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1157
1158 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1159 ASSERT_NE(input, nullptr);
1160
1161 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
1162 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1163 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1164 camInput->GetCameraDevice()->Open();
1165
1166 sptr<CaptureOutput> photo = CreatePhotoOutput();
1167 ASSERT_NE(photo, nullptr);
1168
1169 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1170 ASSERT_NE(session, nullptr);
1171
1172 int32_t ret = session->BeginConfig();
1173 EXPECT_EQ(ret, 0);
1174
1175 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
1176 ret = session->AddInput(input);
1177 EXPECT_EQ(ret, 0);
1178
1179 ret = session->AddOutput(photo);
1180 EXPECT_EQ(ret, 0);
1181
1182 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
1183 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
1184 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
1185 ret = session->CommitConfig();
1186 EXPECT_EQ(ret, 0);
1187
1188 std::shared_ptr<PhotoCaptureSetting> photoSetting = std::make_shared<PhotoCaptureSetting>();
1189 photoSetting->SetRotation(PhotoCaptureSetting::Rotation_90);
1190 photoSetting->SetQuality(PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM);
1191 EXPECT_EQ(photoSetting->GetRotation(), PhotoCaptureSetting::Rotation_90);
1192 EXPECT_EQ(photoSetting->GetQuality(), PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM);
1193
1194 EXPECT_CALL(*mockStreamOperator, Capture(_,
1195 matchCaptureSetting(photoSetting->GetCaptureMetadataSetting()), false));
1196 ret = ((sptr<PhotoOutput> &)photo)->Capture(photoSetting);
1197 EXPECT_EQ(ret, 0);
1198
1199 EXPECT_CALL(*mockStreamOperator, ReleaseStreams(_));
1200 EXPECT_CALL(*mockCameraDevice, Close());
1201 session->Release();
1202 }
1203
1204 /*
1205 * Feature: Framework
1206 * Function: Test GetFocalLength
1207 * SubFunction: NA
1208 * FunctionPoints: NA
1209 * EnvConditions: NA
1210 * CaseDescription: Test GetFocalLength
1211 */
1212 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_040, TestSize.Level0)
1213 {
1214 InSequence s;
1215 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1216 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1217 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1218
1219 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1220 ASSERT_NE(input, nullptr);
1221
1222 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
1223 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1224 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1225 camInput->GetCameraDevice()->Open();
1226
1227 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1228 ASSERT_NE(session, nullptr);
1229
1230 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
1231 int32_t ret = session->AddInput(input);
1232 ASSERT_NE(ret, 0);
1233
1234 double focalLength = session->GetFocalLength();
1235 ASSERT_EQ(focalLength, 1.5);
1236 }
1237
1238
1239 /*
1240 * Feature: Framework
1241 * Function: Test SetMeteringPoint & GetMeteringPoint
1242 * SubFunction: NA
1243 * FunctionPoints: NA
1244 * EnvConditions: NA
1245 * CaseDescription: Test SetMeteringPoint & GetMeteringPoint
1246 */
1247 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_041, TestSize.Level0)
1248 {
1249 InSequence s;
1250 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1251 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1252 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1253
1254 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1255 ASSERT_NE(input, nullptr);
1256 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1257 ASSERT_NE(session, nullptr);
1258 int32_t ret = session->AddInput(input);
1259 ASSERT_NE(ret, 0);
1260
1261 Point exposurePoint = {1.0, 2.0};
1262 session->LockForControl();
1263 session->SetMeteringPoint(exposurePoint);
1264 session->UnlockForControl();
1265 ASSERT_EQ((session->GetMeteringPoint().x), exposurePoint.x);
1266 ASSERT_EQ((session->GetMeteringPoint().y), exposurePoint.y);
1267 }
1268
1269
1270 /*
1271 * Feature: Framework
1272 * Function: Test SetFocusPoint & GetFousPoint
1273 * SubFunction: NA
1274 * FunctionPoints: NA
1275 * EnvConditions: NA
1276 * CaseDescription: Test SetFocusPoint & GetFousPoint
1277 */
1278 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_042, TestSize.Level0)
1279 {
1280 InSequence s;
1281 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1282 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1283 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1284
1285 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1286 ASSERT_NE(input, nullptr);
1287 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1288 ASSERT_NE(session, nullptr);
1289 int32_t ret = session->AddInput(input);
1290 ASSERT_NE(ret, 0);
1291
1292 Point FocusPoint = {1.0, 2.0};
1293 session->LockForControl();
1294 session->SetFocusPoint(FocusPoint);
1295 session->UnlockForControl();
1296 ASSERT_EQ((session->GetFocusPoint().x), FocusPoint.x);
1297 ASSERT_EQ((session->GetFocusPoint().y), FocusPoint.y);
1298 }
1299
1300 /*
1301 * Feature: Framework
1302 * Function: Test GetExposureValue and SetExposureBias
1303 * SubFunction: NA
1304 * FunctionPoints: NA
1305 * EnvConditions: NA
1306 * CaseDescription: Test GetExposureValue and SetExposureBias with value less then the range
1307 */
1308 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_043, TestSize.Level0)
1309 {
1310 InSequence s;
1311 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1312 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1313 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1314
1315 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1316 ASSERT_NE(input, nullptr);
1317 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1318 ASSERT_NE(session, nullptr);
1319 int32_t ret = session->AddInput(input);
1320 ASSERT_NE(ret, 0);
1321
1322 std::vector<int32_t> exposurebiasRange = session->GetExposureBiasRange();
1323 if (!exposurebiasRange.empty()) {
1324 session->LockForControl();
1325 session->SetExposureBias(exposurebiasRange[0]-1);
1326 session->UnlockForControl();
1327 }
1328 ASSERT_EQ(session->GetExposureValue(), exposurebiasRange[0]);
1329 }
1330
1331 /*
1332 * Feature: Framework
1333 * Function: Test GetExposureValue and SetExposureBias
1334 * SubFunction: NA
1335 * FunctionPoints: NA
1336 * EnvConditions: NA
1337 * CaseDescription: Test GetExposureValue and SetExposureBias with value between the range
1338 */
1339 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_044, TestSize.Level0)
1340 {
1341 InSequence s;
1342 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1343 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1344 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1345
1346 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1347 ASSERT_NE(input, nullptr);
1348 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1349 ASSERT_NE(session, nullptr);
1350 int32_t ret = session->AddInput(input);
1351 ASSERT_NE(ret, 0);
1352
1353 std::vector<int32_t> exposurebiasRange = session->GetExposureBiasRange();
1354 if (!exposurebiasRange.empty()) {
1355 session->LockForControl();
1356 session->SetExposureBias(exposurebiasRange[0]+1);
1357 session->UnlockForControl();
1358 }
1359 EXPECT_TRUE((session->GetExposureValue()>=exposurebiasRange[0] &&
1360 session->GetExposureValue()<=exposurebiasRange[1]));
1361 }
1362
1363
1364 /*
1365 * Feature: Framework
1366 * Function: Test GetExposureValue and SetExposureBias
1367 * SubFunction: NA
1368 * FunctionPoints: NA
1369 * EnvConditions: NA
1370 * CaseDescription: Test GetExposureValue and SetExposureBias with value more then the range
1371 */
1372 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_045, TestSize.Level0)
1373 {
1374 InSequence s;
1375 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1376 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1377 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1378
1379 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1380 ASSERT_NE(input, nullptr);
1381 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1382 ASSERT_NE(session, nullptr);
1383 int32_t ret = session->AddInput(input);
1384 ASSERT_NE(ret, 0);
1385
1386 std::vector<int32_t> exposurebiasRange = session->GetExposureBiasRange();
1387 if (!exposurebiasRange.empty()) {
1388 session->LockForControl();
1389 session->SetExposureBias(exposurebiasRange[1]+1);
1390 session->UnlockForControl();
1391 }
1392 ASSERT_EQ(session->GetExposureValue(), exposurebiasRange[1]);
1393 }
1394 } // CameraStandard
1395 } // OHOS
1396