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