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([](std::vector<std::string> &cameraIds) {
118 cameraIds.emplace_back("cam0");
119 return CAMERA_OK;
120 });
121 ON_CALL(*this, GetCameraAbility).WillByDefault([](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[20] = {
127 CameraFrameworkUnitTest::DEFAULT_MODE, CameraFrameworkUnitTest::PREVIEW_STREAM,
128 OHOS_CAMERA_FORMAT_YCRCB_420_SP, CameraFrameworkUnitTest::PREVIEW_DEFAULT_WIDTH,
129 CameraFrameworkUnitTest::PREVIEW_DEFAULT_HEIGHT, CameraFrameworkUnitTest::PREVIEW_FRAMERATE,
130 CameraFrameworkUnitTest::STREAM_FINISH, CameraFrameworkUnitTest::VIDEO_STREAM,
131 OHOS_CAMERA_FORMAT_YCRCB_420_SP, CameraFrameworkUnitTest::VIDEO_DEFAULT_WIDTH,
132 CameraFrameworkUnitTest::VIDEO_DEFAULT_HEIGHT, CameraFrameworkUnitTest::VIDEO_FRAMERATE,
133 CameraFrameworkUnitTest::STREAM_FINISH, CameraFrameworkUnitTest::PHOTO_STREAM,
134 OHOS_CAMERA_FORMAT_JPEG, CameraFrameworkUnitTest::PHOTO_DEFAULT_WIDTH,
135 CameraFrameworkUnitTest::PHOTO_DEFAULT_HEIGHT, CameraFrameworkUnitTest::PHOTO_FRAMERATE,
136 CameraFrameworkUnitTest::STREAM_FINISH, CameraFrameworkUnitTest::MODE_FINISH
137 };
138 ability->addEntry(OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, streams,
139 sizeof(streams) / sizeof(streams[0]));
140 int32_t compensationRange[2] = {-2, 3};
141 ability->addEntry(OHOS_CONTROL_AE_COMPENSATION_RANGE, compensationRange,
142 sizeof(compensationRange) / sizeof(compensationRange[0]));
143 float focalLength = 1.5;
144 ability->addEntry(OHOS_ABILITY_FOCAL_LENGTH, &focalLength, sizeof(float));
145
146 int32_t sensorOrientation = 0;
147 ability->addEntry(OHOS_SENSOR_ORIENTATION, &sensorOrientation, sizeof(int32_t));
148
149 int32_t cameraPosition = 0;
150 ability->addEntry(OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, sizeof(int32_t));
151
152 const camera_rational_t aeCompensationStep[] = {{1, 2}};
153 ability->addEntry(OHOS_CONTROL_AE_COMPENSATION_STEP, &aeCompensationStep,
154 sizeof(aeCompensationStep) / sizeof(aeCompensationStep[0]));
155 return CAMERA_OK;
156 });
157 ON_CALL(*this, OpenCameraDevice).WillByDefault([this](std::string &cameraId,
158 const sptr<ICameraDeviceCallback> &callback,
159 sptr<OHOS::HDI::Camera::V1_1::ICameraDevice> &pDevice) {
160 sptr<ICameraDevice> tempDevice;
161 tempDevice = static_cast<ICameraDevice *>(cameraDevice.GetRefPtr());
162 // static_cast to V1.1
163 pDevice = static_cast<OHOS::HDI::Camera::V1_1::ICameraDevice *>(tempDevice.GetRefPtr());
164 return CAMERA_OK;
165 });
166 ON_CALL(*this, SetFlashlight(_, _)).WillByDefault(Return(CAMERA_OK));
167 ON_CALL(*this, SetCallback(_)).WillByDefault(Return(CAMERA_OK));
168 }
~MockHCameraHostManager()169 ~MockHCameraHostManager() {}
170 MOCK_METHOD1(GetCameras, int32_t(std::vector<std::string> &cameraIds));
171 MOCK_METHOD1(SetCallback, int32_t(sptr<ICameraHostCallback> &callback));
172 MOCK_METHOD2(GetCameraAbility, int32_t(std::string &cameraId,
173 std::shared_ptr<OHOS::Camera::CameraMetadata> &ability));
174 MOCK_METHOD2(SetFlashlight, int32_t(const std::string &cameraId, bool isEnable));
175 MOCK_METHOD3(OpenCameraDevice, int32_t(std::string &cameraId,
176 const sptr<ICameraDeviceCallback> &callback, sptr<OHOS::HDI::Camera::V1_1::ICameraDevice> &pDevice));
177 sptr<MockCameraDevice> cameraDevice;
178 };
179
180 class FakeHCameraService : public HCameraService {
181 public:
FakeHCameraService(sptr<HCameraHostManager> hostManager)182 explicit FakeHCameraService(sptr<HCameraHostManager> hostManager) : HCameraService(hostManager) {}
~FakeHCameraService()183 ~FakeHCameraService() {}
184 };
185
186 class FakeCameraManager : public CameraManager {
187 public:
FakeCameraManager(sptr<HCameraService> service)188 explicit FakeCameraManager(sptr<HCameraService> service) : CameraManager(service) {}
~FakeCameraManager()189 ~FakeCameraManager() {}
190 };
191
CreatePhotoOutput(int32_t width,int32_t height)192 sptr<CaptureOutput> CameraFrameworkUnitTest::CreatePhotoOutput(int32_t width, int32_t height)
193 {
194 sptr<IConsumerSurface> surface = IConsumerSurface::Create();
195 if (surface == nullptr) {
196 return nullptr;
197 }
198 CameraFormat photoFormat = CAMERA_FORMAT_JPEG;
199 Size photoSize;
200 photoSize.width = width;
201 photoSize.height = height;
202 Profile photoProfile = Profile(photoFormat, photoSize);
203 sptr<IBufferProducer> surfaceProducer = surface->GetProducer();
204 return cameraManager->CreatePhotoOutput(photoProfile, surfaceProducer);
205 }
206
CreatePreviewOutput(int32_t width,int32_t height)207 sptr<CaptureOutput> CameraFrameworkUnitTest::CreatePreviewOutput(int32_t width, int32_t height)
208 {
209 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
210 if (surface == nullptr) {
211 return nullptr;
212 }
213 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
214 Size previewSize;
215 previewSize.width = width;
216 previewSize.height = height;
217 Profile previewProfile = Profile(previewFormat, previewSize);
218 return cameraManager->CreatePreviewOutput(previewProfile, surface);
219 }
220
CreateVideoOutput(int32_t width,int32_t height)221 sptr<CaptureOutput> CameraFrameworkUnitTest::CreateVideoOutput(int32_t width, int32_t height)
222 {
223 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
224 if (surface == nullptr) {
225 return nullptr;
226 }
227 CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
228 Size videoSize;
229 videoSize.width = width;
230 videoSize.height = height;
231 std::vector<int32_t> videoFramerates = {30, 30};
232 VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates);
233 return cameraManager->CreateVideoOutput(videoProfile, surface);
234 }
235
SessionCommit(sptr<CaptureSession> session)236 void CameraFrameworkUnitTest::SessionCommit(sptr<CaptureSession> session)
237 {
238 int32_t ret = session->CommitConfig();
239 EXPECT_EQ(ret, 0);
240 int32_t captureId = 3;
241 EXPECT_CALL(*mockStreamOperator, Capture(captureId, _, true));
242 ret = session->Start();
243 EXPECT_EQ(ret, 0);
244 }
245
SessionControlParams(sptr<CaptureSession> session)246 void CameraFrameworkUnitTest::SessionControlParams(sptr<CaptureSession> session)
247 {
248 session->LockForControl();
249
250 std::vector<float> zoomRatioRange = session->GetZoomRatioRange();
251 if (!zoomRatioRange.empty()) {
252 session->SetZoomRatio(zoomRatioRange[0]);
253 }
254
255 std::vector<float> exposurebiasRange = session->GetExposureBiasRange();
256 if (!exposurebiasRange.empty()) {
257 session->SetExposureBias(exposurebiasRange[0]);
258 }
259
260 FlashMode flash = FLASH_MODE_ALWAYS_OPEN;
261 session->SetFlashMode(flash);
262
263 FocusMode focus = FOCUS_MODE_AUTO;
264 session->SetFocusMode(focus);
265
266 ExposureMode exposure = EXPOSURE_MODE_AUTO;
267 session->SetExposureMode(exposure);
268
269 session->UnlockForControl();
270
271 if (!zoomRatioRange.empty()) {
272 EXPECT_EQ(session->GetZoomRatio(), zoomRatioRange[0]);
273 }
274
275 if (!exposurebiasRange.empty()) {
276 EXPECT_EQ(session->GetExposureValue(), exposurebiasRange[0]);
277 }
278
279 EXPECT_EQ(session->GetFlashMode(), flash);
280 EXPECT_EQ(session->GetFocusMode(), focus);
281 EXPECT_EQ(session->GetExposureMode(), exposure);
282 }
283
SetUpTestCase(void)284 void CameraFrameworkUnitTest::SetUpTestCase(void) {}
285
TearDownTestCase(void)286 void CameraFrameworkUnitTest::TearDownTestCase(void) {}
287
SetUp()288 void CameraFrameworkUnitTest::SetUp()
289 {
290 // set native token
291 uint64_t tokenId;
292 const char *perms[2];
293 perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
294 perms[1] = "ohos.permission.CAMERA";
295 NativeTokenInfoParams infoInstance = {
296 .dcapsNum = 0,
297 .permsNum = 2,
298 .aclsNum = 0,
299 .dcaps = NULL,
300 .perms = perms,
301 .acls = NULL,
302 .processName = "native_camera_tdd",
303 .aplStr = "system_basic",
304 };
305 tokenId = GetAccessTokenId(&infoInstance);
306 SetSelfTokenID(tokenId);
307 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
308
309 mockCameraHostManager = new MockHCameraHostManager(nullptr);
310 mockCameraDevice = mockCameraHostManager->cameraDevice;
311 mockStreamOperator = mockCameraDevice->streamOperator;
312 cameraManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager));
313 }
314
TearDown()315 void CameraFrameworkUnitTest::TearDown()
316 {
317 Mock::AllowLeak(mockCameraHostManager);
318 Mock::AllowLeak(mockCameraDevice);
319 Mock::AllowLeak(mockStreamOperator);
320 }
321
322 MATCHER_P(matchCaptureSetting, captureSetting, "Match Capture Setting")
323 {
324 std::vector<uint8_t> result;
325 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(captureSetting, result);
326 return (arg.captureSetting_ == result);
327 }
328
329 /*
330 * Feature: Framework
331 * Function: Test get cameras
332 * SubFunction: NA
333 * FunctionPoints: NA
334 * EnvConditions: NA
335 * CaseDescription: Test get cameras
336 */
337 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_001, TestSize.Level0)
338 {
339 InSequence s;
340 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
341 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
342 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
343 ASSERT_TRUE(cameras.size() != 0);
344 }
345
346 /*
347 * Feature: Framework
348 * Function: Test create input
349 * SubFunction: NA
350 * FunctionPoints: NA
351 * EnvConditions: NA
352 * CaseDescription: Test create input
353 */
354 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_002, TestSize.Level0)
355 {
356 InSequence s;
357 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
358 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
359 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
360 ASSERT_TRUE(cameras.size() != 0);
361 sptr<CameraInput> input = cameraManager->CreateCameraInput(cameras[0]);
362 ASSERT_NE(input, nullptr);
363
364 ASSERT_NE(input->GetCameraDevice(), nullptr);
365
366 input->Release();
367 }
368
369 /*
370 * Feature: Framework
371 * Function: Test create session
372 * SubFunction: NA
373 * FunctionPoints: NA
374 * EnvConditions: NA
375 * CaseDescription: Test create session
376 */
377 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_003, TestSize.Level0)
378 {
379 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
380 ASSERT_NE(session, nullptr);
381 session->Release();
382 }
383
384 /*
385 * Feature: Framework
386 * Function: Test create preview output
387 * SubFunction: NA
388 * FunctionPoints: NA
389 * EnvConditions: NA
390 * CaseDescription: Test create preview output
391 */
392 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_004, TestSize.Level0)
393 {
394 int32_t width = PREVIEW_DEFAULT_WIDTH;
395 int32_t height = PREVIEW_DEFAULT_HEIGHT;
396 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
397 Size previewSize;
398 previewSize.width = width;
399 previewSize.height = height;
400 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
401 Profile previewProfile = Profile(previewFormat, previewSize);
402 sptr<CaptureOutput> preview = cameraManager->CreatePreviewOutput(previewProfile, surface);
403 ASSERT_NE(preview, nullptr);
404 preview->Release();
405 }
406
407 /*
408 * Feature: Framework
409 * Function: Test create preview output with surface as null
410 * SubFunction: NA
411 * FunctionPoints: NA
412 * EnvConditions: NA
413 * CaseDescription: Test create preview output with surface as null
414 */
415 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_005, TestSize.Level0)
416 {
417 int32_t width = PREVIEW_DEFAULT_WIDTH;
418 int32_t height = PREVIEW_DEFAULT_HEIGHT;
419 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
420 Size previewSize;
421 previewSize.width = width;
422 previewSize.height = height;
423 Profile previewProfile = Profile(previewFormat, previewSize);
424 sptr<Surface> surface = nullptr;
425 sptr<CaptureOutput> preview = cameraManager->CreatePreviewOutput(previewProfile, surface);
426 ASSERT_EQ(preview, nullptr);
427 }
428
429
430 /*
431 * Feature: Framework
432 * Function: Test create photo output
433 * SubFunction: NA
434 * FunctionPoints: NA
435 * EnvConditions: NA
436 * CaseDescription: Test create photo output
437 */
438 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_011, TestSize.Level0)
439 {
440 int32_t width = PHOTO_DEFAULT_WIDTH;
441 int32_t height = PHOTO_DEFAULT_HEIGHT;
442 sptr<IConsumerSurface> surface = IConsumerSurface::Create();
443 CameraFormat photoFormat = CAMERA_FORMAT_JPEG;
444 Size photoSize;
445 photoSize.width = width;
446 photoSize.height = height;
447 Profile photoProfile = Profile(photoFormat, photoSize);
448 sptr<IBufferProducer> surfaceProducer = surface->GetProducer();
449 sptr<PhotoOutput> photo = cameraManager->CreatePhotoOutput(photoProfile, surfaceProducer);
450 ASSERT_NE(photo, nullptr);
451 photo->Release();
452 }
453
454 /*
455 * Feature: Framework
456 * Function: Test create photo output with surface as null
457 * SubFunction: NA
458 * FunctionPoints: NA
459 * EnvConditions: NA
460 * CaseDescription: Test create photo output with surface as null
461 */
462 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_012, TestSize.Level0)
463 {
464 int32_t width = PHOTO_DEFAULT_WIDTH;
465 int32_t height = PHOTO_DEFAULT_HEIGHT;
466 CameraFormat photoFormat = CAMERA_FORMAT_JPEG;
467 Size photoSize;
468 photoSize.width = width;
469 photoSize.height = height;
470 Profile photoProfile = Profile(photoFormat, photoSize);
471 sptr<IBufferProducer> surfaceProducer = nullptr;
472 sptr<PhotoOutput> photo = cameraManager->CreatePhotoOutput(photoProfile, surfaceProducer);
473 ASSERT_EQ(photo, nullptr);
474 }
475
476 /*
477 * Feature: Framework
478 * Function: Test create video output
479 * SubFunction: NA
480 * FunctionPoints: NA
481 * EnvConditions: NA
482 * CaseDescription: Test create video output
483 */
484 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_015, TestSize.Level0)
485 {
486 int32_t width = VIDEO_DEFAULT_WIDTH;
487 int32_t height = VIDEO_DEFAULT_HEIGHT;
488 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
489 CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
490 Size videoSize;
491 videoSize.width = width;
492 videoSize.height = height;
493 std::vector<int32_t> videoFramerates = {30, 30};
494 VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates);
495 sptr<VideoOutput> video = cameraManager->CreateVideoOutput(videoProfile, surface);
496 ASSERT_NE(video, nullptr);
497 video->Release();
498 }
499
500 /*
501 * Feature: Framework
502 * Function: Test create video output with surface as null
503 * SubFunction: NA
504 * FunctionPoints: NA
505 * EnvConditions: NA
506 * CaseDescription: Test create video output with surface as null
507 */
508 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_016, TestSize.Level0)
509 {
510 int32_t width = VIDEO_DEFAULT_WIDTH;
511 int32_t height = VIDEO_DEFAULT_HEIGHT;
512 CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
513 sptr<Surface> surface = nullptr;
514 Size videoSize;
515 videoSize.width = width;
516 videoSize.height = height;
517 std::vector<int32_t> videoFramerates = {30, 30};
518 VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates);
519 sptr<VideoOutput> video = cameraManager->CreateVideoOutput(videoProfile, surface);
520 ASSERT_EQ(video, nullptr);
521 }
522
523 /*
524 * Feature: Framework
525 * Function: Test manager callback
526 * SubFunction: NA
527 * FunctionPoints: NA
528 * EnvConditions: NA
529 * CaseDescription: Test manager callback
530 */
531 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_019, TestSize.Level0)
532 {
533 std::shared_ptr<TestCameraMngerCallback> setCallback = std::make_shared<TestCameraMngerCallback>("MgrCallback");
534 cameraManager->SetCallback(setCallback);
535 std::shared_ptr<CameraManagerCallback> getCallback = cameraManager->GetApplicationCallback();
536 ASSERT_EQ(setCallback, getCallback);
537 }
538
539 /*
540 * Feature: Framework
541 * Function: Test set camera parameters
542 * SubFunction: NA
543 * FunctionPoints: NA
544 * EnvConditions: NA
545 * CaseDescription: Test set camera parameters zoom, focus, flash & exposure
546 */
547 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_020, TestSize.Level0)
548 {
549 InSequence s;
550 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
551 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
552 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
553
554 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
555 ASSERT_NE(input, nullptr);
556
557 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
558 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
559 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
560 std::string cameraSettings = camInput->GetCameraSettings();
561 camInput->SetCameraSettings(cameraSettings);
562 camInput->GetCameraDevice()->Open();
563
564 sptr<CaptureOutput> photo = CreatePhotoOutput();
565 ASSERT_NE(photo, nullptr);
566
567 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
568 ASSERT_NE(session, nullptr);
569
570 int32_t ret = session->BeginConfig();
571 EXPECT_EQ(ret, 0);
572
573 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
574 ret = session->AddInput(input);
575 EXPECT_EQ(ret, 0);
576
577 ret = session->AddOutput(photo);
578 EXPECT_EQ(ret, 0);
579
580 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
581 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
582 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
583 ret = session->CommitConfig();
584 EXPECT_EQ(ret, 0);
585
586 SessionControlParams(session);
587
588 session->RemoveOutput(photo);
589 session->RemoveInput(input);
590 photo->Release();
591 input->Release();
592 session->Release();
593 }
594
595 /*
596 * Feature: Framework
597 * Function: Test input callback
598 * SubFunction: NA
599 * FunctionPoints: NA
600 * EnvConditions: NA
601 * CaseDescription: Test input callback
602 */
603 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_021, TestSize.Level0)
604 {
605 InSequence s;
606 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
607 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
608 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
609
610 sptr<CameraInput> input = cameraManager->CreateCameraInput(cameras[0]);
611 ASSERT_NE(input, nullptr);
612
613 std::shared_ptr<TestDeviceCallback> setCallback = std::make_shared<TestDeviceCallback>("InputCallback");
614 input->SetErrorCallback(setCallback);
615 std::shared_ptr<ErrorCallback> getCallback = input->GetErrorCallback();
616 ASSERT_EQ(setCallback, getCallback);
617 }
618
619 /*
620 * Feature: Framework
621 * Function: Test preview callback
622 * SubFunction: NA
623 * FunctionPoints: NA
624 * EnvConditions: NA
625 * CaseDescription: Test preview callback
626 */
627 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_022, TestSize.Level0)
628 {
629 sptr<CaptureOutput> preview = CreatePreviewOutput();
630 ASSERT_NE(preview, nullptr);
631
632 std::shared_ptr<PreviewStateCallback> setCallback =
633 std::make_shared<TestPreviewOutputCallback>("PreviewStateCallback");
634 ((sptr<PreviewOutput> &)preview)->SetCallback(setCallback);
635 std::shared_ptr<PreviewStateCallback> getCallback = ((sptr<PreviewOutput> &)preview)->GetApplicationCallback();
636 ASSERT_EQ(setCallback, getCallback);
637 }
638
639 /*
640 * Feature: Framework
641 * Function: Test photo callback
642 * SubFunction: NA
643 * FunctionPoints: NA
644 * EnvConditions: NA
645 * CaseDescription: Test photo callback
646 */
647 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_023, TestSize.Level0)
648 {
649 sptr<CaptureOutput> photo = CreatePhotoOutput();
650 ASSERT_NE(photo, nullptr);
651
652 std::shared_ptr<PhotoStateCallback> setCallback = std::make_shared<TestPhotoOutputCallback>("PhotoStateCallback");
653 ((sptr<PhotoOutput> &)photo)->SetCallback(setCallback);
654 std::shared_ptr<PhotoStateCallback> getCallback = ((sptr<PhotoOutput> &)photo)->GetApplicationCallback();
655 ASSERT_EQ(setCallback, getCallback);
656 }
657
658 /*
659 * Feature: Framework
660 * Function: Test video callback
661 * SubFunction: NA
662 * FunctionPoints: NA
663 * EnvConditions: NA
664 * CaseDescription: Test video callback
665 */
666 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_024, TestSize.Level0)
667 {
668 sptr<CaptureOutput> video = CreateVideoOutput();
669 ASSERT_NE(video, nullptr);
670
671 std::shared_ptr<VideoStateCallback> setCallback = std::make_shared<TestVideoOutputCallback>("VideoStateCallback");
672 ((sptr<VideoOutput> &)video)->SetCallback(setCallback);
673 std::shared_ptr<VideoStateCallback> getCallback = ((sptr<VideoOutput> &)video)->GetApplicationCallback();
674 ASSERT_EQ(setCallback, getCallback);
675 }
676
677 /*
678 * Feature: Framework
679 * Function: Test capture session add input with invalid value
680 * SubFunction: NA
681 * FunctionPoints: NA
682 * EnvConditions: NA
683 * CaseDescription: Test capture session add input with invalid value
684 */
685 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_025, TestSize.Level0)
686 {
687 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
688 ASSERT_NE(session, nullptr);
689
690 int32_t ret = session->BeginConfig();
691 EXPECT_EQ(ret, 0);
692
693 sptr<CaptureInput> input = nullptr;
694 ret = session->AddInput(input);
695 EXPECT_NE(ret, 0);
696 session->Release();
697 }
698
699 /*
700 * Feature: Framework
701 * Function: Test capture session add output with invalid value
702 * SubFunction: NA
703 * FunctionPoints: NA
704 * EnvConditions: NA
705 * CaseDescription: Test capture session add output with invalid value
706 */
707 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_026, TestSize.Level0)
708 {
709 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
710 ASSERT_NE(session, nullptr);
711
712 int32_t ret = session->BeginConfig();
713 EXPECT_EQ(ret, 0);
714
715 sptr<CaptureOutput> preview = nullptr;
716 ret = session->AddOutput(preview);
717 EXPECT_NE(ret, 0);
718 session->Release();
719 }
720
721 /*
722 * Feature: Framework
723 * Function: Test capture session commit config without adding input
724 * SubFunction: NA
725 * FunctionPoints: NA
726 * EnvConditions: NA
727 * CaseDescription: Test capture session commit config without adding input
728 */
729 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_027, TestSize.Level0)
730 {
731 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
732 ASSERT_NE(session, nullptr);
733
734 int32_t ret = session->BeginConfig();
735 EXPECT_EQ(ret, 0);
736
737 sptr<CaptureOutput> preview = CreatePreviewOutput();
738 ASSERT_NE(preview, nullptr);
739
740 ret = session->AddOutput(preview);
741 EXPECT_EQ(ret, 0);
742
743 ret = session->CommitConfig();
744 EXPECT_NE(ret, 0);
745 session->RemoveOutput(preview);
746 preview->Release();
747 session->Release();
748 }
749
750 /*
751 * Feature: Framework
752 * Function: Test capture session commit config without adding output
753 * SubFunction: NA
754 * FunctionPoints: NA
755 * EnvConditions: NA
756 * CaseDescription: Test capture session commit config without adding output
757 */
758 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_028, TestSize.Level0)
759 {
760 InSequence s;
761 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
762 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
763 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
764
765 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
766 ASSERT_NE(input, nullptr);
767
768 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
769 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
770 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
771 std::string cameraSettings = camInput->GetCameraSettings();
772 camInput->SetCameraSettings(cameraSettings);
773 camInput->GetCameraDevice()->Open();
774
775 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
776 ASSERT_NE(session, nullptr);
777
778 int32_t ret = session->BeginConfig();
779 EXPECT_EQ(ret, 0);
780
781 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
782 ret = session->AddInput(input);
783 EXPECT_EQ(ret, 0);
784
785 ret = session->CommitConfig();
786 EXPECT_NE(ret, 0);
787 session->RemoveInput(input);
788 input->Release();
789 session->Release();
790 }
791
792 /*
793 * Feature: Framework
794 * Function: Test capture session without begin config
795 * SubFunction: NA
796 * FunctionPoints: NA
797 * EnvConditions: NA
798 * CaseDescription: Test capture session without begin config
799 */
800 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_029, TestSize.Level0)
801 {
802 InSequence s;
803 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
804 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
805 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
806
807 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
808 ASSERT_NE(input, nullptr);
809
810 sptr<CaptureOutput> photo = CreatePhotoOutput();
811 ASSERT_NE(photo, nullptr);
812
813 sptr<CaptureOutput> preview = CreatePreviewOutput();
814 ASSERT_NE(preview, nullptr);
815
816 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
817 ASSERT_NE(session, nullptr);
818
819 int32_t ret = session->AddInput(input);
820 EXPECT_NE(ret, 0);
821
822 ret = session->AddOutput(preview);
823 EXPECT_NE(ret, 0);
824
825 ret = session->AddOutput(photo);
826 EXPECT_NE(ret, 0);
827
828 ret = session->CommitConfig();
829 EXPECT_NE(ret, 0);
830
831 ret = session->Start();
832 EXPECT_NE(ret, 0);
833
834 ret = ((sptr<PreviewOutput> &)preview)->Start();
835 EXPECT_NE(ret, 0);
836
837 ret = ((sptr<PhotoOutput> &)photo)->Capture();
838 EXPECT_NE(ret, 0);
839
840 ret = ((sptr<PreviewOutput> &)preview)->Stop();
841 EXPECT_NE(ret, 0);
842
843 ret = session->Stop();
844 EXPECT_NE(ret, 0);
845 session->RemoveInput(input);
846 session->RemoveOutput(preview);
847 session->RemoveOutput(photo);
848 preview->Release();
849 photo->Release();
850 input->Release();
851 session->Release();
852 }
853
854 /*
855 * Feature: Framework
856 * Function: Test capture session start and stop without adding preview output
857 * SubFunction: NA
858 * FunctionPoints: NA
859 * EnvConditions: NA
860 * CaseDescription: Test capture session start and stop without adding preview output
861 */
862 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_030, TestSize.Level0)
863 {
864 InSequence s;
865 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
866 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
867 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
868
869 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
870 ASSERT_NE(input, nullptr);
871
872 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
873 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
874 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
875 std::string cameraSettings = camInput->GetCameraSettings();
876 camInput->SetCameraSettings(cameraSettings);
877 camInput->GetCameraDevice()->Open();
878
879 sptr<CaptureOutput> photo = CreatePhotoOutput();
880 ASSERT_NE(photo, nullptr);
881
882 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
883 ASSERT_NE(session, nullptr);
884
885 int32_t ret = session->BeginConfig();
886 EXPECT_EQ(ret, 0);
887
888 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
889 ret = session->AddInput(input);
890 EXPECT_EQ(ret, 0);
891
892 ret = session->AddOutput(photo);
893 EXPECT_EQ(ret, 0);
894
895 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
896 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
897 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
898 ret = session->CommitConfig();
899 EXPECT_EQ(ret, 0);
900
901 EXPECT_CALL(*mockStreamOperator, Capture(_, _, true)).Times(0);
902 ret = session->Start();
903 EXPECT_EQ(ret, 0);
904
905 EXPECT_CALL(*mockStreamOperator, CancelCapture(_)).Times(0);
906
907 ret = session->Stop();
908 EXPECT_EQ(ret, 0);
909
910 EXPECT_CALL(*mockStreamOperator, ReleaseStreams(_));
911 EXPECT_CALL(*mockCameraDevice, Close());
912 session->Release();
913 input->Release();
914 }
915
916 /*
917 * Feature: Framework
918 * Function: Test session with preview + photo
919 * SubFunction: NA
920 * FunctionPoints: NA
921 * EnvConditions: NA
922 * CaseDescription: Test session with preview + photo
923 */
924 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_031, TestSize.Level0)
925 {
926 InSequence s;
927 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
928 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
929 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
930
931 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
932 ASSERT_NE(input, nullptr);
933
934 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
935 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
936 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
937 std::string cameraSettings = camInput->GetCameraSettings();
938 camInput->SetCameraSettings(cameraSettings);
939 camInput->GetCameraDevice()->Open();
940
941 sptr<CaptureOutput> preview = CreatePreviewOutput();
942 ASSERT_NE(preview, nullptr);
943
944 sptr<CaptureOutput> photo = CreatePhotoOutput();
945 ASSERT_NE(photo, nullptr);
946
947 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
948 ASSERT_NE(session, nullptr);
949
950 int32_t ret = session->BeginConfig();
951 EXPECT_EQ(ret, 0);
952
953 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
954 ret = session->AddInput(input);
955 EXPECT_EQ(ret, 0);
956
957 ret = session->AddOutput(preview);
958 EXPECT_EQ(ret, 0);
959
960 ret = session->AddOutput(photo);
961 EXPECT_EQ(ret, 0);
962
963 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
964 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
965 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
966 ret = session->CommitConfig();
967 EXPECT_EQ(ret, 0);
968
969 EXPECT_CALL(*mockStreamOperator, Capture(1, _, true));
970 ret = session->Start();
971 EXPECT_EQ(ret, 0);
972
973 EXPECT_CALL(*mockStreamOperator, Capture(2, _, false));
974 ret = ((sptr<PhotoOutput> &)photo)->Capture();
975 EXPECT_EQ(ret, 0);
976
977 EXPECT_CALL(*mockStreamOperator, CancelCapture(1));
978 ret = ((sptr<PreviewOutput> &)preview)->Stop();
979 EXPECT_EQ(ret, 0);
980
981 EXPECT_CALL(*mockStreamOperator, ReleaseStreams(_));
982 EXPECT_CALL(*mockCameraDevice, Close());
983 session->Release();
984 input->Release();
985 }
986
987 /*
988 * Feature: Framework
989 * Function: Test session with preview + photo with camera configuration
990 * SubFunction: NA
991 * FunctionPoints: NA
992 * EnvConditions: NA
993 * CaseDescription: Test session with preview + photo with camera configuration
994 */
995 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_032, TestSize.Level0)
996 {
997 InSequence s;
998 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
999 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1000 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1001
1002 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1003 ASSERT_NE(input, nullptr);
1004
1005 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
1006 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1007 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1008 std::string cameraSettings = camInput->GetCameraSettings();
1009 camInput->SetCameraSettings(cameraSettings);
1010 camInput->GetCameraDevice()->Open();
1011
1012 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1013 ASSERT_NE(session, nullptr);
1014
1015 std::vector<float> zoomRatioRange = session->GetZoomRatioRange();
1016 if (!zoomRatioRange.empty()) {
1017 session->LockForControl();
1018 session->SetZoomRatio(zoomRatioRange[0]);
1019 session->UnlockForControl();
1020 }
1021
1022 sptr<CaptureOutput> preview = CreatePreviewOutput();
1023 ASSERT_NE(preview, nullptr);
1024
1025 sptr<CaptureOutput> photo = CreatePhotoOutput();
1026 ASSERT_NE(photo, nullptr);
1027
1028 int32_t ret = session->BeginConfig();
1029 EXPECT_EQ(ret, 0);
1030
1031 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
1032 ret = session->AddInput(input);
1033 EXPECT_EQ(ret, 0);
1034
1035 ret = session->AddOutput(preview);
1036 EXPECT_EQ(ret, 0);
1037
1038 ret = session->AddOutput(photo);
1039 EXPECT_EQ(ret, 0);
1040
1041 if (!zoomRatioRange.empty()) {
1042 EXPECT_CALL(*mockCameraDevice, UpdateSettings(_));
1043 }
1044 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
1045 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
1046 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
1047 ret = session->CommitConfig();
1048 EXPECT_EQ(ret, 0);
1049
1050 EXPECT_CALL(*mockStreamOperator, ReleaseStreams(_));
1051 EXPECT_CALL(*mockCameraDevice, Close());
1052 session->Release();
1053 input->Release();
1054 }
1055
1056 /*
1057 * Feature: Framework
1058 * Function: Test session with preview + video
1059 * SubFunction: NA
1060 * FunctionPoints: NA
1061 * EnvConditions: NA
1062 * CaseDescription: Test session with preview + video
1063 */
1064 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_033, TestSize.Level0)
1065 {
1066 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1067 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1068 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1069
1070 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1071 ASSERT_NE(input, nullptr);
1072
1073 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
1074 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1075 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1076 std::string cameraSettings = camInput->GetCameraSettings();
1077 camInput->SetCameraSettings(cameraSettings);
1078 camInput->GetCameraDevice()->Open();
1079
1080 sptr<CaptureOutput> preview = CreatePreviewOutput();
1081 ASSERT_NE(preview, nullptr);
1082
1083 sptr<CaptureOutput> video = CreateVideoOutput();
1084 ASSERT_NE(video, nullptr);
1085
1086 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1087 ASSERT_NE(session, nullptr);
1088
1089 int32_t ret = session->BeginConfig();
1090 EXPECT_EQ(ret, 0);
1091
1092 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
1093 ret = session->AddInput(input);
1094 EXPECT_EQ(ret, 0);
1095
1096 ret = session->AddOutput(preview);
1097 EXPECT_EQ(ret, 0);
1098
1099 ret = session->AddOutput(video);
1100 EXPECT_EQ(ret, 0);
1101
1102 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
1103 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
1104 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
1105
1106 SessionCommit(session);
1107
1108 EXPECT_CALL(*mockStreamOperator, Capture(4, _, true));
1109 ret = ((sptr<VideoOutput> &)video)->Start();
1110 EXPECT_EQ(ret, 0);
1111
1112 EXPECT_CALL(*mockStreamOperator, CancelCapture(4));
1113 ret = ((sptr<VideoOutput> &)video)->Stop();
1114 EXPECT_EQ(ret, 0);
1115
1116 EXPECT_CALL(*mockStreamOperator, CancelCapture(3));
1117 ret = ((sptr<PreviewOutput> &)preview)->Stop();
1118 EXPECT_EQ(ret, 0);
1119
1120 ((sptr<VideoOutput> &)video)->Release();
1121 EXPECT_CALL(*mockStreamOperator, ReleaseStreams(_));
1122 EXPECT_CALL(*mockCameraDevice, Close());
1123 session->Release();
1124 input->Release();
1125 }
1126
1127 /*
1128 * Feature: Framework
1129 * Function: Test capture session remove output with null
1130 * SubFunction: NA
1131 * FunctionPoints: NA
1132 * EnvConditions: NA
1133 * CaseDescription: Test capture session remove output with null
1134 */
1135 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_034, TestSize.Level0)
1136 {
1137 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1138 ASSERT_NE(session, nullptr);
1139
1140 int32_t ret = session->BeginConfig();
1141 EXPECT_EQ(ret, 0);
1142
1143 sptr<CaptureOutput> output = nullptr;
1144 ret = session->RemoveOutput(output);
1145 EXPECT_NE(ret, 0);
1146 session->Release();
1147 }
1148
1149 /*
1150 * Feature: Framework
1151 * Function: Test capture session remove output
1152 * SubFunction: NA
1153 * FunctionPoints: NA
1154 * EnvConditions: NA
1155 * CaseDescription: Test capture session remove output
1156 */
1157 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_035, TestSize.Level0)
1158 {
1159 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1160 ASSERT_NE(session, nullptr);
1161
1162 sptr<CaptureOutput> video = CreateVideoOutput();
1163 ASSERT_NE(video, nullptr);
1164
1165 int32_t ret = session->BeginConfig();
1166 EXPECT_EQ(ret, 0);
1167
1168 ret = session->AddOutput(video);
1169 EXPECT_EQ(ret, 0);
1170
1171 ret = session->RemoveOutput(video);
1172 EXPECT_EQ(ret, 0);
1173 video->Release();
1174 session->Release();
1175 }
1176
1177 /*
1178 * Feature: Framework
1179 * Function: Test capture session remove input with null
1180 * SubFunction: NA
1181 * FunctionPoints: NA
1182 * EnvConditions: NA
1183 * CaseDescription: Test capture session remove input with null
1184 */
1185 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_036, TestSize.Level0)
1186 {
1187 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1188 ASSERT_NE(session, nullptr);
1189
1190 int32_t ret = session->BeginConfig();
1191 EXPECT_EQ(ret, 0);
1192
1193 sptr<CaptureInput> input = nullptr;
1194 ret = session->RemoveInput(input);
1195 EXPECT_NE(ret, 0);
1196 session->Release();
1197 }
1198
1199 /*
1200 * Feature: Framework
1201 * Function: Test capture session remove input
1202 * SubFunction: NA
1203 * FunctionPoints: NA
1204 * EnvConditions: NA
1205 * CaseDescription: Test capture session remove input
1206 */
1207 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_037, TestSize.Level0)
1208 {
1209 InSequence s;
1210 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1211 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1212 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1213
1214 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1215 ASSERT_NE(input, nullptr);
1216
1217 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
1218 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1219 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1220 std::string cameraSettings = camInput->GetCameraSettings();
1221 camInput->SetCameraSettings(cameraSettings);
1222 camInput->GetCameraDevice()->Open();
1223
1224 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1225 ASSERT_NE(session, nullptr);
1226
1227 int32_t ret = session->BeginConfig();
1228 EXPECT_EQ(ret, 0);
1229
1230 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
1231 ret = session->AddInput(input);
1232 EXPECT_EQ(ret, 0);
1233
1234 ret = session->RemoveInput(input);
1235 EXPECT_EQ(ret, 0);
1236 input->Release();
1237 session->Release();
1238 }
1239
1240 /*
1241 * Feature: Framework
1242 * Function: Test photo capture with photo settings
1243 * SubFunction: NA
1244 * FunctionPoints: NA
1245 * EnvConditions: NA
1246 * CaseDescription: Test photo capture with photo settings
1247 */
1248 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_038, TestSize.Level0)
1249 {
1250 InSequence s;
1251 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1252 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1253 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1254
1255 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1256 ASSERT_NE(input, nullptr);
1257
1258 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
1259 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1260 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1261 std::string cameraSettings = camInput->GetCameraSettings();
1262 camInput->SetCameraSettings(cameraSettings);
1263 camInput->GetCameraDevice()->Open();
1264
1265 sptr<CaptureOutput> photo = CreatePhotoOutput();
1266 ASSERT_NE(photo, nullptr);
1267
1268 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1269 ASSERT_NE(session, nullptr);
1270
1271 int32_t ret = session->BeginConfig();
1272 EXPECT_EQ(ret, 0);
1273
1274 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
1275 ret = session->AddInput(input);
1276 EXPECT_EQ(ret, 0);
1277
1278 ret = session->AddOutput(photo);
1279 EXPECT_EQ(ret, 0);
1280
1281 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
1282 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
1283 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
1284 ret = session->CommitConfig();
1285 EXPECT_EQ(ret, 0);
1286
1287 std::shared_ptr<PhotoCaptureSetting> photoSetting = std::make_shared<PhotoCaptureSetting>();
1288 photoSetting->SetRotation(PhotoCaptureSetting::Rotation_90);
1289 photoSetting->SetQuality(PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM);
1290 EXPECT_EQ(photoSetting->GetRotation(), PhotoCaptureSetting::Rotation_90);
1291 EXPECT_EQ(photoSetting->GetQuality(), PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM);
1292
1293 EXPECT_CALL(*mockStreamOperator, Capture(_,
1294 matchCaptureSetting(photoSetting->GetCaptureMetadataSetting()), false));
1295 ret = ((sptr<PhotoOutput> &)photo)->Capture(photoSetting);
1296 EXPECT_EQ(ret, 0);
1297
1298 EXPECT_CALL(*mockStreamOperator, ReleaseStreams(_));
1299 EXPECT_CALL(*mockCameraDevice, Close());
1300 session->Release();
1301 input->Release();
1302 }
1303
1304 /*
1305 * Feature: Framework
1306 * Function: Test GetFocalLength
1307 * SubFunction: NA
1308 * FunctionPoints: NA
1309 * EnvConditions: NA
1310 * CaseDescription: Test GetFocalLength
1311 */
1312 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_040, TestSize.Level0)
1313 {
1314 InSequence s;
1315 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1316 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1317 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1318
1319 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1320 ASSERT_NE(input, nullptr);
1321
1322 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
1323 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1324 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1325 std::string cameraSettings = camInput->GetCameraSettings();
1326 camInput->SetCameraSettings(cameraSettings);
1327 camInput->GetCameraDevice()->Open();
1328
1329 sptr<CaptureOutput> photo = CreatePhotoOutput();
1330 ASSERT_NE(photo, nullptr);
1331
1332 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1333 ASSERT_NE(session, nullptr);
1334
1335 int32_t ret = session->BeginConfig();
1336 EXPECT_EQ(ret, 0);
1337
1338 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
1339 ret = session->AddInput(input);
1340 EXPECT_EQ(ret, 0);
1341
1342 ret = session->AddOutput(photo);
1343 EXPECT_EQ(ret, 0);
1344
1345 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
1346 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
1347 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
1348 ret = session->CommitConfig();
1349 EXPECT_EQ(ret, 0);
1350
1351 double focalLength = session->GetFocalLength();
1352 ASSERT_EQ(focalLength, 1.5);
1353
1354 session->RemoveInput(input);
1355 session->RemoveOutput(photo);
1356 photo->Release();
1357 input->Release();
1358 session->Release();
1359 }
1360
1361
1362 /*
1363 * Feature: Framework
1364 * Function: Test SetMeteringPoint & GetMeteringPoint
1365 * SubFunction: NA
1366 * FunctionPoints: NA
1367 * EnvConditions: NA
1368 * CaseDescription: Test SetMeteringPoint & GetMeteringPoint
1369 */
1370 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_041, TestSize.Level0)
1371 {
1372 InSequence s;
1373 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1374 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1375 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1376
1377 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1378 ASSERT_NE(input, nullptr);
1379
1380 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
1381 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1382 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1383 std::string cameraSettings = camInput->GetCameraSettings();
1384 camInput->SetCameraSettings(cameraSettings);
1385 camInput->GetCameraDevice()->Open();
1386
1387 sptr<CaptureOutput> photo = CreatePhotoOutput();
1388 ASSERT_NE(photo, nullptr);
1389
1390 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1391 ASSERT_NE(session, nullptr);
1392
1393 int32_t ret = session->BeginConfig();
1394 EXPECT_EQ(ret, 0);
1395
1396 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
1397 ret = session->AddInput(input);
1398 EXPECT_EQ(ret, 0);
1399
1400 ret = session->AddOutput(photo);
1401 EXPECT_EQ(ret, 0);
1402
1403 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
1404 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
1405 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
1406 ret = session->CommitConfig();
1407 EXPECT_EQ(ret, 0);
1408
1409 Point exposurePoint = {1.0, 2.0};
1410 session->LockForControl();
1411 session->SetMeteringPoint(exposurePoint);
1412 session->UnlockForControl();
1413 ASSERT_EQ((session->GetMeteringPoint().x), exposurePoint.x > 1 ? 1 : exposurePoint.x);
1414 ASSERT_EQ((session->GetMeteringPoint().y), exposurePoint.y > 1 ? 1 : exposurePoint.y);
1415
1416 session->RemoveInput(input);
1417 session->RemoveOutput(photo);
1418 photo->Release();
1419 input->Release();
1420 session->Release();
1421 }
1422
1423
1424 /*
1425 * Feature: Framework
1426 * Function: Test SetFocusPoint & GetFousPoint
1427 * SubFunction: NA
1428 * FunctionPoints: NA
1429 * EnvConditions: NA
1430 * CaseDescription: Test SetFocusPoint & GetFousPoint
1431 */
1432 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_042, TestSize.Level0)
1433 {
1434 InSequence s;
1435 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1436 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1437 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1438
1439 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1440 ASSERT_NE(input, nullptr);
1441
1442 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
1443 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1444 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1445 std::string cameraSettings = camInput->GetCameraSettings();
1446 camInput->SetCameraSettings(cameraSettings);
1447 camInput->GetCameraDevice()->Open();
1448
1449 sptr<CaptureOutput> photo = CreatePhotoOutput();
1450 ASSERT_NE(photo, nullptr);
1451
1452 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1453 ASSERT_NE(session, nullptr);
1454
1455 int32_t ret = session->BeginConfig();
1456 EXPECT_EQ(ret, 0);
1457
1458 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
1459 ret = session->AddInput(input);
1460 EXPECT_EQ(ret, 0);
1461
1462 ret = session->AddOutput(photo);
1463 EXPECT_EQ(ret, 0);
1464
1465 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
1466 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
1467 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
1468 ret = session->CommitConfig();
1469 EXPECT_EQ(ret, 0);
1470
1471 Point FocusPoint = {1.0, 2.0};
1472 session->LockForControl();
1473 session->SetFocusPoint(FocusPoint);
1474 session->UnlockForControl();
1475 ASSERT_EQ((session->GetFocusPoint().x), FocusPoint.x > 1 ? 1 : FocusPoint.x);
1476 ASSERT_EQ((session->GetFocusPoint().y), FocusPoint.y > 1 ? 1 : FocusPoint.y);
1477
1478 session->RemoveInput(input);
1479 session->RemoveOutput(photo);
1480 photo->Release();
1481 input->Release();
1482 session->Release();
1483 }
1484
1485 /*
1486 * Feature: Framework
1487 * Function: Test GetExposureValue and SetExposureBias
1488 * SubFunction: NA
1489 * FunctionPoints: NA
1490 * EnvConditions: NA
1491 * CaseDescription: Test GetExposureValue and SetExposureBias with value less then the range
1492 */
1493 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_043, TestSize.Level0)
1494 {
1495 InSequence s;
1496 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1497 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1498 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1499
1500 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1501 ASSERT_NE(input, nullptr);
1502
1503 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
1504 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1505 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1506 std::string cameraSettings = camInput->GetCameraSettings();
1507 camInput->SetCameraSettings(cameraSettings);
1508 camInput->GetCameraDevice()->Open();
1509
1510 sptr<CaptureOutput> photo = CreatePhotoOutput();
1511 ASSERT_NE(photo, nullptr);
1512
1513 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1514 ASSERT_NE(session, nullptr);
1515
1516 int32_t ret = session->BeginConfig();
1517 EXPECT_EQ(ret, 0);
1518
1519 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
1520 ret = session->AddInput(input);
1521 EXPECT_EQ(ret, 0);
1522
1523 ret = session->AddOutput(photo);
1524 EXPECT_EQ(ret, 0);
1525
1526 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
1527 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
1528 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
1529 ret = session->CommitConfig();
1530 EXPECT_EQ(ret, 0);
1531
1532 std::vector<float> exposurebiasRange = session->GetExposureBiasRange();
1533 if (!exposurebiasRange.empty()) {
1534 session->LockForControl();
1535 session->SetExposureBias(exposurebiasRange[0]-1.0);
1536 session->UnlockForControl();
1537 ASSERT_EQ(session->GetExposureValue(), exposurebiasRange[0]);
1538 }
1539 session->RemoveInput(input);
1540 session->RemoveOutput(photo);
1541 photo->Release();
1542 input->Release();
1543 session->Release();
1544 }
1545
1546 /*
1547 * Feature: Framework
1548 * Function: Test GetExposureValue and SetExposureBias
1549 * SubFunction: NA
1550 * FunctionPoints: NA
1551 * EnvConditions: NA
1552 * CaseDescription: Test GetExposureValue and SetExposureBias with value between the range
1553 */
1554 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_044, TestSize.Level0)
1555 {
1556 InSequence s;
1557 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1558 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1559 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1560
1561 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1562 ASSERT_NE(input, nullptr);
1563
1564 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
1565 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1566 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1567 std::string cameraSettings = camInput->GetCameraSettings();
1568 camInput->SetCameraSettings(cameraSettings);
1569 camInput->GetCameraDevice()->Open();
1570
1571 sptr<CaptureOutput> photo = CreatePhotoOutput();
1572 ASSERT_NE(photo, nullptr);
1573
1574 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1575 ASSERT_NE(session, nullptr);
1576
1577 int32_t ret = session->BeginConfig();
1578 EXPECT_EQ(ret, 0);
1579
1580 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
1581 ret = session->AddInput(input);
1582 EXPECT_EQ(ret, 0);
1583
1584 ret = session->AddOutput(photo);
1585 EXPECT_EQ(ret, 0);
1586
1587 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
1588 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
1589 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
1590 ret = session->CommitConfig();
1591 EXPECT_EQ(ret, 0);
1592
1593 std::vector<float> exposurebiasRange = session->GetExposureBiasRange();
1594 if (!exposurebiasRange.empty()) {
1595 session->LockForControl();
1596 session->SetExposureBias(exposurebiasRange[0]+1.0);
1597 session->UnlockForControl();
1598 EXPECT_TRUE((session->GetExposureValue()>=exposurebiasRange[0] &&
1599 session->GetExposureValue()<=exposurebiasRange[1]));
1600 }
1601 session->RemoveInput(input);
1602 session->RemoveOutput(photo);
1603 photo->Release();
1604 input->Release();
1605 session->Release();
1606 }
1607
1608
1609 /*
1610 * Feature: Framework
1611 * Function: Test GetExposureValue and SetExposureBias
1612 * SubFunction: NA
1613 * FunctionPoints: NA
1614 * EnvConditions: NA
1615 * CaseDescription: Test GetExposureValue and SetExposureBias with value more then the range
1616 */
1617 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_045, TestSize.Level0)
1618 {
1619 InSequence s;
1620 EXPECT_CALL(*mockCameraHostManager, GetCameras(_));
1621 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)).Times(2);
1622 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1623
1624 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1625 ASSERT_NE(input, nullptr);
1626
1627 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _));
1628 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1629 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1630 std::string cameraSettings = camInput->GetCameraSettings();
1631 camInput->SetCameraSettings(cameraSettings);
1632 camInput->GetCameraDevice()->Open();
1633
1634 sptr<CaptureOutput> photo = CreatePhotoOutput();
1635 ASSERT_NE(photo, nullptr);
1636
1637 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1638 ASSERT_NE(session, nullptr);
1639
1640 int32_t ret = session->BeginConfig();
1641 EXPECT_EQ(ret, 0);
1642
1643 EXPECT_CALL(*mockCameraDevice, GetStreamOperator(_, _));
1644 ret = session->AddInput(input);
1645 EXPECT_EQ(ret, 0);
1646
1647 ret = session->AddOutput(photo);
1648 EXPECT_EQ(ret, 0);
1649
1650 EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _));
1651 EXPECT_CALL(*mockStreamOperator, CreateStreams(_));
1652 EXPECT_CALL(*mockStreamOperator, CommitStreams(_, _));
1653 ret = session->CommitConfig();
1654 EXPECT_EQ(ret, 0);
1655
1656 std::vector<float> exposurebiasRange = session->GetExposureBiasRange();
1657 if (!exposurebiasRange.empty()) {
1658 session->LockForControl();
1659 session->SetExposureBias(exposurebiasRange[1]+1.0);
1660 session->UnlockForControl();
1661 }
1662 ASSERT_EQ(session->GetExposureValue(), exposurebiasRange[1]);
1663 session->Release();
1664 }
1665 } // CameraStandard
1666 } // OHOS
1667