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
18 #include "gtest/gtest.h"
19 #include <cstdint>
20 #include <vector>
21
22 #include "access_token.h"
23 #include "accesstoken_kit.h"
24 #include "camera_log.h"
25 #include "camera_manager.h"
26 #include "camera_output_capability.h"
27 #include "camera_util.h"
28 #include "capture_output.h"
29 #include "capture_scene_const.h"
30 #include "capture_session.h"
31 #include "gmock/gmock.h"
32 #include "hap_token_info.h"
33 #include "input/camera_input.h"
34 #include "ipc_skeleton.h"
35 #include "metadata_utils.h"
36 #include "nativetoken_kit.h"
37 #include "night_session.h"
38 #include "panorama_session.h"
39 #include "photo_output.h"
40 #include "photo_session.h"
41 #include "preview_output.h"
42 #include "scan_session.h"
43 #include "secure_camera_session.h"
44 #include "slow_motion_session.h"
45 #include "surface.h"
46 #include "test_common.h"
47 #include "token_setproc.h"
48 #include "video_session.h"
49 #include "os_account_manager.h"
50 #include "output/metadata_output.h"
51
52 using namespace testing::ext;
53 using ::testing::A;
54 using ::testing::InSequence;
55 using ::testing::Mock;
56 using ::testing::Return;
57 using ::testing::_;
58
59 bool g_mockFlagWithoutAbt = false;
60 bool g_getCameraAbilityerror = false;
61 bool g_openCameraDevicerror = false;
62 int g_num = 0;
63
64 namespace OHOS {
65 namespace CameraStandard {
66 using namespace OHOS::HDI::Camera::V1_1;
67 constexpr static int32_t ARRAY_IDX = 2;
68 class MockStreamOperator : public OHOS::HDI::Camera::V1_1::IStreamOperator {
69 public:
MockStreamOperator()70 MockStreamOperator()
71 {
72 ON_CALL(*this, CreateStreams(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
73 ON_CALL(*this, CreateStreams_V1_1(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
74 ON_CALL(*this, ReleaseStreams(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
75 ON_CALL(*this, CommitStreams(_, _)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
76 ON_CALL(*this, CommitStreams_V1_1(_, _)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
77 ON_CALL(*this, Capture(_, _, _)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
78 ON_CALL(*this, CancelCapture(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
79 ON_CALL(*this, IsStreamsSupported(_, _, A<const std::shared_ptr<OHOS::HDI::Camera::V1_0::StreamInfo> &>(), _))
80 .WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
81 ON_CALL(*this, IsStreamsSupported(_, _, A<const std::vector<OHOS::HDI::Camera::V1_0::StreamInfo> &>(), _))
82 .WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
83 ON_CALL(*this, IsStreamsSupported_V1_1(_, _, A<const std::shared_ptr<StreamInfo> &>(), _))
84 .WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
85 ON_CALL(*this, IsStreamsSupported_V1_1(_, _, A<const std::vector<StreamInfo_V1_1> &>(), _))
86 .WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
87 ON_CALL(*this, GetStreamAttributes(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
88 ON_CALL(*this, AttachBufferQueue(_, _)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
89 ON_CALL(*this, DetachBufferQueue(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
90 ON_CALL(*this, ChangeToOfflineStream(_, _, _)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
91 }
~MockStreamOperator()92 ~MockStreamOperator() {}
93 MOCK_METHOD1(CreateStreams, int32_t(
94 const std::vector<OHOS::HDI::Camera::V1_0::StreamInfo>& streamInfos));
95 MOCK_METHOD1(CreateStreams_V1_1, int32_t(
96 const std::vector<StreamInfo_V1_1>& streamInfos));
97 MOCK_METHOD1(ReleaseStreams, int32_t(const std::vector<int32_t>& streamIds));
98 MOCK_METHOD1(CancelCapture, int32_t(int32_t captureId));
99 MOCK_METHOD1(GetStreamAttributes, int32_t(
100 std::vector<StreamAttribute>& attributes));
101 MOCK_METHOD1(DetachBufferQueue, int32_t(int32_t streamId));
102 MOCK_METHOD2(CommitStreams, int32_t(OperationMode mode, const std::vector<uint8_t>& modeSetting));
103 MOCK_METHOD2(CommitStreams_V1_1, int32_t(OHOS::HDI::Camera::V1_1::OperationMode_V1_1 mode,
104 const std::vector<uint8_t>& modeSetting));
105 MOCK_METHOD2(AttachBufferQueue, int32_t(int32_t streamId,
106 const sptr<BufferProducerSequenceable>& bufferProducer));
107 MOCK_METHOD3(Capture, int32_t(int32_t captureId, const CaptureInfo& info, bool isStreaming));
108 MOCK_METHOD3(ChangeToOfflineStream, int32_t(const std::vector<int32_t>& streamIds,
109 const sptr<HDI::Camera::V1_0::IStreamOperatorCallback>& callbackObj,
110 sptr<HDI::Camera::V1_0::IOfflineStreamOperator>& offlineOperator));
111 MOCK_METHOD4(IsStreamsSupported, int32_t(OperationMode mode,
112 const std::shared_ptr<OHOS::Camera::CameraMetadata> &modeSetting,
113 const std::shared_ptr<OHOS::HDI::Camera::V1_0::StreamInfo> &info, StreamSupportType &type));
114 MOCK_METHOD4(IsStreamsSupported, int32_t(OperationMode mode, const std::vector<uint8_t>& modeSetting,
115 const std::vector<OHOS::HDI::Camera::V1_0::StreamInfo>& infos, StreamSupportType& type));
116 MOCK_METHOD4(IsStreamsSupported_V1_1, int32_t(OHOS::HDI::Camera::V1_1::OperationMode_V1_1 mode,
117 const std::shared_ptr<OHOS::Camera::CameraMetadata> &modeSetting,
118 const std::shared_ptr<StreamInfo> &info, StreamSupportType &type));
119 MOCK_METHOD4(IsStreamsSupported_V1_1, int32_t(OHOS::HDI::Camera::V1_1::OperationMode_V1_1 mode,
120 const std::vector<uint8_t>& modeSetting,
121 const std::vector<StreamInfo_V1_1>& infos, StreamSupportType& type));
122 };
123
124 class MockCameraDevice : public OHOS::HDI::Camera::V1_1::ICameraDevice {
125 public:
MockCameraDevice()126 MockCameraDevice()
127 {
128 streamOperator = new MockStreamOperator();
129 ON_CALL(*this, GetStreamOperator_V1_1).WillByDefault([this](
130 const OHOS::sptr<HDI::Camera::V1_0::IStreamOperatorCallback> &callback,
131 sptr<OHOS::HDI::Camera::V1_1::IStreamOperator>& pStreamOperator) {
132 pStreamOperator = streamOperator;
133 return HDI::Camera::V1_0::NO_ERROR;
134 });
135 ON_CALL(*this, GetStreamOperator).WillByDefault([this](
136 const OHOS::sptr<HDI::Camera::V1_0::IStreamOperatorCallback> &callback,
137 sptr<OHOS::HDI::Camera::V1_0::IStreamOperator>& pStreamOperator) {
138 pStreamOperator = streamOperator;
139 return HDI::Camera::V1_0::NO_ERROR;
140 });
141 ON_CALL(*this, UpdateSettings(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
142 ON_CALL(*this, SetResultMode(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
143 ON_CALL(*this, GetEnabledResults(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
144 ON_CALL(*this, EnableResult(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
145 ON_CALL(*this, DisableResult(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
146 ON_CALL(*this, Open()).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
147 ON_CALL(*this, Close()).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
148 ON_CALL(*this, GetDefaultSettings(_)).WillByDefault(Return(HDI::Camera::V1_0::NO_ERROR));
149 }
~MockCameraDevice()150 ~MockCameraDevice() {}
151 MOCK_METHOD0(Open, int32_t());
152 MOCK_METHOD0(Close, int32_t());
153 MOCK_METHOD1(GetDefaultSettings, int32_t(std::vector<uint8_t> &settings));
154 MOCK_METHOD1(UpdateSettings, int32_t(const std::vector<uint8_t>& settings));
155 MOCK_METHOD1(SetResultMode, int32_t(ResultCallbackMode mode));
156 MOCK_METHOD1(GetEnabledResults, int32_t(std::vector<int32_t>& results));
157 MOCK_METHOD1(EnableResult, int32_t(const std::vector<int32_t>& results));
158 MOCK_METHOD1(DisableResult, int32_t(const std::vector<int32_t>& results));
159 MOCK_METHOD2(GetStreamOperator, int32_t(const sptr<HDI::Camera::V1_0::IStreamOperatorCallback>& callbackObj,
160 sptr<OHOS::HDI::Camera::V1_0::IStreamOperator>& streamOperator));
161 MOCK_METHOD2(GetStreamOperator_V1_1, int32_t(const sptr<HDI::Camera::V1_0::IStreamOperatorCallback>& callbackObj,
162 sptr<OHOS::HDI::Camera::V1_1::IStreamOperator>& streamOperator));
163 sptr<MockStreamOperator> streamOperator;
164 };
165
166 class MockHCameraHostManager : public HCameraHostManager {
167 public:
168 struct StreamFormatConfig {
169 camera_format_t cameraFormat;
170 int32_t streamWidth;
171 int32_t streamHeight;
172 int32_t fixedFrameRate;
173 int32_t minFrameRate;
174 int32_t maxFrameRate;
175 std::vector<int32_t> streamAbilities = {};
IntoVectorOHOS::CameraStandard::MockHCameraHostManager::StreamFormatConfig176 void IntoVector(std::vector<int32_t>& vector) const
177 {
178 static const int32_t ABILITY_FINISH = -1;
179 vector.emplace_back(cameraFormat);
180 vector.emplace_back(streamWidth);
181 vector.emplace_back(streamHeight);
182 vector.emplace_back(fixedFrameRate);
183 vector.emplace_back(minFrameRate);
184 vector.emplace_back(maxFrameRate);
185 vector.insert(vector.end(), streamAbilities.begin(), streamAbilities.end());
186 vector.emplace_back(ABILITY_FINISH);
187 }
188 };
189
190 struct StreamConfig {
191 int32_t streamType;
192 std::vector<StreamFormatConfig> streamFormatConfigs;
193
IntoVectorOHOS::CameraStandard::MockHCameraHostManager::StreamConfig194 void IntoVector(std::vector<int32_t>& vector) const
195 {
196 static const int32_t STREAM_FINISH = -1;
197 vector.emplace_back(streamType);
198 for (auto& formatConfig : streamFormatConfigs) {
199 formatConfig.IntoVector(vector);
200 }
201 vector.emplace_back(STREAM_FINISH);
202 }
203 };
204
205 struct ModeConfig {
206 int32_t modeName;
207 std::vector<StreamConfig> streams = {};
IntoVectorOHOS::CameraStandard::MockHCameraHostManager::ModeConfig208 void IntoVector(std::vector<int32_t>& vector) const
209 {
210 static const int32_t MODE_FINISH = -1;
211 vector.emplace_back(modeName);
212 for (auto& stream : streams) {
213 stream.IntoVector(vector);
214 }
215 vector.emplace_back(MODE_FINISH);
216 }
217 };
218
219 struct ModeConfigs {
220 std::vector<ModeConfig> configs = {};
ModeConfigsOHOS::CameraStandard::MockHCameraHostManager::ModeConfigs221 explicit ModeConfigs(std::vector<ModeConfig> modeConfigs) : configs(std::move(modeConfigs)) {}
222
GetModesOHOS::CameraStandard::MockHCameraHostManager::ModeConfigs223 std::vector<uint8_t> GetModes() const
224 {
225 std::vector<uint8_t> modes = {};
226 for (auto& config : configs) {
227 modes.emplace_back(config.modeName);
228 }
229 return modes;
230 }
231
GetDatasOHOS::CameraStandard::MockHCameraHostManager::ModeConfigs232 std::vector<int32_t> GetDatas() const
233 {
234 std::vector<int32_t> datas = {};
235 for (auto& config : configs) {
236 config.IntoVector(datas);
237 }
238 return datas;
239 }
240 };
241
242 const ModeConfig DEFAULT_MODE_CONFIG = { CameraFrameworkUnitTest::DEFAULT_MODE, {
243 { CameraFrameworkUnitTest::PREVIEW_STREAM, { { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 640, 480, 0, 0, 0 } } },
244 { CameraFrameworkUnitTest::VIDEO_STREAM, { { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 640, 360, 30, 0, 0 } } },
245 { CameraFrameworkUnitTest::PHOTO_STREAM, { { OHOS_CAMERA_FORMAT_JPEG, 1280, 960, 0, 0, 0 } } } } };
246
247 const ModeConfig PHOTO_MODE_CONFIG = { CameraFrameworkUnitTest::PHOTO_MODE,
248 {
249 { CameraFrameworkUnitTest::PREVIEW_STREAM,
250 {
251 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 640, 480, 0, 0, 0 },
252
253 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 720, 720, 0, 0, 0 },
254 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1080, 1080, 0, 0, 0 },
255 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1440, 1440, 0, 0, 0 },
256
257 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 960, 720, 0, 0, 0 },
258 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1440, 1080, 0, 0, 0 },
259 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1920, 1440, 0, 0, 0 },
260
261 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1280, 720, 0, 0, 0 },
262 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1920, 1080, 0, 0, 0 },
263 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 2560, 1440, 0, 0, 0 },
264 } },
265 { CameraFrameworkUnitTest::PHOTO_STREAM,
266 {
267 { OHOS_CAMERA_FORMAT_JPEG, 720, 720, 0, 0, 0 },
268 { OHOS_CAMERA_FORMAT_JPEG, 1080, 1080, 0, 0, 0 },
269 { OHOS_CAMERA_FORMAT_JPEG, 2160, 2160, 0, 0, 0 },
270 { OHOS_CAMERA_FORMAT_JPEG, 3072, 3072, 0, 0, 0 },
271
272 { OHOS_CAMERA_FORMAT_JPEG, 960, 720, 0, 0, 0 },
273 { OHOS_CAMERA_FORMAT_JPEG, 1440, 1080, 0, 0, 0 },
274 { OHOS_CAMERA_FORMAT_JPEG, 2880, 2160, 0, 0, 0 },
275 { OHOS_CAMERA_FORMAT_JPEG, 4096, 3072, 0, 0, 0 },
276
277 { OHOS_CAMERA_FORMAT_JPEG, 1280, 720, 0, 0, 0 },
278 { OHOS_CAMERA_FORMAT_JPEG, 1920, 1080, 0, 0, 0 },
279 { OHOS_CAMERA_FORMAT_JPEG, 3840, 2160, 0, 0, 0 },
280 { OHOS_CAMERA_FORMAT_JPEG, 4096, 2304, 0, 0, 0 },
281
282 { OHOS_CAMERA_FORMAT_JPEG, 1280, 960, 0, 0, 0 },
283 } },
284 } };
285
286 const ModeConfig VIDEO_MODE_CONFIG = { CameraFrameworkUnitTest::VIDEO_MODE,
287 {
288 { CameraFrameworkUnitTest::PREVIEW_STREAM,
289 {
290 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 720, 720, 0, 0, 0 },
291 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1080, 1080, 0, 0, 0 },
292 { OHOS_CAMERA_FORMAT_YCRCB_P010, 1080, 1080, 0, 0, 0 },
293
294 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 960, 720, 0, 0, 0 },
295 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1440, 1080, 0, 0, 0 },
296 { OHOS_CAMERA_FORMAT_YCRCB_P010, 1440, 1080, 0, 0, 0 },
297
298 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1280, 720, 0, 0, 0 },
299 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1920, 1080, 0, 0, 0 },
300 { OHOS_CAMERA_FORMAT_YCRCB_P010, 1920, 1080, 0, 0, 0 },
301
302 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 640, 480, 0, 0, 0 },
303 } },
304 { CameraFrameworkUnitTest::VIDEO_STREAM,
305 {
306 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 720, 720, 30, 24, 30 },
307 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1080, 1080, 30, 24, 30 },
308 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 2160, 2160, 30, 24, 30 },
309 { OHOS_CAMERA_FORMAT_YCRCB_P010, 2160, 2160, 30, 24, 30 },
310
311 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 960, 720, 30, 24, 30 },
312 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1440, 1080, 30, 24, 30 },
313 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 2880, 2160, 30, 24, 30 },
314 { OHOS_CAMERA_FORMAT_YCRCB_P010, 2880, 2160, 30, 24, 30 },
315
316 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1280, 720, 30, 24, 30 },
317 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1920, 1080, 30, 24, 30 },
318 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 3840, 2160, 30, 24, 30 },
319 { OHOS_CAMERA_FORMAT_YCRCB_P010, 3840, 2160, 30, 24, 30 },
320
321 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 640, 360, 30, 24, 30 },
322 } },
323 { CameraFrameworkUnitTest::PHOTO_STREAM,
324 {
325 { OHOS_CAMERA_FORMAT_JPEG, 2304, 2304, 0, 0, 0 },
326 { OHOS_CAMERA_FORMAT_JPEG, 3072, 2304, 0, 0, 0 },
327 { OHOS_CAMERA_FORMAT_JPEG, 4096, 2304, 0, 0, 0 },
328
329 { OHOS_CAMERA_FORMAT_JPEG, 1280, 960, 0, 0, 0 },
330 { OHOS_CAMERA_FORMAT_JPEG, 1280, 720, 0, 0, 0 },
331 { OHOS_CAMERA_FORMAT_JPEG, 1920, 1080, 0, 0, 0 },
332 { OHOS_CAMERA_FORMAT_JPEG, 3840, 2160, 0, 0, 0 },
333 } },
334 } };
335
336 const ModeConfig PORTRAIT_MODE_CONFIG = { CameraFrameworkUnitTest::PORTRAIT_MODE, {
337 { CameraFrameworkUnitTest::PREVIEW_STREAM, {
338 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 640, 480, 0, 0, 0, {
339 CameraFrameworkUnitTest::ABILITY_ID_ONE,
340 CameraFrameworkUnitTest::ABILITY_ID_TWO,
341 CameraFrameworkUnitTest::ABILITY_ID_THREE,
342 CameraFrameworkUnitTest::ABILITY_ID_FOUR } } } },
343 { CameraFrameworkUnitTest::VIDEO_STREAM, {
344 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 640, 360, 30, 0, 0, {
345 CameraFrameworkUnitTest::ABILITY_ID_ONE,
346 CameraFrameworkUnitTest::ABILITY_ID_TWO,
347 CameraFrameworkUnitTest::ABILITY_ID_THREE,
348 CameraFrameworkUnitTest::ABILITY_ID_FOUR } } } },
349 { CameraFrameworkUnitTest::PHOTO_STREAM, {
350 { OHOS_CAMERA_FORMAT_JPEG, 1280, 960, 0, 0, 0, {
351 CameraFrameworkUnitTest::ABILITY_ID_ONE,
352 CameraFrameworkUnitTest::ABILITY_ID_TWO,
353 CameraFrameworkUnitTest::ABILITY_ID_THREE,
354 CameraFrameworkUnitTest::ABILITY_ID_FOUR } } } } } };
355
356 const ModeConfig NIGHT_MODE_CONFIG = { CameraFrameworkUnitTest::NIGHT_MODE, {
357 { CameraFrameworkUnitTest::PREVIEW_STREAM, {
358 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 640, 480, 0, 0, 0, {
359 CameraFrameworkUnitTest::ABILITY_ID_ONE,
360 CameraFrameworkUnitTest::ABILITY_ID_TWO,
361 CameraFrameworkUnitTest::ABILITY_ID_THREE,
362 CameraFrameworkUnitTest::ABILITY_ID_FOUR } } } },
363 { CameraFrameworkUnitTest::VIDEO_STREAM, {
364 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 640, 360, 30, 0, 0, {
365 CameraFrameworkUnitTest::ABILITY_ID_ONE,
366 CameraFrameworkUnitTest::ABILITY_ID_TWO,
367 CameraFrameworkUnitTest::ABILITY_ID_THREE,
368 CameraFrameworkUnitTest::ABILITY_ID_FOUR } } } },
369 { CameraFrameworkUnitTest::PHOTO_STREAM, {
370 { OHOS_CAMERA_FORMAT_JPEG, 1280, 960, 0, 0, 0, {
371 CameraFrameworkUnitTest::ABILITY_ID_ONE,
372 CameraFrameworkUnitTest::ABILITY_ID_TWO,
373 CameraFrameworkUnitTest::ABILITY_ID_THREE,
374 CameraFrameworkUnitTest::ABILITY_ID_FOUR } } } } } };
375
376 const ModeConfig SCAN_MODE_CONFIG = { CameraFrameworkUnitTest::SCAN_MODE, {
377 { CameraFrameworkUnitTest::PREVIEW_STREAM, {
378 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 640, 480, 0, 0, 0, {
379 CameraFrameworkUnitTest::ABILITY_ID_ONE,
380 CameraFrameworkUnitTest::ABILITY_ID_TWO,
381 CameraFrameworkUnitTest::ABILITY_ID_THREE,
382 CameraFrameworkUnitTest::ABILITY_ID_FOUR } } } },
383 { CameraFrameworkUnitTest::VIDEO_STREAM, {
384 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 640, 360, 30, 0, 0, {
385 CameraFrameworkUnitTest::ABILITY_ID_ONE,
386 CameraFrameworkUnitTest::ABILITY_ID_TWO,
387 CameraFrameworkUnitTest::ABILITY_ID_THREE,
388 CameraFrameworkUnitTest::ABILITY_ID_FOUR } } } },
389 { CameraFrameworkUnitTest::PHOTO_STREAM, {
390 { OHOS_CAMERA_FORMAT_JPEG, 1280, 960, 0, 0, 0, {
391 CameraFrameworkUnitTest::ABILITY_ID_ONE,
392 CameraFrameworkUnitTest::ABILITY_ID_TWO,
393 CameraFrameworkUnitTest::ABILITY_ID_THREE,
394 CameraFrameworkUnitTest::ABILITY_ID_FOUR, } } } } } };
395
396 const ModeConfig SLOW_MODE_CONFIG = { CameraFrameworkUnitTest::SLOW_MODE, {
397 { CameraFrameworkUnitTest::PREVIEW_STREAM, {
398 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1920, 1080, 0, 0, 0} } },
399 { CameraFrameworkUnitTest::VIDEO_STREAM, {
400 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, 1920, 1080, 0, 0, 0} } }}};
401
402 const ModeConfigs ABILITY_MODE_CONFIGS = ModeConfigs(std::vector<ModeConfig> { DEFAULT_MODE_CONFIG,
403 PHOTO_MODE_CONFIG, VIDEO_MODE_CONFIG, PORTRAIT_MODE_CONFIG, NIGHT_MODE_CONFIG, SCAN_MODE_CONFIG,
404 SLOW_MODE_CONFIG });
405
406 uint8_t filterAbility[2] = {0, 1};
407 int32_t filterControl[2] = {0, 1};
408 uint8_t beautyAbility[5] = {OHOS_CAMERA_BEAUTY_TYPE_OFF, OHOS_CAMERA_BEAUTY_TYPE_AUTO,
409 OHOS_CAMERA_BEAUTY_TYPE_SKIN_SMOOTH, OHOS_CAMERA_BEAUTY_TYPE_FACE_SLENDER,
410 OHOS_CAMERA_BEAUTY_TYPE_SKIN_TONE};
411 uint8_t faceSlenderBeautyRange[2] = {2, 3};
412 int32_t faceSlenderBeautyControl[2] = {2, 3};
413 int32_t effectAbility[2] = {0, 1};
414 int32_t effectControl[2] = {0, 1};
415 int32_t photoFormats[2] = {OHOS_CAMERA_FORMAT_YCRCB_420_SP, OHOS_CAMERA_FORMAT_JPEG};
416 class MockStatusCallback : public StatusCallback {
417 public:
OnCameraStatus(const std::string & cameraId,CameraStatus status,CallbackInvoker invoker)418 void OnCameraStatus(const std::string& cameraId, CameraStatus status, CallbackInvoker invoker) override
419 {
420 MEDIA_DEBUG_LOG("MockStatusCallback::OnCameraStatus");
421 return;
422 }
OnFlashlightStatus(const std::string & cameraId,FlashStatus status)423 void OnFlashlightStatus(const std::string& cameraId, FlashStatus status) override
424 {
425 MEDIA_DEBUG_LOG("MockStatusCallback::OnFlashlightStatus");
426 return;
427 }
OnTorchStatus(TorchStatus status)428 void OnTorchStatus(TorchStatus status) override
429 {
430 MEDIA_DEBUG_LOG("MockStatusCallback::OnTorchStatus");
431 return;
432 }
433 };
434
MockHCameraHostManager(std::shared_ptr<StatusCallback> statusCallback)435 explicit MockHCameraHostManager(std::shared_ptr<StatusCallback> statusCallback) : HCameraHostManager(statusCallback)
436 {
437 cameraDevice = new MockCameraDevice();
438 ON_CALL(*this, GetCameras).WillByDefault([](std::vector<std::string> &cameraIds) {
439 cameraIds.emplace_back("cam0");
440 return CAMERA_OK;
441 });
442 ON_CALL(*this, GetVersionByCamera).WillByDefault([](const std::string& cameraId) {
443 const uint32_t offset = 8;
444 uint32_t major = 1;
445 uint32_t minor = 1;
446 return static_cast<int32_t>((major << offset) | minor);
447 });
448 ON_CALL(*this, GetCameraAbility).WillByDefault([this](std::string &cameraId,
449 std::shared_ptr<OHOS::Camera::CameraMetadata> &ability) {
450 int32_t itemCount = 10;
451 int32_t dataSize = 100;
452 auto streamsInfo = ABILITY_MODE_CONFIGS.GetDatas();
453 ability = std::make_shared<OHOS::Camera::CameraMetadata>(itemCount, dataSize);
454 ability->addEntry(
455 OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, streamsInfo.data(), streamsInfo.size());
456
457 ability->addEntry(
458 OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, streamsInfo.data(), streamsInfo.size());
459
460 if (g_mockFlagWithoutAbt) {
461 return CAMERA_OK;
462 }
463 if (g_getCameraAbilityerror) {
464 g_getCameraAbilityerror = false;
465 return CAMERA_ALLOC_ERROR;
466 }
467
468 int32_t compensationRange[2] = {0, 0};
469 ability->addEntry(OHOS_ABILITY_AE_COMPENSATION_RANGE, compensationRange,
470 sizeof(compensationRange) / sizeof(compensationRange[0]));
471 float focalLength = 1.5;
472 ability->addEntry(OHOS_ABILITY_FOCAL_LENGTH, &focalLength, sizeof(float));
473
474 int32_t sensorOrientation = 0;
475 ability->addEntry(OHOS_SENSOR_ORIENTATION, &sensorOrientation, sizeof(int32_t));
476
477 int32_t cameraPosition = 0;
478 ability->addEntry(OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, sizeof(int32_t));
479
480 const camera_rational_t aeCompensationStep[] = {{0, 1}};
481 ability->addEntry(OHOS_ABILITY_AE_COMPENSATION_STEP, &aeCompensationStep,
482 sizeof(aeCompensationStep) / sizeof(aeCompensationStep[0]));
483
484 int32_t zoomCap[2] = {0, 10};
485 ability->addEntry(OHOS_ABILITY_ZOOM_CAP, &zoomCap,
486 sizeof(zoomCap) / sizeof(zoomCap[0]));
487
488 int32_t sceneZoomCap[2] = {1, 10};
489 ability->addEntry(OHOS_ABILITY_SCENE_ZOOM_CAP, &sceneZoomCap,
490 sizeof(zoomCap) / sizeof(zoomCap[0]));
491
492 float zoomRatio = 1.0;
493 ability->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, sizeof(float));
494
495 uint8_t flaMode = OHOS_CAMERA_FLASH_MODE_ALWAYS_OPEN;
496 ability->addEntry(OHOS_CONTROL_FLASH_MODE, &flaMode, sizeof(uint8_t));
497
498 uint8_t flashstate = OHOS_CAMERA_FLASH_STATE_READY;
499 ability->addEntry(OHOS_CONTROL_FLASH_STATE, &flashstate, sizeof(uint8_t));
500
501 uint8_t fMode = FOCUS_MODE_AUTO;
502 ability->addEntry(OHOS_CONTROL_FOCUS_MODE, &fMode, sizeof(uint8_t));
503
504 uint8_t focusState = OHOS_CAMERA_FOCUS_STATE_SCAN;
505 ability->addEntry(OHOS_CONTROL_FOCUS_STATE, &focusState, sizeof(uint8_t));
506
507 uint8_t exMode = 0;
508 ability->addEntry(OHOS_CONTROL_EXPOSURE_MODE, &exMode, sizeof(uint8_t));
509
510 uint8_t muteMode = OHOS_CAMERA_MUTE_MODE_OFF;
511 ability->addEntry(OHOS_CONTROL_MUTE_MODE, &muteMode, sizeof(uint8_t));
512
513 int32_t activeArraySize[] = {
514 0, 0, CameraFrameworkUnitTest::PREVIEW_DEFAULT_WIDTH, CameraFrameworkUnitTest::PREVIEW_DEFAULT_HEIGHT
515 };
516 ability->addEntry(OHOS_SENSOR_INFO_ACTIVE_ARRAY_SIZE, &activeArraySize, sizeof(int32_t));
517
518 uint8_t videoStabilizationMode = OHOS_CAMERA_VIDEO_STABILIZATION_OFF;
519 ability->addEntry(OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &videoStabilizationMode, sizeof(uint8_t));
520
521 uint8_t faceDetectMode = OHOS_CAMERA_FACE_DETECT_MODE_SIMPLE;
522 ability->addEntry(OHOS_STATISTICS_FACE_DETECT_MODE, &faceDetectMode, sizeof(uint8_t));
523
524 uint8_t type = 5;
525 ability->addEntry(OHOS_ABILITY_CAMERA_TYPE, &type, sizeof(uint8_t));
526 uint8_t value_u8 = 0;
527 ability->addEntry(OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &value_u8, sizeof(uint8_t));
528 ability->addEntry(OHOS_ABILITY_FLASH_MODES, &value_u8, sizeof(uint8_t));
529 ability->addEntry(OHOS_ABILITY_FOCUS_MODES, &value_u8, sizeof(uint8_t));
530 ability->addEntry(OHOS_ABILITY_EXPOSURE_MODES, &value_u8, sizeof(uint8_t));
531 ability->addEntry(OHOS_ABILITY_VIDEO_STABILIZATION_MODES, &value_u8, sizeof(uint8_t));
532 ability->addEntry(OHOS_ABILITY_PRELAUNCH_AVAILABLE, &value_u8, sizeof(uint8_t));
533 ability->addEntry(OHOS_ABILITY_STREAM_QUICK_THUMBNAIL_AVAILABLE, &value_u8, sizeof(uint8_t));
534 ability->addEntry(OHOS_ABILITY_MUTE_MODES, &value_u8, sizeof(uint8_t));
535
536 uint32_t value_u32[2] = {0, 10};
537 ability->addEntry(OHOS_ABILITY_FPS_RANGES, &value_u32, sizeof(value_u32) / sizeof(value_u32[0]));
538
539 float value_f[1] = {1.0};
540 ability->addEntry(OHOS_ABILITY_ZOOM_RATIO_RANGE, &value_f, sizeof(value_f) / sizeof(value_f[0]));
541
542 int32_t aeRegions = 0;
543 ability->addEntry(OHOS_CONTROL_AE_REGIONS, &aeRegions, sizeof(int32_t));
544
545 int32_t aeExposureCompensation = 0;
546 ability->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, sizeof(int32_t));
547
548 uint8_t exposureState = 0;
549 ability->addEntry(OHOS_CONTROL_EXPOSURE_STATE, &exposureState, sizeof(uint8_t));
550
551 uint8_t mirror = OHOS_CAMERA_MIRROR_OFF;
552 ability->addEntry(OHOS_CONTROL_CAPTURE_MIRROR, &mirror, sizeof(uint8_t));
553
554 int32_t orientation = OHOS_CAMERA_JPEG_ROTATION_0;
555 ability->addEntry(OHOS_JPEG_ORIENTATION, &orientation, sizeof(int32_t));
556
557 std::vector<uint8_t> modes = ABILITY_MODE_CONFIGS.GetModes();
558 ability->addEntry(OHOS_ABILITY_CAMERA_MODES, modes.data(), modes.size());
559
560 ability->addEntry(OHOS_ABILITY_SCENE_FILTER_TYPES, &filterAbility,
561 sizeof(filterAbility) / sizeof(filterAbility[0]));
562
563 ability->addEntry(OHOS_CONTROL_FILTER_TYPE, &filterControl,
564 sizeof(filterControl) / sizeof(filterControl[0]));
565
566 ability->addEntry(OHOS_ABILITY_SCENE_BEAUTY_TYPES, beautyAbility,
567 sizeof(beautyAbility) / sizeof(beautyAbility[0]));
568
569 ability->addEntry(OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES, &faceSlenderBeautyRange,
570 sizeof(faceSlenderBeautyRange) / sizeof(faceSlenderBeautyRange[0]));
571
572 ability->addEntry(OHOS_CONTROL_BEAUTY_FACE_SLENDER_VALUE, &faceSlenderBeautyControl,
573 sizeof(faceSlenderBeautyControl) / sizeof(faceSlenderBeautyControl[0]));
574
575 ability->addEntry(OHOS_ABILITY_SCENE_PORTRAIT_EFFECT_TYPES, &effectAbility,
576 sizeof(effectAbility) / sizeof(effectAbility[0]));
577
578 ability->addEntry(OHOS_CONTROL_PORTRAIT_EFFECT_TYPE, &effectControl,
579 sizeof(effectControl) / sizeof(effectControl[0]));
580 ability->addEntry(OHOS_STREAM_AVAILABLE_FORMATS, &photoFormats,
581 sizeof(photoFormats) / sizeof(photoFormats[0]));
582 return CAMERA_OK;
583 });
584 ON_CALL(*this, OpenCameraDevice).WillByDefault([this](std::string &cameraId,
585 const sptr<ICameraDeviceCallback> &callback,
586 sptr<OHOS::HDI::Camera::V1_0::ICameraDevice> &pDevice,
587 bool isEnableSecCam) {
588 pDevice = cameraDevice;
589 return CAMERA_OK;
590 });
591 ON_CALL(*this, SetFlashlight(_, _)).WillByDefault(Return(CAMERA_OK));
592 ON_CALL(*this, SetCallback(_)).WillByDefault(Return(CAMERA_OK));
593 }
~MockHCameraHostManager()594 ~MockHCameraHostManager() {}
595 MOCK_METHOD1(GetVersionByCamera, int32_t(const std::string& cameraId));
596 MOCK_METHOD1(GetCameras, int32_t(std::vector<std::string> &cameraIds));
597 MOCK_METHOD1(SetCallback, int32_t(sptr<ICameraHostCallback> &callback));
598 MOCK_METHOD2(GetCameraAbility, int32_t(std::string &cameraId,
599 std::shared_ptr<OHOS::Camera::CameraMetadata> &ability));
600 MOCK_METHOD2(SetFlashlight, int32_t(const std::string &cameraId, bool isEnable));
601 MOCK_METHOD4(OpenCameraDevice, int32_t(std::string &cameraId,
602 const sptr<ICameraDeviceCallback> &callback, sptr<OHOS::HDI::Camera::V1_0::ICameraDevice> &pDevice,
603 bool isEnableSecCam));
604 sptr<MockCameraDevice> cameraDevice;
605 };
606
607 class MockCameraManager : public CameraManager {
608 public:
609 MOCK_METHOD0(GetIsFoldable, bool());
610 MOCK_METHOD0(GetFoldStatus, FoldStatus());
~MockCameraManager()611 ~MockCameraManager() {}
612 };
613
614 class FakeHCameraService : public HCameraService {
615 public:
FakeHCameraService(sptr<HCameraHostManager> hostManager)616 explicit FakeHCameraService(sptr<HCameraHostManager> hostManager) : HCameraService(hostManager)
617 {
618 SetServiceStatus(CameraServiceStatus::SERVICE_READY);
619 }
~FakeHCameraService()620 ~FakeHCameraService() {}
621 };
622
623 class FakeCameraManager : public CameraManager {
624 public:
FakeCameraManager(sptr<HCameraService> service)625 explicit FakeCameraManager(sptr<HCameraService> service) : CameraManager(service) {}
~FakeCameraManager()626 ~FakeCameraManager() {}
627 };
628
629 class CallbackListener : public FocusCallback, public ExposureCallback {
630 public:
OnFocusState(FocusState state)631 void OnFocusState(FocusState state) override
632 {
633 MEDIA_DEBUG_LOG("CallbackListener::OnFocusState ");
634 return;
635 }
636
OnExposureState(ExposureState state)637 void OnExposureState(ExposureState state) override
638 {
639 MEDIA_DEBUG_LOG("CallbackListener::OnExposureState ");
640 return;
641 }
642 };
643
644 class AppSessionCallback : public SessionCallback {
645 public:
OnError(int32_t errorCode)646 void OnError(int32_t errorCode)
647 {
648 MEDIA_DEBUG_LOG("AppMetadataCallback::OnError %{public}d", errorCode);
649 return;
650 }
651 };
652
653 class AppMacroStatusCallback : public MacroStatusCallback {
654 public:
OnMacroStatusChanged(MacroStatus status)655 void OnMacroStatusChanged(MacroStatus status)
656 {
657 MEDIA_DEBUG_LOG("AppMacroStatusCallback");
658 }
659 };
660
661 class AppMetadataCallback : public MetadataObjectCallback, public MetadataStateCallback {
662 public:
OnMetadataObjectsAvailable(std::vector<sptr<MetadataObject>> metaObjects) const663 void OnMetadataObjectsAvailable(std::vector<sptr<MetadataObject>> metaObjects) const
664 {
665 MEDIA_DEBUG_LOG("AppMetadataCallback::OnMetadataObjectsAvailable received");
666 }
OnError(int32_t errorCode) const667 void OnError(int32_t errorCode) const
668 {
669 MEDIA_DEBUG_LOG("AppMetadataCallback::OnError %{public}d", errorCode);
670 }
671 };
672
673 class TestSlowMotionStateCallback : public SlowMotionStateCallback {
674 public:
OnSlowMotionState(const SlowMotionState state)675 void OnSlowMotionState(const SlowMotionState state)
676 {
677 MEDIA_INFO_LOG("TestSlowMotionStateCallback OnSlowMotionState.");
678 }
679 };
680
681 class TestExposureCallback : public ExposureCallback {
682 public:
OnExposureState(ExposureState state)683 void OnExposureState(ExposureState state)
684 {
685 MEDIA_INFO_LOG("TestExposureCallback OnExposureState.");
686 }
687 };
688
689 class TestSmoothZoomCallback : public SmoothZoomCallback {
690 public:
OnSmoothZoom(int32_t duration)691 void OnSmoothZoom(int32_t duration)
692 {
693 MEDIA_INFO_LOG("TestSmoothZoomCallback OnSmoothZoom.");
694 }
695 };
696
697 class TestAbilityCallback : public AbilityCallback {
698 public:
OnAbilityChange()699 void OnAbilityChange()
700 {
701 MEDIA_INFO_LOG("TestAbilityCallback OnAbilityChange.");
702 }
703 };
704
705 class TestFocusCallback : public FocusCallback {
706 public:
OnFocusState(FocusState state)707 void OnFocusState(FocusState state)
708 {
709 MEDIA_INFO_LOG("TestFocusCallback OnFocusState.");
710 }
711 };
712
713 class TestARCallback : public ARCallback {
714 public:
OnResult(const ARStatusInfo & arStatusInfo) const715 void OnResult(const ARStatusInfo &arStatusInfo) const
716 {
717 MEDIA_INFO_LOG("TestARCallback OnResult.");
718 }
719 };
720
CreatePhotoOutput(int32_t width,int32_t height)721 sptr<CaptureOutput> CameraFrameworkUnitTest::CreatePhotoOutput(int32_t width, int32_t height)
722 {
723 sptr<IConsumerSurface> surface = IConsumerSurface::Create();
724 if (surface == nullptr) {
725 return nullptr;
726 }
727 CameraFormat photoFormat = CAMERA_FORMAT_JPEG;
728 Size photoSize;
729 photoSize.width = width;
730 photoSize.height = height;
731 Profile photoProfile = Profile(photoFormat, photoSize);
732 sptr<IBufferProducer> surfaceProducer = surface->GetProducer();
733 return cameraManager->CreatePhotoOutput(photoProfile, surfaceProducer);
734 }
735
CreatePreviewOutput(int32_t width,int32_t height)736 sptr<CaptureOutput> CameraFrameworkUnitTest::CreatePreviewOutput(int32_t width, int32_t height)
737 {
738 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
739 if (surface == nullptr) {
740 return nullptr;
741 }
742 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
743 Size previewSize;
744 previewSize.width = width;
745 previewSize.height = height;
746 Profile previewProfile = Profile(previewFormat, previewSize);
747 return cameraManager->CreatePreviewOutput(previewProfile, surface);
748 }
749
CreateVideoOutput(int32_t width,int32_t height)750 sptr<CaptureOutput> CameraFrameworkUnitTest::CreateVideoOutput(int32_t width, int32_t height)
751 {
752 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
753 if (surface == nullptr) {
754 return nullptr;
755 }
756 CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
757 Size videoSize;
758 videoSize.width = width;
759 videoSize.height = height;
760 std::vector<int32_t> videoFramerates = {30, 30};
761 VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates);
762 return cameraManager->CreateVideoOutput(videoProfile, surface);
763 }
764
SessionCommit(sptr<CaptureSession> session)765 void CameraFrameworkUnitTest::SessionCommit(sptr<CaptureSession> session)
766 {
767 int32_t ret = session->CommitConfig();
768 EXPECT_EQ(ret, 0);
769 int32_t captureId = 3;
770 EXPECT_CALL(*mockStreamOperator, Capture(captureId, _, true));
771 ret = session->Start();
772 EXPECT_EQ(ret, 0);
773 }
774
SessionControlParams(sptr<CaptureSession> session)775 void CameraFrameworkUnitTest::SessionControlParams(sptr<CaptureSession> session)
776 {
777 session->LockForControl();
778
779 std::vector<float> zoomRatioRange = session->GetZoomRatioRange();
780 if (!zoomRatioRange.empty()) {
781 session->SetZoomRatio(zoomRatioRange[0]);
782 }
783
784 std::vector<float> exposurebiasRange = session->GetExposureBiasRange();
785 if (!exposurebiasRange.empty()) {
786 session->SetExposureBias(exposurebiasRange[0]);
787 }
788
789 FlashMode flash = FLASH_MODE_ALWAYS_OPEN;
790 bool flashSupported = session->IsFlashModeSupported(flash);
791 if (flashSupported) {
792 session->SetFlashMode(flash);
793 }
794
795 FocusMode focus = FOCUS_MODE_AUTO;
796 bool focusSupported = session->IsFocusModeSupported(focus);
797 if (focusSupported) {
798 session->SetFocusMode(focus);
799 }
800
801 ExposureMode exposure = EXPOSURE_MODE_AUTO;
802 bool exposureSupported = session->IsExposureModeSupported(exposure);
803 if (exposureSupported) {
804 session->SetExposureMode(exposure);
805 }
806
807 session->UnlockForControl();
808
809 if (!exposurebiasRange.empty()) {
810 EXPECT_EQ(session->GetExposureValue(), exposurebiasRange[0]);
811 }
812
813 if (flashSupported) {
814 EXPECT_EQ(session->GetFlashMode(), flash);
815 }
816
817 if (focusSupported) {
818 EXPECT_EQ(session->GetFocusMode(), focus);
819 }
820
821 if (exposureSupported) {
822 EXPECT_EQ(session->GetExposureMode(), exposure);
823 }
824 }
825
PortraitSessionControlParams(sptr<PortraitSession> portraitSession)826 void CameraFrameworkUnitTest::PortraitSessionControlParams(sptr<PortraitSession> portraitSession)
827 {
828 portraitSession->LockForControl();
829
830 std::vector<PortraitEffect> effects= portraitSession->GetSupportedPortraitEffects();
831 ASSERT_TRUE(effects.size() != 0);
832
833 if (!effects.empty()) {
834 portraitSession->SetPortraitEffect(effects[0]);
835 }
836
837 std::vector<FilterType> filterLists= portraitSession->GetSupportedFilters();
838 ASSERT_TRUE(filterLists.size() != 0);
839
840 if (!filterLists.empty()) {
841 portraitSession->SetFilter(filterLists[0]);
842 }
843
844 std::vector<BeautyType> beautyLists= portraitSession->GetSupportedBeautyTypes();
845 ASSERT_TRUE(beautyLists.size() != 0);
846
847 std::vector<int32_t> rangeLists= portraitSession->GetSupportedBeautyRange(beautyLists[ARRAY_IDX]);
848 ASSERT_TRUE(rangeLists.size() != 0);
849
850 if (!beautyLists.empty()) {
851 portraitSession->SetBeauty(beautyLists[ARRAY_IDX], rangeLists[0]);
852 }
853
854 portraitSession->UnlockForControl();
855 ASSERT_EQ(portraitSession->GetPortraitEffect(), effects[0]);
856 ASSERT_EQ(portraitSession->GetFilter(), filterLists[0]);
857 ASSERT_EQ(portraitSession->GetBeauty(beautyLists[ARRAY_IDX]), rangeLists[0]);
858 }
859
PortraitSessionEffectParams(sptr<PortraitSession> portraitSession)860 void CameraFrameworkUnitTest::PortraitSessionEffectParams(sptr<PortraitSession> portraitSession)
861 {
862 std::vector<PortraitEffect> effects= portraitSession->GetSupportedPortraitEffects();
863 ASSERT_TRUE(effects.size() != 0);
864
865 if (!effects.empty()) {
866 portraitSession->LockForControl();
867 portraitSession->SetPortraitEffect(effects[0]);
868 portraitSession->UnlockForControl();
869 }
870 ASSERT_EQ(portraitSession->GetPortraitEffect(), effects[0]);
871 }
872
PortraitSessionFilterParams(sptr<PortraitSession> portraitSession)873 void CameraFrameworkUnitTest::PortraitSessionFilterParams(sptr<PortraitSession> portraitSession)
874 {
875 std::vector<FilterType> filterLists= portraitSession->GetSupportedFilters();
876 ASSERT_TRUE(filterLists.size() != 0);
877
878 if (!filterLists.empty()) {
879 portraitSession->LockForControl();
880 portraitSession->SetFilter(filterLists[0]);
881 portraitSession->UnlockForControl();
882 }
883 ASSERT_EQ(portraitSession->GetFilter(), filterLists[0]);
884 }
885
PortraitSessionBeautyParams(sptr<PortraitSession> portraitSession)886 void CameraFrameworkUnitTest::PortraitSessionBeautyParams(sptr<PortraitSession> portraitSession)
887 {
888 std::vector<BeautyType> beautyLists= portraitSession->GetSupportedBeautyTypes();
889 ASSERT_TRUE(beautyLists.size() != 0);
890
891 std::vector<int32_t> rangeLists= portraitSession->GetSupportedBeautyRange(beautyLists[ARRAY_IDX]);
892 ASSERT_TRUE(rangeLists.size() != 0);
893
894 if (!beautyLists.empty()) {
895 portraitSession->LockForControl();
896 portraitSession->SetBeauty(beautyLists[ARRAY_IDX], rangeLists[0]);
897 portraitSession->UnlockForControl();
898 }
899 ASSERT_EQ(portraitSession->GetBeauty(beautyLists[ARRAY_IDX]), rangeLists[0]);
900 }
901
SetUpTestCase(void)902 void CameraFrameworkUnitTest::SetUpTestCase(void) {}
903
TearDownTestCase(void)904 void CameraFrameworkUnitTest::TearDownTestCase(void)
905 {
906 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
907 SceneMode mode = PORTRAIT;
908 sptr<HCaptureSession> camSession = new (std::nothrow) HCaptureSession(callerToken, mode);
909 camSession->Release();
910 }
911
SetUp()912 void CameraFrameworkUnitTest::SetUp()
913 {
914 // set native token
915 g_num++;
916 MEDIA_DEBUG_LOG("CameraFrameworkUnitTest::SetUp num:%{public}d", g_num);
917 NativeAuthorization();
918 g_mockFlagWithoutAbt = false;
919 mockCameraHostManager = new MockHCameraHostManager(nullptr);
920 mockCameraDevice = mockCameraHostManager->cameraDevice;
921 mockStreamOperator = mockCameraDevice->streamOperator;
922 cameraManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager));
923 mockCameraManager = new MockCameraManager();
924 }
925
NativeAuthorization()926 void CameraFrameworkUnitTest::NativeAuthorization()
927 {
928 const char *perms[2];
929 perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
930 perms[1] = "ohos.permission.CAMERA";
931 NativeTokenInfoParams infoInstance = {
932 .dcapsNum = 0,
933 .permsNum = 2,
934 .aclsNum = 0,
935 .dcaps = NULL,
936 .perms = perms,
937 .acls = NULL,
938 .processName = "native_camera_tdd",
939 .aplStr = "system_basic",
940 };
941 g_tokenId_ = GetAccessTokenId(&infoInstance);
942 g_uid_ = IPCSkeleton::GetCallingUid();
943 AccountSA::OsAccountManager::GetOsAccountLocalIdFromUid(g_uid_, g_userId_);
944 MEDIA_DEBUG_LOG("CameraFrameworkUnitTest::NativeAuthorization g_uid:%{public}d", g_uid_);
945 SetSelfTokenID(g_tokenId_);
946 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
947 }
948
TearDown()949 void CameraFrameworkUnitTest::TearDown()
950 {
951 Mock::AllowLeak(mockCameraHostManager);
952 Mock::AllowLeak(mockCameraDevice);
953 Mock::AllowLeak(mockStreamOperator);
954 Mock::AllowLeak(mockCameraManager);
955 MEDIA_DEBUG_LOG("CameraFrameworkUnitTest::TearDown num:%{public}d", g_num);
956 }
957
958 MATCHER_P(matchCaptureSetting, captureSetting, "Match Capture Setting")
959 {
960 std::vector<uint8_t> result;
961 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(captureSetting, result);
962 return (arg.captureSetting_ == result);
963 }
964
965 /*
966 * Feature: Framework
967 * Function: Test get HostName
968 * SubFunction: NA
969 * FunctionPoints: NA
970 * EnvConditions: NA
971 * CaseDescription: Test get HostName
972 */
973 HWTEST_F(CameraFrameworkUnitTest, Camera_fwInfoManager_unittest_001, TestSize.Level0)
974 {
975 InSequence s;
976 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
977 ASSERT_NE(static_cast<int>(cameras.size()), 0);
978 std::string hostName = cameras[0]->GetHostName();
979 ASSERT_EQ(hostName, "");
980 }
981
982 /*
983 * Feature: Framework
984 * Function: Test get DeviceType
985 * SubFunction: NA
986 * FunctionPoints: NA
987 * EnvConditions: NA
988 * CaseDescription: Test get DeviceType
989 */
990 HWTEST_F(CameraFrameworkUnitTest, Camera_fwInfoManager_unittest_002, TestSize.Level0)
991 {
992 InSequence s;
993 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
994 ASSERT_NE(static_cast<int>(cameras.size()), 0);
__anon779f14c50702() 995 auto judgeDeviceType = [&cameras] () -> bool {
996 bool isOk = false;
997 uint16_t deviceType = cameras[0]->GetDeviceType();
998 switch (deviceType) {
999 case UNKNOWN:
1000 case PHONE:
1001 case TABLET:
1002 isOk = true;
1003 break;
1004 default:
1005 isOk = false;
1006 break;
1007 }
1008 return isOk;
1009 };
1010 ASSERT_NE(judgeDeviceType(), false);
1011 }
1012
1013 /*
1014 * Feature: Framework
1015 * Function: Test result callback
1016 * SubFunction: NA
1017 * FunctionPoints: NA
1018 * EnvConditions: NA
1019 * CaseDescription: Test result callback
1020 */
1021 HWTEST_F(CameraFrameworkUnitTest, Camera_ResultCallback_unittest, TestSize.Level0)
1022 {
1023 InSequence s;
1024 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1025
1026 sptr<CameraInput> input = cameraManager->CreateCameraInput(cameras[0]);
1027 ASSERT_NE(input, nullptr);
1028
1029 std::shared_ptr<TestOnResultCallback> setResultCallback =
1030 std::make_shared<TestOnResultCallback>("OnResultCallback");
1031
1032 input->SetResultCallback(setResultCallback);
1033 std::shared_ptr<ResultCallback> getResultCallback = input->GetResultCallback();
1034 ASSERT_EQ(getResultCallback, setResultCallback);
1035 }
1036
1037 /*
1038 * Feature: Framework
1039 * Function: Test get cameras
1040 * SubFunction: NA
1041 * FunctionPoints: NA
1042 * EnvConditions: NA
1043 * CaseDescription: Test get cameras
1044 */
1045 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_001, TestSize.Level0)
1046 {
1047 InSequence s;
1048 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1049 ASSERT_TRUE(cameras.size() != 0);
1050 }
1051
1052 /*
1053 * Feature: Framework
1054 * Function: Test create input
1055 * SubFunction: NA
1056 * FunctionPoints: NA
1057 * EnvConditions: NA
1058 * CaseDescription: Test create input
1059 */
1060 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_002, TestSize.Level0)
1061 {
1062 InSequence s;
1063 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1064 ASSERT_TRUE(cameras.size() != 0);
1065 sptr<CameraInput> input = cameraManager->CreateCameraInput(cameras[0]);
1066 ASSERT_NE(input, nullptr);
1067
1068 ASSERT_NE(input->GetCameraDevice(), nullptr);
1069
1070 input->Release();
1071 }
1072
1073 /*
1074 * Feature: Framework
1075 * Function: Test create session
1076 * SubFunction: NA
1077 * FunctionPoints: NA
1078 * EnvConditions: NA
1079 * CaseDescription: Test create session
1080 */
1081 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_003, TestSize.Level0)
1082 {
1083 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1084 ASSERT_NE(session, nullptr);
1085 EXPECT_EQ(session->Release(), 0);
1086 }
1087
1088 /*
1089 * Feature: Framework
1090 * Function: Test create preview output
1091 * SubFunction: NA
1092 * FunctionPoints: NA
1093 * EnvConditions: NA
1094 * CaseDescription: Test create preview output
1095 */
1096 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_004, TestSize.Level0)
1097 {
1098 int32_t width = PREVIEW_DEFAULT_WIDTH;
1099 int32_t height = PREVIEW_DEFAULT_HEIGHT;
1100 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
1101 Size previewSize;
1102 previewSize.width = width;
1103 previewSize.height = height;
1104 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
1105 Profile previewProfile = Profile(previewFormat, previewSize);
1106 sptr<CaptureOutput> preview = cameraManager->CreatePreviewOutput(previewProfile, surface);
1107 ASSERT_NE(preview, nullptr);
1108 preview->Release();
1109 }
1110
1111 /*
1112 * Feature: Framework
1113 * Function: Test create preview output with surface as null
1114 * SubFunction: NA
1115 * FunctionPoints: NA
1116 * EnvConditions: NA
1117 * CaseDescription: Test create preview output with surface as null
1118 */
1119 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_005, TestSize.Level0)
1120 {
1121 int32_t width = PREVIEW_DEFAULT_WIDTH;
1122 int32_t height = PREVIEW_DEFAULT_HEIGHT;
1123 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
1124 Size previewSize;
1125 previewSize.width = width;
1126 previewSize.height = height;
1127 Profile previewProfile = Profile(previewFormat, previewSize);
1128 sptr<Surface> surface = nullptr;
1129 sptr<CaptureOutput> preview = cameraManager->CreatePreviewOutput(previewProfile, surface);
1130 ASSERT_EQ(preview, nullptr);
1131 }
1132
1133
1134 /*
1135 * Feature: Framework
1136 * Function: Test create photo output
1137 * SubFunction: NA
1138 * FunctionPoints: NA
1139 * EnvConditions: NA
1140 * CaseDescription: Test create photo output
1141 */
1142 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_011, TestSize.Level0)
1143 {
1144 int32_t width = PHOTO_DEFAULT_WIDTH;
1145 int32_t height = PHOTO_DEFAULT_HEIGHT;
1146 sptr<IConsumerSurface> surface = IConsumerSurface::Create();
1147 CameraFormat photoFormat = CAMERA_FORMAT_JPEG;
1148 Size photoSize;
1149 photoSize.width = width;
1150 photoSize.height = height;
1151 Profile photoProfile = Profile(photoFormat, photoSize);
1152 sptr<IBufferProducer> surfaceProducer = surface->GetProducer();
1153 sptr<PhotoOutput> photo = cameraManager->CreatePhotoOutput(photoProfile, surfaceProducer);
1154 ASSERT_NE(photo, nullptr);
1155 photo->Release();
1156 }
1157
1158 /*
1159 * Feature: Framework
1160 * Function: Test create photo output with surface as null
1161 * SubFunction: NA
1162 * FunctionPoints: NA
1163 * EnvConditions: NA
1164 * CaseDescription: Test create photo output with surface as null
1165 */
1166 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_012, TestSize.Level0)
1167 {
1168 int32_t width = PHOTO_DEFAULT_WIDTH;
1169 int32_t height = PHOTO_DEFAULT_HEIGHT;
1170 CameraFormat photoFormat = CAMERA_FORMAT_JPEG;
1171 Size photoSize;
1172 photoSize.width = width;
1173 photoSize.height = height;
1174 Profile photoProfile = Profile(photoFormat, photoSize);
1175 sptr<IBufferProducer> surfaceProducer = nullptr;
1176 sptr<PhotoOutput> photo = cameraManager->CreatePhotoOutput(photoProfile, surfaceProducer);
1177 ASSERT_EQ(photo, nullptr);
1178 }
1179
1180 /*
1181 * Feature: Framework
1182 * Function: Test create video output
1183 * SubFunction: NA
1184 * FunctionPoints: NA
1185 * EnvConditions: NA
1186 * CaseDescription: Test create video output
1187 */
1188 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_015, TestSize.Level0)
1189 {
1190 int32_t width = VIDEO_DEFAULT_WIDTH;
1191 int32_t height = VIDEO_DEFAULT_HEIGHT;
1192 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
1193 CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
1194 Size videoSize;
1195 videoSize.width = width;
1196 videoSize.height = height;
1197 std::vector<int32_t> videoFramerates = {30, 30};
1198 VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates);
1199 sptr<VideoOutput> video = cameraManager->CreateVideoOutput(videoProfile, surface);
1200 ASSERT_NE(video, nullptr);
1201 video->Release();
1202 }
1203
1204 /*
1205 * Feature: Framework
1206 * Function: Test create video output with surface as null
1207 * SubFunction: NA
1208 * FunctionPoints: NA
1209 * EnvConditions: NA
1210 * CaseDescription: Test create video output with surface as null
1211 */
1212 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_016, TestSize.Level0)
1213 {
1214 int32_t width = VIDEO_DEFAULT_WIDTH;
1215 int32_t height = VIDEO_DEFAULT_HEIGHT;
1216 CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
1217 sptr<Surface> surface = nullptr;
1218 Size videoSize;
1219 videoSize.width = width;
1220 videoSize.height = height;
1221 std::vector<int32_t> videoFramerates = {30, 30};
1222 VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates);
1223 sptr<VideoOutput> video = cameraManager->CreateVideoOutput(videoProfile, surface);
1224 ASSERT_EQ(video, nullptr);
1225 }
1226
1227 /*
1228 * Feature: Framework
1229 * Function: Test manager callback
1230 * SubFunction: NA
1231 * FunctionPoints: NA
1232 * EnvConditions: NA
1233 * CaseDescription: Test manager callback
1234 */
1235 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_019, TestSize.Level0)
1236 {
1237 std::shared_ptr<TestCameraMngerCallback> setCallback = std::make_shared<TestCameraMngerCallback>("MgrCallback");
1238 cameraManager->SetCallback(setCallback);
1239 std::shared_ptr<CameraManagerCallback> getCallback = cameraManager->GetApplicationCallback();
1240 ASSERT_EQ(setCallback, getCallback);
1241 }
1242
1243 /*
1244 * Feature: Framework
1245 * Function: Test set camera parameters
1246 * SubFunction: NA
1247 * FunctionPoints: NA
1248 * EnvConditions: NA
1249 * CaseDescription: Test set camera parameters zoom, focus, flash & exposure
1250 */
1251 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_020, TestSize.Level0)
1252 {
1253 InSequence s;
1254 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1255
1256 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1257 ASSERT_NE(input, nullptr);
1258
1259 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
1260 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1261 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1262 std::string cameraSettings = camInput->GetCameraSettings();
1263 camInput->SetCameraSettings(cameraSettings);
1264 camInput->GetCameraDevice()->Open();
1265
1266 sptr<CaptureOutput> photo = CreatePhotoOutput();
1267 ASSERT_NE(photo, nullptr);
1268
1269 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1270 ASSERT_NE(session, nullptr);
1271
1272 int32_t ret = session->BeginConfig();
1273 EXPECT_EQ(ret, 0);
1274 ret = session->AddInput(input);
1275 EXPECT_EQ(ret, 0);
1276
1277 ret = session->AddOutput(photo);
1278 EXPECT_EQ(ret, 0);
1279
1280 ret = session->CommitConfig();
1281 EXPECT_EQ(ret, 0);
1282
1283 SessionControlParams(session);
1284
1285 session->RemoveOutput(photo);
1286 session->RemoveInput(input);
1287 photo->Release();
1288 input->Release();
1289 EXPECT_EQ(session->Release(), 0);
1290 }
1291
1292 /*
1293 * Feature: Framework
1294 * Function: Test input callback
1295 * SubFunction: NA
1296 * FunctionPoints: NA
1297 * EnvConditions: NA
1298 * CaseDescription: Test input callback
1299 */
1300 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_021, TestSize.Level0)
1301 {
1302 InSequence s;
1303 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1304
1305 sptr<CameraInput> input = cameraManager->CreateCameraInput(cameras[0]);
1306 ASSERT_NE(input, nullptr);
1307
1308 std::shared_ptr<TestDeviceCallback> setCallback = std::make_shared<TestDeviceCallback>("InputCallback");
1309 input->SetErrorCallback(setCallback);
1310 std::shared_ptr<ErrorCallback> getCallback = input->GetErrorCallback();
1311 ASSERT_EQ(setCallback, getCallback);
1312 }
1313
1314 /*
1315 * Feature: Framework
1316 * Function: Test preview callback
1317 * SubFunction: NA
1318 * FunctionPoints: NA
1319 * EnvConditions: NA
1320 * CaseDescription: Test preview callback
1321 */
1322 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_022, TestSize.Level0)
1323 {
1324 sptr<CaptureOutput> preview = CreatePreviewOutput();
1325 ASSERT_NE(preview, nullptr);
1326
1327 std::shared_ptr<PreviewStateCallback> setCallback =
1328 std::make_shared<TestPreviewOutputCallback>("PreviewStateCallback");
1329 ((sptr<PreviewOutput> &)preview)->SetCallback(setCallback);
1330 std::shared_ptr<PreviewStateCallback> getCallback = ((sptr<PreviewOutput> &)preview)->GetApplicationCallback();
1331 ASSERT_EQ(setCallback, getCallback);
1332 }
1333
1334 /*
1335 * Feature: Framework
1336 * Function: Test photo callback
1337 * SubFunction: NA
1338 * FunctionPoints: NA
1339 * EnvConditions: NA
1340 * CaseDescription: Test photo callback
1341 */
1342 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_023, TestSize.Level0)
1343 {
1344 sptr<CaptureOutput> photo = CreatePhotoOutput();
1345 ASSERT_NE(photo, nullptr);
1346
1347 std::shared_ptr<PhotoStateCallback> setCallback = std::make_shared<TestPhotoOutputCallback>("PhotoStateCallback");
1348 ((sptr<PhotoOutput> &)photo)->SetCallback(setCallback);
1349 std::shared_ptr<PhotoStateCallback> getCallback = ((sptr<PhotoOutput> &)photo)->GetApplicationCallback();
1350 ASSERT_EQ(setCallback, getCallback);
1351 }
1352
1353 /*
1354 * Feature: Framework
1355 * Function: Test video callback
1356 * SubFunction: NA
1357 * FunctionPoints: NA
1358 * EnvConditions: NA
1359 * CaseDescription: Test video callback
1360 */
1361 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_024, TestSize.Level0)
1362 {
1363 sptr<CaptureOutput> video = CreateVideoOutput();
1364 ASSERT_NE(video, nullptr);
1365
1366 std::shared_ptr<VideoStateCallback> setCallback = std::make_shared<TestVideoOutputCallback>("VideoStateCallback");
1367 ((sptr<VideoOutput> &)video)->SetCallback(setCallback);
1368 std::shared_ptr<VideoStateCallback> getCallback = ((sptr<VideoOutput> &)video)->GetApplicationCallback();
1369 ASSERT_EQ(setCallback, getCallback);
1370 }
1371
1372 /*
1373 * Feature: Framework
1374 * Function: Test capture session add input with invalid value
1375 * SubFunction: NA
1376 * FunctionPoints: NA
1377 * EnvConditions: NA
1378 * CaseDescription: Test capture session add input with invalid value
1379 */
1380 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_025, TestSize.Level0)
1381 {
1382 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1383 ASSERT_NE(session, nullptr);
1384
1385 int32_t ret = session->BeginConfig();
1386 EXPECT_EQ(ret, 0);
1387
1388 sptr<CaptureInput> input = nullptr;
1389 ret = session->AddInput(input);
1390 EXPECT_NE(ret, 0);
1391 EXPECT_EQ(session->Release(), 0);
1392 }
1393
1394 /*
1395 * Feature: Framework
1396 * Function: Test capture session add output with invalid value
1397 * SubFunction: NA
1398 * FunctionPoints: NA
1399 * EnvConditions: NA
1400 * CaseDescription: Test capture session add output with invalid value
1401 */
1402 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_026, TestSize.Level0)
1403 {
1404 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1405 ASSERT_NE(session, nullptr);
1406
1407 int32_t ret = session->BeginConfig();
1408 EXPECT_EQ(ret, 0);
1409
1410 sptr<CaptureOutput> preview = nullptr;
1411 ret = session->AddOutput(preview);
1412 EXPECT_NE(ret, 0);
1413 EXPECT_EQ(session->Release(), 0);
1414 }
1415
1416 /*
1417 * Feature: Framework
1418 * Function: Test capture session commit config without adding input
1419 * SubFunction: NA
1420 * FunctionPoints: NA
1421 * EnvConditions: NA
1422 * CaseDescription: Test capture session commit config without adding input
1423 */
1424 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_027, TestSize.Level0)
1425 {
1426 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1427 ASSERT_NE(session, nullptr);
1428
1429 int32_t ret = session->BeginConfig();
1430 EXPECT_EQ(ret, 0);
1431
1432 sptr<CaptureOutput> preview = CreatePreviewOutput();
1433 ASSERT_NE(preview, nullptr);
1434
1435 ret = session->AddOutput(preview);
1436 EXPECT_EQ(ret, 7400201);
1437
1438 ret = session->CommitConfig();
1439 EXPECT_NE(ret, 0);
1440 session->RemoveOutput(preview);
1441 preview->Release();
1442 EXPECT_EQ(session->Release(), 0);
1443 }
1444
1445 /*
1446 * Feature: Framework
1447 * Function: Test capture session commit config without adding output
1448 * SubFunction: NA
1449 * FunctionPoints: NA
1450 * EnvConditions: NA
1451 * CaseDescription: Test capture session commit config without adding output
1452 */
1453 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_028, TestSize.Level0)
1454 {
1455 InSequence s;
1456 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1457
1458 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1459 ASSERT_NE(input, nullptr);
1460
1461 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
1462 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1463 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1464 std::string cameraSettings = camInput->GetCameraSettings();
1465 camInput->SetCameraSettings(cameraSettings);
1466 camInput->GetCameraDevice()->Open();
1467
1468 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1469 ASSERT_NE(session, nullptr);
1470
1471 int32_t ret = session->BeginConfig();
1472 EXPECT_EQ(ret, 0);
1473
1474 ret = session->AddInput(input);
1475 EXPECT_EQ(ret, 0);
1476
1477 ret = session->CommitConfig();
1478 EXPECT_NE(ret, 0);
1479 session->RemoveInput(input);
1480 input->Release();
1481 EXPECT_EQ(session->Release(), 0);
1482 }
1483
1484 /*
1485 * Feature: Framework
1486 * Function: Test capture session without begin config
1487 * SubFunction: NA
1488 * FunctionPoints: NA
1489 * EnvConditions: NA
1490 * CaseDescription: Test capture session without begin config
1491 */
1492 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_029, TestSize.Level0)
1493 {
1494 InSequence s;
1495 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1496
1497 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1498 ASSERT_NE(input, nullptr);
1499
1500 sptr<CaptureOutput> photo = CreatePhotoOutput();
1501 ASSERT_NE(photo, nullptr);
1502
1503 sptr<CaptureOutput> preview = CreatePreviewOutput();
1504 ASSERT_NE(preview, nullptr);
1505
1506 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1507 ASSERT_NE(session, nullptr);
1508
1509 int32_t ret = session->AddInput(input);
1510 EXPECT_NE(ret, 0);
1511
1512 ret = session->AddOutput(preview);
1513 EXPECT_NE(ret, 0);
1514
1515 ret = session->AddOutput(photo);
1516 EXPECT_NE(ret, 0);
1517
1518 ret = session->CommitConfig();
1519 EXPECT_NE(ret, 0);
1520
1521 ret = session->Start();
1522 EXPECT_NE(ret, 0);
1523
1524 ret = ((sptr<PreviewOutput> &)preview)->Start();
1525 EXPECT_NE(ret, 0);
1526
1527 ret = ((sptr<PhotoOutput> &)photo)->Capture();
1528 EXPECT_NE(ret, 0);
1529
1530 ret = ((sptr<PreviewOutput> &)preview)->Stop();
1531 EXPECT_NE(ret, 0);
1532
1533 ret = session->Stop();
1534 EXPECT_NE(ret, 0);
1535 session->RemoveInput(input);
1536 session->RemoveOutput(preview);
1537 session->RemoveOutput(photo);
1538 preview->Release();
1539 photo->Release();
1540 input->Release();
1541 session->Release();
1542 }
1543
1544 /*
1545 * Feature: Framework
1546 * Function: Test capture session start and stop without adding preview output
1547 * SubFunction: NA
1548 * FunctionPoints: NA
1549 * EnvConditions: NA
1550 * CaseDescription: Test capture session start and stop without adding preview output
1551 */
1552 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_030, TestSize.Level0)
1553 {
1554 InSequence s;
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 ret = session->AddInput(input);
1577 EXPECT_EQ(ret, 0);
1578
1579 ret = session->AddOutput(photo);
1580 EXPECT_EQ(ret, 0);
1581
1582 ret = session->CommitConfig();
1583 EXPECT_EQ(ret, 0);
1584
1585 EXPECT_CALL(*mockStreamOperator, Capture(_, _, true)).Times(0);
1586 ret = session->Start();
1587 EXPECT_EQ(ret, 0);
1588
1589 EXPECT_CALL(*mockStreamOperator, CancelCapture(_)).Times(0);
1590
1591 ret = session->Stop();
1592 EXPECT_EQ(ret, 0);
1593
1594 session->Release();
1595 input->Release();
1596 }
1597
1598 /*
1599 * Feature: Framework
1600 * Function: Test session with preview + photo
1601 * SubFunction: NA
1602 * FunctionPoints: NA
1603 * EnvConditions: NA
1604 * CaseDescription: Test session with preview + photo
1605 */
1606 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_031, TestSize.Level0)
1607 {
1608 InSequence s;
1609 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1610
1611 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1612 ASSERT_NE(input, nullptr);
1613
1614 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
1615 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1616 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1617 std::string cameraSettings = camInput->GetCameraSettings();
1618 camInput->SetCameraSettings(cameraSettings);
1619 camInput->GetCameraDevice()->Open();
1620
1621 sptr<CaptureOutput> preview = CreatePreviewOutput();
1622 ASSERT_NE(preview, nullptr);
1623
1624 sptr<CaptureOutput> photo = CreatePhotoOutput();
1625 ASSERT_NE(photo, nullptr);
1626
1627 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1628 ASSERT_NE(session, nullptr);
1629
1630 int32_t ret = session->BeginConfig();
1631 EXPECT_EQ(ret, 0);
1632
1633 ret = session->AddInput(input);
1634 EXPECT_EQ(ret, 0);
1635
1636 ret = session->AddOutput(preview);
1637 EXPECT_EQ(ret, 0);
1638
1639 ret = session->AddOutput(photo);
1640 EXPECT_EQ(ret, 0);
1641
1642 ret = session->CommitConfig();
1643 EXPECT_EQ(ret, 0);
1644
1645 EXPECT_CALL(*mockStreamOperator, Capture(1, _, true));
1646 ret = session->Start();
1647 EXPECT_EQ(ret, 0);
1648
1649 EXPECT_CALL(*mockStreamOperator, Capture(2, _, false));
1650 ret = ((sptr<PhotoOutput> &)photo)->Capture();
1651 EXPECT_EQ(ret, 0);
1652
1653 EXPECT_CALL(*mockStreamOperator, CancelCapture(1));
1654 ret = ((sptr<PreviewOutput> &)preview)->Stop();
1655 EXPECT_EQ(ret, 0);
1656
1657 session->Release();
1658 input->Release();
1659 }
1660
1661 /*
1662 * Feature: Framework
1663 * Function: Test session with preview + photo with camera configuration
1664 * SubFunction: NA
1665 * FunctionPoints: NA
1666 * EnvConditions: NA
1667 * CaseDescription: Test session with preview + photo with camera configuration
1668 */
1669 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_032, TestSize.Level0)
1670 {
1671 InSequence s;
1672 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1673
1674 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1675 ASSERT_NE(input, nullptr);
1676
1677 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
1678 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1679 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1680 std::string cameraSettings = camInput->GetCameraSettings();
1681 camInput->SetCameraSettings(cameraSettings);
1682 camInput->GetCameraDevice()->Open();
1683
1684 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1685 ASSERT_NE(session, nullptr);
1686
1687 std::vector<float> zoomRatioRange = session->GetZoomRatioRange();
1688 if (!zoomRatioRange.empty()) {
1689 session->LockForControl();
1690 session->SetZoomRatio(zoomRatioRange[0]);
1691 session->UnlockForControl();
1692 }
1693
1694 sptr<CaptureOutput> preview = CreatePreviewOutput();
1695 ASSERT_NE(preview, nullptr);
1696
1697 sptr<CaptureOutput> photo = CreatePhotoOutput();
1698 ASSERT_NE(photo, nullptr);
1699
1700 int32_t ret = session->BeginConfig();
1701 EXPECT_EQ(ret, 0);
1702
1703 ret = session->AddInput(input);
1704 EXPECT_EQ(ret, 0);
1705
1706 ret = session->AddOutput(preview);
1707 EXPECT_EQ(ret, 0);
1708
1709 ret = session->AddOutput(photo);
1710 EXPECT_EQ(ret, 0);
1711
1712 if (!zoomRatioRange.empty()) {
1713 EXPECT_CALL(*mockCameraDevice, UpdateSettings(_));
1714 }
1715 ret = session->CommitConfig();
1716 EXPECT_EQ(ret, 0);
1717
1718 session->Release();
1719 input->Release();
1720 }
1721
1722 /*
1723 * Feature: Framework
1724 * Function: Test session with preview + video
1725 * SubFunction: NA
1726 * FunctionPoints: NA
1727 * EnvConditions: NA
1728 * CaseDescription: Test session with preview + video
1729 */
1730 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_033, TestSize.Level0)
1731 {
1732 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1733
1734 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1735 ASSERT_NE(input, nullptr);
1736
1737 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
1738 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1739 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1740 std::string cameraSettings = camInput->GetCameraSettings();
1741 camInput->SetCameraSettings(cameraSettings);
1742 camInput->GetCameraDevice()->Open();
1743
1744 sptr<CaptureOutput> preview = CreatePreviewOutput();
1745 ASSERT_NE(preview, nullptr);
1746
1747 sptr<CaptureOutput> video = CreateVideoOutput();
1748 ASSERT_NE(video, nullptr);
1749
1750 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1751 ASSERT_NE(session, nullptr);
1752
1753 int32_t ret = session->BeginConfig();
1754 EXPECT_EQ(ret, 0);
1755
1756 ret = session->AddInput(input);
1757 EXPECT_EQ(ret, 0);
1758
1759 ret = session->AddOutput(preview);
1760 EXPECT_EQ(ret, 0);
1761
1762 ret = session->AddOutput(video);
1763 EXPECT_EQ(ret, 0);
1764
1765 SessionCommit(session);
1766
1767 EXPECT_CALL(*mockStreamOperator, Capture(4, _, true));
1768 ret = ((sptr<VideoOutput> &)video)->Start();
1769 EXPECT_EQ(ret, 0);
1770
1771 EXPECT_CALL(*mockStreamOperator, CancelCapture(4));
1772 ret = ((sptr<VideoOutput> &)video)->Stop();
1773 EXPECT_EQ(ret, 0);
1774
1775 EXPECT_CALL(*mockStreamOperator, CancelCapture(3));
1776 ret = ((sptr<PreviewOutput> &)preview)->Stop();
1777 EXPECT_EQ(ret, 0);
1778
1779 ((sptr<VideoOutput> &)video)->Release();
1780 session->Release();
1781 input->Release();
1782 }
1783
1784 /*
1785 * Feature: Framework
1786 * Function: Test capture session remove output with null
1787 * SubFunction: NA
1788 * FunctionPoints: NA
1789 * EnvConditions: NA
1790 * CaseDescription: Test capture session remove output with null
1791 */
1792 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_034, TestSize.Level0)
1793 {
1794 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1795 ASSERT_NE(session, nullptr);
1796
1797 int32_t ret = session->BeginConfig();
1798 EXPECT_EQ(ret, 0);
1799
1800 sptr<CaptureOutput> output = nullptr;
1801 ret = session->RemoveOutput(output);
1802 EXPECT_NE(ret, 0);
1803 session->Release();
1804 }
1805
1806 /*
1807 * Feature: Framework
1808 * Function: Test capture session remove output
1809 * SubFunction: NA
1810 * FunctionPoints: NA
1811 * EnvConditions: NA
1812 * CaseDescription: Test capture session remove output
1813 */
1814 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_035, TestSize.Level0)
1815 {
1816 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1817 ASSERT_NE(session, nullptr);
1818
1819 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1820
1821 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1822 ASSERT_NE(input, nullptr);
1823
1824 sptr<CaptureOutput> video = CreateVideoOutput();
1825 ASSERT_NE(video, nullptr);
1826
1827 int32_t ret = session->BeginConfig();
1828 EXPECT_EQ(ret, 0);
1829
1830 ret = session->AddInput(input);
1831 EXPECT_EQ(ret, 0);
1832
1833 ret = session->AddOutput(video);
1834 EXPECT_EQ(ret, 0);
1835
1836 ret = session->RemoveOutput(video);
1837 EXPECT_EQ(ret, 0);
1838 input->Release();
1839 video->Release();
1840 session->Release();
1841 }
1842
1843 /*
1844 * Feature: Framework
1845 * Function: Test capture session remove input with null
1846 * SubFunction: NA
1847 * FunctionPoints: NA
1848 * EnvConditions: NA
1849 * CaseDescription: Test capture session remove input with null
1850 */
1851 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_036, TestSize.Level0)
1852 {
1853 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1854 ASSERT_NE(session, nullptr);
1855
1856 int32_t ret = session->BeginConfig();
1857 EXPECT_EQ(ret, 0);
1858
1859 sptr<CaptureInput> input = nullptr;
1860 ret = session->RemoveInput(input);
1861 EXPECT_NE(ret, 0);
1862 session->Release();
1863 }
1864
1865 /*
1866 * Feature: Framework
1867 * Function: Test capture session remove input
1868 * SubFunction: NA
1869 * FunctionPoints: NA
1870 * EnvConditions: NA
1871 * CaseDescription: Test capture session remove input
1872 */
1873 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_037, TestSize.Level0)
1874 {
1875 InSequence s;
1876 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1877
1878 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1879 ASSERT_NE(input, nullptr);
1880
1881 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
1882 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1883 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1884 std::string cameraSettings = camInput->GetCameraSettings();
1885 camInput->SetCameraSettings(cameraSettings);
1886 camInput->GetCameraDevice()->Open();
1887
1888 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1889 ASSERT_NE(session, nullptr);
1890
1891 int32_t ret = session->BeginConfig();
1892 EXPECT_EQ(ret, 0);
1893
1894 ret = session->AddInput(input);
1895 EXPECT_EQ(ret, 0);
1896
1897 ret = session->RemoveInput(input);
1898 EXPECT_EQ(ret, 0);
1899 input->Release();
1900 session->Release();
1901 }
1902
1903 /*
1904 * Feature: Framework
1905 * Function: Test photo capture with photo settings
1906 * SubFunction: NA
1907 * FunctionPoints: NA
1908 * EnvConditions: NA
1909 * CaseDescription: Test photo capture with photo settings
1910 */
1911 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_038, TestSize.Level0)
1912 {
1913 InSequence s;
1914 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1915
1916 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1917 ASSERT_NE(input, nullptr);
1918
1919 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
1920 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1921 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1922 std::string cameraSettings = camInput->GetCameraSettings();
1923 camInput->SetCameraSettings(cameraSettings);
1924 camInput->GetCameraDevice()->Open();
1925
1926 sptr<CaptureOutput> photo = CreatePhotoOutput();
1927 ASSERT_NE(photo, nullptr);
1928
1929 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1930 ASSERT_NE(session, nullptr);
1931
1932 int32_t ret = session->BeginConfig();
1933 EXPECT_EQ(ret, 0);
1934
1935 ret = session->AddInput(input);
1936 EXPECT_EQ(ret, 0);
1937
1938 ret = session->AddOutput(photo);
1939 EXPECT_EQ(ret, 0);
1940
1941 ret = session->CommitConfig();
1942 EXPECT_EQ(ret, 0);
1943
1944 std::shared_ptr<PhotoCaptureSetting> photoSetting = std::make_shared<PhotoCaptureSetting>();
1945 photoSetting->SetRotation(PhotoCaptureSetting::Rotation_90);
1946 photoSetting->SetQuality(PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM);
1947 EXPECT_EQ(photoSetting->GetRotation(), PhotoCaptureSetting::Rotation_90);
1948 EXPECT_EQ(photoSetting->GetQuality(), PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM);
1949
1950 EXPECT_CALL(*mockStreamOperator, Capture(_,
1951 matchCaptureSetting(photoSetting->GetCaptureMetadataSetting()), false));
1952 ret = ((sptr<PhotoOutput> &)photo)->Capture(photoSetting);
1953 EXPECT_EQ(ret, 0);
1954
1955 session->Release();
1956 input->Release();
1957 }
1958
1959 /*
1960 * Feature: Framework
1961 * Function: Test GetFocalLength
1962 * SubFunction: NA
1963 * FunctionPoints: NA
1964 * EnvConditions: NA
1965 * CaseDescription: Test GetFocalLength
1966 */
1967 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_040, TestSize.Level0)
1968 {
1969 InSequence s;
1970 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
1971
1972 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
1973 ASSERT_NE(input, nullptr);
1974
1975 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
1976 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
1977 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
1978 std::string cameraSettings = camInput->GetCameraSettings();
1979 camInput->SetCameraSettings(cameraSettings);
1980 camInput->GetCameraDevice()->Open();
1981
1982 sptr<CaptureOutput> photo = CreatePhotoOutput();
1983 ASSERT_NE(photo, nullptr);
1984
1985 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
1986 ASSERT_NE(session, nullptr);
1987
1988 int32_t ret = session->BeginConfig();
1989 EXPECT_EQ(ret, 0);
1990
1991 ret = session->AddInput(input);
1992 EXPECT_EQ(ret, 0);
1993
1994 ret = session->AddOutput(photo);
1995 EXPECT_EQ(ret, 0);
1996
1997 ret = session->CommitConfig();
1998 EXPECT_EQ(ret, 0);
1999
2000 double focalLength = session->GetFocalLength();
2001 ASSERT_EQ(focalLength, 1.5);
2002
2003 session->RemoveInput(input);
2004 session->RemoveOutput(photo);
2005 photo->Release();
2006 input->Release();
2007 session->Release();
2008 }
2009
2010
2011 /*
2012 * Feature: Framework
2013 * Function: Test SetMeteringPoint & GetMeteringPoint
2014 * SubFunction: NA
2015 * FunctionPoints: NA
2016 * EnvConditions: NA
2017 * CaseDescription: Test SetMeteringPoint & GetMeteringPoint
2018 */
2019 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_041, TestSize.Level0)
2020 {
2021 InSequence s;
2022 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2023
2024 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2025 ASSERT_NE(input, nullptr);
2026
2027 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2028 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2029 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2030 std::string cameraSettings = camInput->GetCameraSettings();
2031 camInput->SetCameraSettings(cameraSettings);
2032 camInput->GetCameraDevice()->Open();
2033
2034 sptr<CaptureOutput> photo = CreatePhotoOutput();
2035 ASSERT_NE(photo, nullptr);
2036
2037 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
2038 ASSERT_NE(session, nullptr);
2039
2040 int32_t ret = session->BeginConfig();
2041 EXPECT_EQ(ret, 0);
2042
2043 ret = session->AddInput(input);
2044 EXPECT_EQ(ret, 0);
2045
2046 ret = session->AddOutput(photo);
2047 EXPECT_EQ(ret, 0);
2048
2049 ret = session->CommitConfig();
2050 EXPECT_EQ(ret, 0);
2051
2052 Point exposurePoint = {1.0, 2.0};
2053 session->LockForControl();
2054 session->SetMeteringPoint(exposurePoint);
2055 session->UnlockForControl();
2056 ASSERT_EQ((session->GetMeteringPoint().x), exposurePoint.x > 1 ? 1 : exposurePoint.x);
2057 ASSERT_EQ((session->GetMeteringPoint().y), exposurePoint.y > 1 ? 1 : exposurePoint.y);
2058
2059 session->RemoveInput(input);
2060 session->RemoveOutput(photo);
2061 photo->Release();
2062 input->Release();
2063 session->Release();
2064 }
2065
2066
2067 /*
2068 * Feature: Framework
2069 * Function: Test SetFocusPoint & GetFousPoint
2070 * SubFunction: NA
2071 * FunctionPoints: NA
2072 * EnvConditions: NA
2073 * CaseDescription: Test SetFocusPoint & GetFousPoint
2074 */
2075 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_042, TestSize.Level0)
2076 {
2077 InSequence s;
2078 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2079
2080 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2081 ASSERT_NE(input, nullptr);
2082
2083 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2084 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2085 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2086 std::string cameraSettings = camInput->GetCameraSettings();
2087 camInput->SetCameraSettings(cameraSettings);
2088 camInput->GetCameraDevice()->Open();
2089
2090 sptr<CaptureOutput> photo = CreatePhotoOutput();
2091 ASSERT_NE(photo, nullptr);
2092
2093 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
2094 ASSERT_NE(session, nullptr);
2095
2096 int32_t ret = session->BeginConfig();
2097 EXPECT_EQ(ret, 0);
2098
2099 ret = session->AddInput(input);
2100 EXPECT_EQ(ret, 0);
2101
2102 ret = session->AddOutput(photo);
2103 EXPECT_EQ(ret, 0);
2104
2105 ret = session->CommitConfig();
2106 EXPECT_EQ(ret, 0);
2107
2108 Point FocusPoint = {1.0, 2.0};
2109 session->LockForControl();
2110 session->SetFocusPoint(FocusPoint);
2111 session->UnlockForControl();
2112 ASSERT_EQ((session->GetFocusPoint().x), FocusPoint.x > 1 ? 1 : FocusPoint.x);
2113 ASSERT_EQ((session->GetFocusPoint().y), FocusPoint.y > 1 ? 1 : FocusPoint.y);
2114
2115 session->RemoveInput(input);
2116 session->RemoveOutput(photo);
2117 photo->Release();
2118 input->Release();
2119 session->Release();
2120 }
2121
2122 /*
2123 * Feature: Framework
2124 * Function: Test GetExposureValue and SetExposureBias
2125 * SubFunction: NA
2126 * FunctionPoints: NA
2127 * EnvConditions: NA
2128 * CaseDescription: Test GetExposureValue and SetExposureBias with value less then the range
2129 */
2130 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_043, TestSize.Level0)
2131 {
2132 InSequence s;
2133 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2134
2135 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2136 ASSERT_NE(input, nullptr);
2137
2138 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2139 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2140 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2141 std::string cameraSettings = camInput->GetCameraSettings();
2142 camInput->SetCameraSettings(cameraSettings);
2143 camInput->GetCameraDevice()->Open();
2144
2145 sptr<CaptureOutput> photo = CreatePhotoOutput();
2146 ASSERT_NE(photo, nullptr);
2147
2148 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
2149 ASSERT_NE(session, nullptr);
2150
2151 int32_t ret = session->BeginConfig();
2152 EXPECT_EQ(ret, 0);
2153
2154 ret = session->AddInput(input);
2155 EXPECT_EQ(ret, 0);
2156
2157 ret = session->AddOutput(photo);
2158 EXPECT_EQ(ret, 0);
2159
2160 ret = session->CommitConfig();
2161 EXPECT_EQ(ret, 0);
2162
2163 std::vector<float> exposurebiasRange = session->GetExposureBiasRange();
2164 if (!exposurebiasRange.empty()) {
2165 session->LockForControl();
2166 session->SetExposureBias(exposurebiasRange[0]-1.0);
2167 session->UnlockForControl();
2168 ASSERT_EQ(session->GetExposureValue(), exposurebiasRange[0]);
2169 }
2170
2171 session->RemoveInput(input);
2172 session->RemoveOutput(photo);
2173 photo->Release();
2174 input->Release();
2175 session->Release();
2176 }
2177
2178 /*
2179 * Feature: Framework
2180 * Function: Test GetExposureValue and SetExposureBias
2181 * SubFunction: NA
2182 * FunctionPoints: NA
2183 * EnvConditions: NA
2184 * CaseDescription: Test GetExposureValue and SetExposureBias with value between the range
2185 */
2186 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_044, TestSize.Level0)
2187 {
2188 InSequence s;
2189 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2190
2191 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2192 ASSERT_NE(input, nullptr);
2193
2194 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2195 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2196 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2197 std::string cameraSettings = camInput->GetCameraSettings();
2198 camInput->SetCameraSettings(cameraSettings);
2199 camInput->GetCameraDevice()->Open();
2200
2201 sptr<CaptureOutput> photo = CreatePhotoOutput();
2202 ASSERT_NE(photo, nullptr);
2203
2204 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
2205 ASSERT_NE(session, nullptr);
2206
2207 int32_t ret = session->BeginConfig();
2208 EXPECT_EQ(ret, 0);
2209
2210 ret = session->AddInput(input);
2211 EXPECT_EQ(ret, 0);
2212
2213 ret = session->AddOutput(photo);
2214 EXPECT_EQ(ret, 0);
2215
2216 ret = session->CommitConfig();
2217 EXPECT_EQ(ret, 0);
2218
2219 std::vector<float> exposurebiasRange = session->GetExposureBiasRange();
2220 if (!exposurebiasRange.empty()) {
2221 session->LockForControl();
2222 session->SetExposureBias(exposurebiasRange[0]+1.0);
2223 session->UnlockForControl();
2224 EXPECT_TRUE((session->GetExposureValue()>=exposurebiasRange[0] &&
2225 session->GetExposureValue()<=exposurebiasRange[1]));
2226 }
2227 session->RemoveInput(input);
2228 session->RemoveOutput(photo);
2229 photo->Release();
2230 input->Release();
2231 session->Release();
2232 }
2233
2234
2235 /*
2236 * Feature: Framework
2237 * Function: Test GetExposureValue and SetExposureBias
2238 * SubFunction: NA
2239 * FunctionPoints: NA
2240 * EnvConditions: NA
2241 * CaseDescription: Test GetExposureValue and SetExposureBias with value more then the range
2242 */
2243 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_045, TestSize.Level0)
2244 {
2245 InSequence s;
2246 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2247
2248 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2249 ASSERT_NE(input, nullptr);
2250
2251 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2252 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2253 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2254 std::string cameraSettings = camInput->GetCameraSettings();
2255 camInput->SetCameraSettings(cameraSettings);
2256 camInput->GetCameraDevice()->Open();
2257
2258 sptr<CaptureOutput> photo = CreatePhotoOutput();
2259 ASSERT_NE(photo, nullptr);
2260 SceneMode mode = CAPTURE;
2261 sptr<CaptureSession> session = cameraManager->CreateCaptureSession(mode);
2262 ASSERT_NE(session, nullptr);
2263
2264 int32_t ret = session->BeginConfig();
2265 EXPECT_EQ(ret, 0);
2266
2267 ret = session->AddInput(input);
2268 EXPECT_EQ(ret, 0);
2269
2270 ret = session->AddOutput(photo);
2271 EXPECT_EQ(ret, 0);
2272
2273 ret = session->CommitConfig();
2274 EXPECT_EQ(ret, 0);
2275
2276 std::vector<float> exposurebiasRange = session->GetExposureBiasRange();
2277 if (!exposurebiasRange.empty()) {
2278 session->LockForControl();
2279 session->SetExposureBias(exposurebiasRange[1]+1.0);
2280 session->UnlockForControl();
2281 }
2282 ASSERT_EQ(session->GetExposureValue(), exposurebiasRange[1]);
2283 session->Release();
2284 }
2285
2286 /*
2287 * Feature: Framework
2288 * Function: Test cameraManager and portrait session with beauty/filter/portrait effects
2289 * SubFunction: NA
2290 * FunctionPoints: NA
2291 * EnvConditions: NA
2292 * CaseDescription: Test cameraManager and portrait session with beauty/filter/portrait effects
2293 */
2294 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_046, TestSize.Level0)
2295 {
2296 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2297
2298 SceneMode mode = PORTRAIT;
2299 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
2300 ASSERT_TRUE(modes.size() != 0);
2301
2302 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
2303 ASSERT_NE(ability, nullptr);
2304
2305 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2306 ASSERT_NE(input, nullptr);
2307
2308 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2309 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2310 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2311 std::string cameraSettings = camInput->GetCameraSettings();
2312 camInput->SetCameraSettings(cameraSettings);
2313 camInput->GetCameraDevice()->Open();
2314 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(mode);
2315 ASSERT_NE(captureSession, nullptr);
2316 sptr<PortraitSession> portraitSession = nullptr;
2317 portraitSession = static_cast<PortraitSession *> (captureSession.GetRefPtr());
2318 ASSERT_NE(portraitSession, nullptr);
2319
2320 sptr<CaptureOutput> preview = CreatePreviewOutput();
2321 ASSERT_NE(preview, nullptr);
2322
2323 sptr<CaptureOutput> photo = CreatePhotoOutput();
2324 ASSERT_NE(photo, nullptr);
2325
2326 int32_t ret = portraitSession->BeginConfig();
2327 EXPECT_EQ(ret, 0);
2328
2329 ret = portraitSession->AddInput(input);
2330 EXPECT_EQ(ret, 0);
2331
2332 ret = portraitSession->AddOutput(preview);
2333 EXPECT_EQ(ret, 0);
2334
2335 ret = portraitSession->AddOutput(photo);
2336 EXPECT_EQ(ret, 0);
2337
2338 ret = portraitSession->CommitConfig();
2339 EXPECT_EQ(ret, 0);
2340
2341 PortraitSessionControlParams(portraitSession);
2342
2343 portraitSession->Release();
2344 }
2345
2346 /*
2347 * Feature: Framework
2348 * Function: Test cameraManager with GetSupportedModes
2349 * SubFunction: NA
2350 * FunctionPoints: NA
2351 * EnvConditions: NA
2352 * CaseDescription: Test GetSupportedModes to get modes
2353 */
2354 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_047, TestSize.Level0)
2355 {
2356 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2357
2358 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
2359 ASSERT_TRUE(modes.size() != 0);
2360 }
2361
2362 /*
2363 * Feature: Framework
2364 * Function: Test cameraManager with GetSupportedOutputCapability
2365 * SubFunction: NA
2366 * FunctionPoints: NA
2367 * EnvConditions: NA
2368 * CaseDescription: Test GetSupportedOutputCapability to get capability
2369 */
2370 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_048, TestSize.Level0)
2371 {
2372 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2373
2374 SceneMode mode = PORTRAIT;
2375 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
2376 ASSERT_TRUE(modes.size() != 0);
2377
2378 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
2379 ASSERT_NE(ability, nullptr);
2380 }
2381
2382 /*
2383 * Feature: Framework
2384 * Function: Test cameraManager with CreateCaptureSession and CommitConfig
2385 * SubFunction: NA
2386 * FunctionPoints: NA
2387 * EnvConditions: NA
2388 * CaseDescription: Test cameraManager to CreateCaptureSession
2389 */
2390 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_049, TestSize.Level0)
2391 {
2392 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2393
2394 SceneMode mode = PORTRAIT;
2395 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
2396 ASSERT_TRUE(modes.size() != 0);
2397
2398 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
2399 ASSERT_NE(ability, nullptr);
2400
2401 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2402 ASSERT_NE(input, nullptr);
2403
2404 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2405 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2406 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2407 std::string cameraSettings = camInput->GetCameraSettings();
2408 camInput->SetCameraSettings(cameraSettings);
2409 camInput->GetCameraDevice()->Open();
2410
2411 sptr<CaptureOutput> preview = CreatePreviewOutput();
2412 ASSERT_NE(preview, nullptr);
2413
2414 sptr<CaptureOutput> photo = CreatePhotoOutput();
2415 ASSERT_NE(photo, nullptr);
2416
2417
2418 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(mode);
2419 ASSERT_NE(captureSession, nullptr);
2420 sptr<PortraitSession> portraitSession = nullptr;
2421 portraitSession = static_cast<PortraitSession *> (captureSession.GetRefPtr());
2422 ASSERT_NE(portraitSession, nullptr);
2423
2424
2425 int32_t ret = portraitSession->BeginConfig();
2426 EXPECT_EQ(ret, 0);
2427
2428 ret = portraitSession->AddInput(input);
2429 EXPECT_EQ(ret, 0);
2430
2431 ret = portraitSession->AddOutput(preview);
2432 EXPECT_EQ(ret, 0);
2433
2434 ret = portraitSession->AddOutput(photo);
2435 EXPECT_EQ(ret, 0);
2436
2437 ret = portraitSession->CommitConfig();
2438 EXPECT_EQ(ret, 0);
2439 portraitSession->Release();
2440 }
2441
2442 /*
2443 * Feature: Framework
2444 * Function: Test GetSupportedPortraitEffects / GetPortraitEffect / SetPortraitEffect
2445 * SubFunction: NA
2446 * FunctionPoints: NA
2447 * EnvConditions: NA
2448 * CaseDescription: Test GetPortraitEffect and SetPortraitEffect with value
2449 */
2450 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_050, TestSize.Level0)
2451 {
2452 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2453 SceneMode mode = PORTRAIT;
2454 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
2455 ASSERT_TRUE(modes.size() != 0);
2456
2457 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
2458 ASSERT_NE(ability, nullptr);
2459
2460 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2461 ASSERT_NE(input, nullptr);
2462
2463 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2464 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2465 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2466 std::string cameraSettings = camInput->GetCameraSettings();
2467 camInput->SetCameraSettings(cameraSettings);
2468 camInput->GetCameraDevice()->Open();
2469
2470
2471 sptr<CaptureOutput> preview = CreatePreviewOutput();
2472 ASSERT_NE(preview, nullptr);
2473
2474 sptr<CaptureOutput> photo = CreatePhotoOutput();
2475 ASSERT_NE(photo, nullptr);
2476
2477 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(mode);
2478 ASSERT_NE(captureSession, nullptr);
2479 sptr<PortraitSession> portraitSession = nullptr;
2480 portraitSession = static_cast<PortraitSession *> (captureSession.GetRefPtr());
2481 ASSERT_NE(portraitSession, nullptr);
2482
2483 int32_t ret = portraitSession->BeginConfig();
2484 EXPECT_EQ(ret, 0);
2485
2486 ret = portraitSession->AddInput(input);
2487 EXPECT_EQ(ret, 0);
2488
2489 ret = portraitSession->AddOutput(preview);
2490 EXPECT_EQ(ret, 0);
2491
2492 ret = portraitSession->AddOutput(photo);
2493 EXPECT_EQ(ret, 0);
2494
2495 ret = portraitSession->CommitConfig();
2496 EXPECT_EQ(ret, 0);
2497
2498 PortraitSessionEffectParams(portraitSession);
2499
2500 portraitSession->Release();
2501 }
2502
2503 /*
2504 * Feature: Framework
2505 * Function: Test GetSupportedFilters / GetFilter / SetFilter
2506 * SubFunction: NA
2507 * FunctionPoints: NA
2508 * EnvConditions: NA
2509 * CaseDescription: Test GetFilter and SetFilter with value
2510 */
2511 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_051, TestSize.Level0)
2512 {
2513 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2514 SceneMode mode = PORTRAIT;
2515 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
2516 ASSERT_TRUE(modes.size() != 0);
2517
2518 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
2519 ASSERT_NE(ability, nullptr);
2520
2521 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2522 ASSERT_NE(input, nullptr);
2523
2524 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2525 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2526 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2527 std::string cameraSettings = camInput->GetCameraSettings();
2528 camInput->SetCameraSettings(cameraSettings);
2529 camInput->GetCameraDevice()->Open();
2530
2531 sptr<CaptureOutput> preview = CreatePreviewOutput();
2532 ASSERT_NE(preview, nullptr);
2533
2534 sptr<CaptureOutput> photo = CreatePhotoOutput();
2535 ASSERT_NE(photo, nullptr);
2536
2537 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(mode);
2538 ASSERT_NE(captureSession, nullptr);
2539 sptr<PortraitSession> portraitSession = nullptr;
2540 portraitSession = static_cast<PortraitSession *> (captureSession.GetRefPtr());
2541 ASSERT_NE(portraitSession, nullptr);
2542
2543 int32_t ret = portraitSession->BeginConfig();
2544 EXPECT_EQ(ret, 0);
2545
2546 ret = portraitSession->AddInput(input);
2547 EXPECT_EQ(ret, 0);
2548
2549 ret = portraitSession->AddOutput(preview);
2550 EXPECT_EQ(ret, 0);
2551
2552 ret = portraitSession->AddOutput(photo);
2553 EXPECT_EQ(ret, 0);
2554
2555 ret = portraitSession->CommitConfig();
2556 EXPECT_EQ(ret, 0);
2557
2558 PortraitSessionFilterParams(portraitSession);
2559
2560 portraitSession->Release();
2561 }
2562
2563 /*
2564 * Feature: Framework
2565 * Function: Test GetSupportedBeautyTypes / GetSupportedBeautyRange / GetBeauty / SetBeauty
2566 * SubFunction: NA
2567 * FunctionPoints: NA
2568 * EnvConditions: NA
2569 * CaseDescription: Test GetBeauty and SetBeauty with value
2570 */
2571 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_052, TestSize.Level0)
2572 {
2573 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2574 SceneMode mode = PORTRAIT;
2575 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
2576 ASSERT_TRUE(modes.size() != 0);
2577
2578 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
2579 ASSERT_NE(ability, nullptr);
2580
2581 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2582 ASSERT_NE(input, nullptr);
2583
2584 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2585 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2586 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2587 std::string cameraSettings = camInput->GetCameraSettings();
2588 camInput->SetCameraSettings(cameraSettings);
2589 camInput->GetCameraDevice()->Open();
2590
2591
2592 sptr<CaptureOutput> preview = CreatePreviewOutput();
2593 ASSERT_NE(preview, nullptr);
2594
2595 sptr<CaptureOutput> photo = CreatePhotoOutput();
2596 ASSERT_NE(photo, nullptr);
2597
2598 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(mode);
2599 ASSERT_NE(captureSession, nullptr);
2600 sptr<PortraitSession> portraitSession = nullptr;
2601 portraitSession = static_cast<PortraitSession *> (captureSession.GetRefPtr());
2602 ASSERT_NE(portraitSession, nullptr);
2603
2604 int32_t ret = portraitSession->BeginConfig();
2605 EXPECT_EQ(ret, 0);
2606
2607 ret = portraitSession->AddInput(input);
2608 EXPECT_EQ(ret, 0);
2609
2610 ret = portraitSession->AddOutput(preview);
2611 EXPECT_EQ(ret, 0);
2612
2613 ret = portraitSession->AddOutput(photo);
2614 EXPECT_EQ(ret, 0);
2615
2616 ret = portraitSession->CommitConfig();
2617 EXPECT_EQ(ret, 0);
2618
2619 PortraitSessionBeautyParams(portraitSession);
2620
2621 portraitSession->Release();
2622 }
2623
2624 /*
2625 * Feature: Framework
2626 * Function: Test anomalous branch
2627 * SubFunction: NA
2628 * FunctionPoints: NA
2629 * EnvConditions: NA
2630 * CaseDescription: Test HCameraDevice with anomalous branch
2631 */
2632 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_001, TestSize.Level0)
2633 {
2634 InSequence s;
2635 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2636
2637 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2638 ASSERT_NE(input, nullptr);
2639
2640 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2641 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2642 std::string cameraSettings = camInput->GetCameraSettings();
2643 camInput->SetCameraSettings(cameraSettings);
2644
2645 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
2646 std::string cameraId = cameras[0]->GetID();
2647 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
2648 sptr<HCameraDevice> camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken);
2649 ASSERT_NE(camDevice, nullptr);
2650
2651 int32_t ret = camDevice->HCameraDevice::Open();
2652 EXPECT_EQ(ret, 0);
2653
2654 std::vector<int32_t> result;
2655 result.push_back(OHOS_SENSOR_EXPOSURE_TIME);
2656
2657 ret = camDevice->HCameraDevice::EnableResult(result);
2658 EXPECT_EQ(ret, 0);
2659
2660 ret = camDevice->HCameraDevice::DisableResult(result);
2661 EXPECT_EQ(ret, 0);
2662
2663 sptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator = camDevice->HCameraDevice::GetStreamOperator();
2664 EXPECT_TRUE(streamOperator != nullptr);
2665
2666 ret = camDevice->HCameraDevice::OnError(REQUEST_TIMEOUT, 0);
2667 EXPECT_EQ(ret, 0);
2668
2669 ret = camDevice->HCameraDevice::Close();
2670 EXPECT_EQ(ret, 0);
2671 }
2672
2673 /*
2674 * Feature: Framework
2675 * Function: Test anomalous branch
2676 * SubFunction: NA
2677 * FunctionPoints: NA
2678 * EnvConditions: NA
2679 * CaseDescription: Test dump with args empty
2680 */
2681 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_002, TestSize.Level0)
2682 {
2683 InSequence s;
2684 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2685
2686 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2687 ASSERT_NE(input, nullptr);
2688
2689 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2690 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2691 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2692 std::string cameraSettings = camInput->GetCameraSettings();
2693 camInput->SetCameraSettings(cameraSettings);
2694 camInput->GetCameraDevice()->Open();
2695
2696 sptr<FakeHCameraService> mockHCameraService = new FakeHCameraService(mockCameraHostManager);
2697 sptr<HCameraService> camService = (sptr<HCameraService> &)mockHCameraService;
2698 ASSERT_NE(camService, nullptr);
2699
2700 std::vector<std::string> cameraIds = {};
2701 std::vector<std::shared_ptr<OHOS::Camera::CameraMetadata>> cameraAbilityList = {};
2702 int32_t ret = camService->GetCameras(cameraIds, cameraAbilityList);
2703
2704 int fd = 0;
2705 std::vector<std::u16string> args = {};
2706 ret = camService->Dump(fd, args);
2707 EXPECT_EQ(ret, 0);
2708
2709 input->Close();
2710 }
2711
2712 /*
2713 * Feature: Framework
2714 * Function: Test anomalous branch
2715 * SubFunction: NA
2716 * FunctionPoints: NA
2717 * EnvConditions: NA
2718 * CaseDescription: Test HCaptureSession with anomalous branch
2719 */
2720 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_003, TestSize.Level0)
2721 {
2722 InSequence s;
2723 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2724
2725 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2726 ASSERT_NE(input, nullptr);
2727
2728 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2729 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2730 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2731 std::string cameraSettings = camInput->GetCameraSettings();
2732 camInput->SetCameraSettings(cameraSettings);
2733 camInput->GetCameraDevice()->Open();
2734
2735 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
2736 sptr<StreamOperatorCallback> streamOperatorCb = nullptr;
2737 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
2738 SceneMode mode = PORTRAIT;
2739 sptr<HCaptureSession> camSession = new (std::nothrow) HCaptureSession(callerToken, mode);
2740 ASSERT_NE(camSession, nullptr);
2741
2742 sptr<ICameraDeviceService> cameraDevice = camInput->GetCameraDevice();
2743 int32_t ret = camSession->AddInput(cameraDevice);
2744 EXPECT_EQ(ret, 10);
2745
2746 ret = camSession->RemoveInput(cameraDevice);
2747 EXPECT_EQ(ret, 10);
2748
2749 ret = camSession->BeginConfig();
2750 EXPECT_EQ(ret, 0);
2751
2752 ret = camSession->BeginConfig();
2753 EXPECT_EQ(ret, 10);
2754
2755 cameraDevice = nullptr;
2756 ret = camSession->AddInput(cameraDevice);
2757 EXPECT_EQ(ret, 2);
2758
2759 ret = camSession->RemoveInput(cameraDevice);
2760 EXPECT_EQ(ret, 2);
2761
2762 sptr<IStreamCommon> stream_2 = nullptr;
2763 ret = camSession->AddOutput(StreamType::CAPTURE, stream_2);
2764 EXPECT_EQ(ret, 2);
2765
2766 ret = camSession->RemoveOutput(StreamType::CAPTURE, stream_2);
2767 EXPECT_EQ(ret, 2);
2768
2769 input->Close();
2770 camSession->Release();
2771 }
2772
2773 /*
2774 * Feature: Framework
2775 * Function: Test anomalous branch
2776 * SubFunction: NA
2777 * FunctionPoints: NA
2778 * EnvConditions: NA
2779 * CaseDescription: Test HCameraService with anomalous branch
2780 */
2781 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_004, TestSize.Level0)
2782 {
2783 InSequence s;
2784 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2785
2786 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2787 ASSERT_NE(input, nullptr);
2788
2789 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2790 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2791 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2792 std::string cameraSettings = camInput->GetCameraSettings();
2793 camInput->SetCameraSettings(cameraSettings);
2794 camInput->GetCameraDevice()->Open();
2795
2796 sptr<FakeHCameraService> mockHCameraService = new FakeHCameraService(mockCameraHostManager);
2797 sptr<HCameraService> cameraService = (sptr<HCameraService> &)mockHCameraService;
2798 ASSERT_NE(cameraService, nullptr);
2799
2800 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
2801 sptr<IBufferProducer> Producer = Surface->GetProducer();
2802
2803 int32_t height = 0;
2804 int32_t width = PHOTO_DEFAULT_WIDTH;
2805 sptr<IStreamRepeat> output = nullptr;
2806 int32_t intResult = cameraService->CreateDeferredPreviewOutput(0, width, height, output);
2807 EXPECT_EQ(intResult, 2);
2808
2809 width = 0;
2810 intResult = cameraService->CreateDeferredPreviewOutput(0, width, height, output);
2811 EXPECT_EQ(intResult, 2);
2812
2813 Producer = nullptr;
2814 intResult = cameraService->CreatePreviewOutput(Producer, 0, width, height, output);
2815 EXPECT_EQ(intResult, 2);
2816
2817 Producer = Surface->GetProducer();
2818 intResult = cameraService->CreatePreviewOutput(Producer, 0, width, height, output);
2819 EXPECT_EQ(intResult, 2);
2820
2821 width = PREVIEW_DEFAULT_WIDTH;
2822 intResult = cameraService->CreatePreviewOutput(Producer, 0, width, height, output);
2823 EXPECT_EQ(intResult, 2);
2824
2825 intResult = cameraService->CreateVideoOutput(Producer, 0, width, height, output);
2826 EXPECT_EQ(intResult, 2);
2827
2828 width = 0;
2829 intResult = cameraService->CreateVideoOutput(Producer, 0, width, height, output);
2830 EXPECT_EQ(intResult, 2);
2831
2832 Producer = nullptr;
2833 intResult = cameraService->CreateVideoOutput(Producer, 0, width, height, output);
2834 EXPECT_EQ(intResult, 2);
2835
2836 input->Close();
2837 }
2838
2839 /*
2840 * Feature: Framework
2841 * Function: Test anomalous branch
2842 * SubFunction: NA
2843 * FunctionPoints: NA
2844 * EnvConditions: NA
2845 * CaseDescription: Test HCameraService with anomalous branch
2846 */
2847 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_005, TestSize.Level0)
2848 {
2849 InSequence s;
2850 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2851
2852 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2853 ASSERT_NE(input, nullptr);
2854
2855 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2856 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2857 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2858 std::string cameraSettings = camInput->GetCameraSettings();
2859 camInput->SetCameraSettings(cameraSettings);
2860 camInput->GetCameraDevice()->Open();
2861
2862 sptr<FakeHCameraService> mockHCameraService = new FakeHCameraService(mockCameraHostManager);
2863 sptr<HCameraService> cameraService = (sptr<HCameraService> &)mockHCameraService;
2864 ASSERT_NE(cameraService, nullptr);
2865
2866 int32_t width = 0;
2867 int32_t height = 0;
2868
2869 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
2870 sptr<IBufferProducer> Producer = Surface->GetProducer();
2871
2872 sptr<IStreamCapture> output_1 = nullptr;
2873 int32_t intResult = cameraService->CreatePhotoOutput(Producer, 0, width, height, output_1);
2874 EXPECT_EQ(intResult, 2);
2875
2876 width = PHOTO_DEFAULT_WIDTH;
2877 intResult = cameraService->CreatePhotoOutput(Producer, 0, width, height, output_1);
2878 EXPECT_EQ(intResult, 2);
2879
2880 Producer = nullptr;
2881 intResult = cameraService->CreatePhotoOutput(Producer, 0, width, height, output_1);
2882 EXPECT_EQ(intResult, 2);
2883
2884 sptr<IStreamMetadata> output_2 = nullptr;
2885 intResult = cameraService->CreateMetadataOutput(Producer, 0, {1}, output_2);
2886 EXPECT_EQ(intResult, 2);
2887
2888 input->Close();
2889 }
2890
2891 /*
2892 * Feature: Framework
2893 * Function: Test anomalous branch
2894 * SubFunction: NA
2895 * FunctionPoints: NA
2896 * EnvConditions: NA
2897 * CaseDescription: Test HCameraService with anomalous branch
2898 */
2899 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_006, TestSize.Level0)
2900 {
2901 InSequence s;
2902 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2903
2904 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2905 ASSERT_NE(input, nullptr);
2906
2907 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2908 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2909 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2910 std::string cameraSettings = camInput->GetCameraSettings();
2911 camInput->SetCameraSettings(cameraSettings);
2912 camInput->GetCameraDevice()->Open();
2913
2914 sptr<FakeHCameraService> mockHCameraService = new FakeHCameraService(mockCameraHostManager);
2915 sptr<HCameraService> cameraService = (sptr<HCameraService> &)mockHCameraService;
2916 ASSERT_NE(cameraService, nullptr);
2917
2918 sptr<ICameraServiceCallback> callback = nullptr;
2919 int32_t intResult = cameraService->SetCameraCallback(callback);
2920 EXPECT_EQ(intResult, 2);
2921
2922 callback = new(std::nothrow) CameraStatusServiceCallback(cameraManager);
2923 ASSERT_NE(callback, nullptr);
2924 intResult = cameraService->SetCameraCallback(callback);
2925 EXPECT_EQ(intResult, 0);
2926
2927 sptr<ICameraDeviceService> deviceObj = camInput->GetCameraDevice();
2928 ASSERT_NE(deviceObj, nullptr);
2929
2930 sptr<ICameraMuteServiceCallback> callback_2 = nullptr;
2931 intResult = cameraService->SetMuteCallback(callback_2);
2932 EXPECT_EQ(intResult, 2);
2933
2934 callback_2 = new(std::nothrow) CameraMuteServiceCallback(cameraManager);
2935 ASSERT_NE(callback_2, nullptr);
2936 intResult = cameraService->SetMuteCallback(callback_2);
2937 EXPECT_EQ(intResult, 0);
2938
2939 std::string cameraId = camInput->GetCameraId();
2940 int activeTime = 15;
2941 EffectParam effectParam = {0, 0, 0};
2942 intResult = cameraService->SetPrelaunchConfig(cameraId, RestoreParamTypeOhos::PERSISTENT_DEFAULT_PARAM_OHOS,
2943 activeTime, effectParam);
2944 EXPECT_EQ(intResult, 2);
2945
2946 cameraId = "";
2947 intResult = cameraService->SetPrelaunchConfig(cameraId, RestoreParamTypeOhos::TRANSIENT_ACTIVE_PARAM_OHOS,
2948 activeTime, effectParam);
2949 EXPECT_EQ(intResult, 2);
2950
2951 intResult = cameraService->SetPrelaunchConfig(cameraId, RestoreParamTypeOhos::PERSISTENT_DEFAULT_PARAM_OHOS,
2952 activeTime, effectParam);
2953 EXPECT_EQ(intResult, 2);
2954
2955 cameraId = "";
2956 intResult = cameraService->SetPrelaunchConfig(cameraId, RestoreParamTypeOhos::PERSISTENT_DEFAULT_PARAM_OHOS,
2957 activeTime, effectParam);
2958 EXPECT_EQ(intResult, 2);
2959
2960 input->Close();
2961 }
2962
2963 /*
2964 * Feature: Framework
2965 * Function: Test anomalous branch
2966 * SubFunction: NA
2967 * FunctionPoints: NA
2968 * EnvConditions: NA
2969 * CaseDescription: Test different status with OnReceive
2970 */
2971 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_007, TestSize.Level0)
2972 {
2973 InSequence s;
2974 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
2975
2976 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
2977 ASSERT_NE(input, nullptr);
2978
2979 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
2980 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
2981 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
2982 std::string cameraSettings = camInput->GetCameraSettings();
2983 camInput->SetCameraSettings(cameraSettings);
2984 camInput->GetCameraDevice()->Open();
2985
2986 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
2987 cameraHostManager->Init();
2988 HDI::ServiceManager::V1_0::ServiceStatus status;
2989
2990 status.serviceName = "1";
2991 cameraHostManager->GetRegisterServStatListener()->OnReceive(status);
2992
2993 status.deviceClass = DEVICE_CLASS_CAMERA;
2994 status.serviceName = "distributed_camera_service";
2995 status.status = HDI::ServiceManager::V1_0::SERVIE_STATUS_START;
2996 cameraHostManager->GetRegisterServStatListener()->OnReceive(status);
2997 cameraHostManager->GetRegisterServStatListener()->OnReceive(status);
2998
2999 status.status = HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP;
3000 cameraHostManager->GetRegisterServStatListener()->OnReceive(status);
3001
3002 status.status = 4;
3003 cameraHostManager->GetRegisterServStatListener()->OnReceive(status);
3004 cameraHostManager->DeInit();
3005 input->Close();
3006 }
3007
3008 /*
3009 * Feature: Framework
3010 * Function: Test anomalous branch
3011 * SubFunction: NA
3012 * FunctionPoints: NA
3013 * EnvConditions: NA
3014 * CaseDescription: Test CaptureSession with no static capability.
3015 */
3016 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_008, TestSize.Level0)
3017 {
3018 g_mockFlagWithoutAbt = true;
3019 sptr<CameraManager> camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager));
3020
3021 std::vector<sptr<CameraDevice>> cameras = camManager->GetSupportedCameras();
3022 sptr<CaptureInput> input = camManager->CreateCameraInput(cameras[0]);
3023 ASSERT_NE(input, nullptr);
3024
3025 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3026 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3027 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3028 std::string cameraSettings = camInput->GetCameraSettings();
3029 camInput->SetCameraSettings(cameraSettings);
3030 camInput->GetCameraDevice()->Open();
3031
3032 sptr<CaptureOutput> photo = CreatePhotoOutput();
3033 ASSERT_NE(photo, nullptr);
3034
3035 sptr<CaptureSession> session = camManager->CreateCaptureSession();
3036 ASSERT_NE(session, nullptr);
3037
3038 EXPECT_EQ(session->BeginConfig(), 0);
3039
3040 EXPECT_EQ(session->AddInput(input), 0);
3041 EXPECT_EQ(session->AddOutput(photo), 0);
3042
3043 EXPECT_EQ(session->CommitConfig(), 0);
3044
3045 sptr<CameraOutputCapability> cameraOutputCapability = camManager->GetSupportedOutputCapability(cameras[0]);
3046
3047 std::vector<VideoStabilizationMode> videoStabilizationMode = session->GetSupportedStabilizationMode();
3048 EXPECT_EQ(videoStabilizationMode.empty(), true);
3049
3050 int32_t intResult = session->GetSupportedStabilizationMode(videoStabilizationMode);
3051 EXPECT_EQ(intResult, 0);
3052
3053 std::vector<ExposureMode> getSupportedExpModes = session->GetSupportedExposureModes();
3054 EXPECT_EQ(getSupportedExpModes.empty(), true);
3055
3056 EXPECT_EQ(session->GetSupportedExposureModes(getSupportedExpModes), 0);
3057
3058 EXPECT_EQ(session->GetExposureMode(), -1);
3059 EXPECT_EQ((session->GetMeteringPoint().x), 0);
3060 EXPECT_EQ((session->GetMeteringPoint().y), 0);
3061
3062 float exposureValue = session->GetExposureValue();
3063 EXPECT_EQ(exposureValue, 0);
3064 int32_t exposureValueGet = session->GetExposureValue(exposureValue);
3065 EXPECT_EQ(exposureValueGet, 0);
3066
3067 input->Close();
3068 session->Release();
3069 }
3070
3071 /*
3072 * Feature: Framework
3073 * Function: Test anomalous branch
3074 * SubFunction: NA
3075 * FunctionPoints: NA
3076 * EnvConditions: NA
3077 * CaseDescription: Test CaptureSession with no static capability.
3078 */
3079 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_009, TestSize.Level0)
3080 {
3081 g_mockFlagWithoutAbt = true;
3082 sptr<CameraManager> camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager));
3083
3084 std::vector<sptr<CameraDevice>> cameras = camManager->GetSupportedCameras();
3085
3086 sptr<CaptureInput> input = camManager->CreateCameraInput(cameras[0]);
3087 ASSERT_NE(input, nullptr);
3088
3089 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3090 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3091 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3092 std::string cameraSettings = camInput->GetCameraSettings();
3093 camInput->SetCameraSettings(cameraSettings);
3094 camInput->GetCameraDevice()->Open();
3095
3096 sptr<CaptureOutput> photo = CreatePhotoOutput();
3097 ASSERT_NE(photo, nullptr);
3098
3099 sptr<CaptureSession> session = camManager->CreateCaptureSession();
3100 ASSERT_NE(session, nullptr);
3101
3102 EXPECT_EQ(session->BeginConfig(), 0);
3103
3104 EXPECT_EQ(session->AddInput(input), 0);
3105 EXPECT_EQ(session->AddOutput(photo), 0);
3106
3107 EXPECT_EQ(session->CommitConfig(), 0);
3108
3109 sptr<CameraOutputCapability> cameraOutputCapability = camManager->GetSupportedOutputCapability(cameras[0]);
3110
3111 std::vector<FocusMode> supportedFocusModes = session->GetSupportedFocusModes();
3112 EXPECT_EQ(supportedFocusModes.empty(), true);
3113 EXPECT_EQ(session->GetSupportedFocusModes(supportedFocusModes), 0);
3114
3115 EXPECT_EQ(session->GetFocusMode(), 0);
3116
3117 float focalLength = session->GetFocalLength();
3118 EXPECT_EQ(focalLength, 0);
3119 EXPECT_EQ(session->GetFocalLength(focalLength), 0);
3120
3121 std::vector<FlashMode> supportedFlashModes = session->GetSupportedFlashModes();
3122 EXPECT_EQ(supportedFlashModes.empty(), true);
3123 EXPECT_EQ(session->GetSupportedFlashModes(supportedFlashModes), 0);
3124 EXPECT_EQ(session->GetFlashMode(), 0);
3125 EXPECT_EQ(session->GetZoomRatio(), 0);
3126
3127 bool isSupported;
3128 EXPECT_EQ(session->IsVideoStabilizationModeSupported(MIDDLE, isSupported), 0);
3129 if (isSupported) {
3130 EXPECT_EQ(session->SetVideoStabilizationMode(MIDDLE), 0);
3131 } else {
3132 EXPECT_EQ(session->SetVideoStabilizationMode(MIDDLE), 7400102);
3133 }
3134 EXPECT_EQ(session->IsFlashModeSupported(FLASH_MODE_AUTO), false);
3135 EXPECT_EQ(session->IsFlashModeSupported(FLASH_MODE_AUTO, isSupported), 0);
3136
3137 sptr<PhotoOutput> photoOutput = (sptr<PhotoOutput> &)photo;
3138 EXPECT_EQ(photoOutput->IsMirrorSupported(), false);
3139
3140 input->Close();
3141 session->Release();
3142 }
3143
3144 /*
3145 * Feature: Framework
3146 * Function: Test anomalous branch
3147 * SubFunction: NA
3148 * FunctionPoints: NA
3149 * EnvConditions: NA
3150 * CaseDescription: Test dump with no static capability.
3151 */
3152 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_010, TestSize.Level0)
3153 {
3154 g_mockFlagWithoutAbt = true;
3155 sptr<CameraManager> camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager));
3156 std::vector<sptr<CameraDevice>> cameras = camManager->GetSupportedCameras();
3157
3158 sptr<CaptureInput> input = camManager->CreateCameraInput(cameras[0]);
3159 ASSERT_NE(input, nullptr);
3160
3161 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3162 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3163 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3164 std::string cameraSettings = camInput->GetCameraSettings();
3165 camInput->SetCameraSettings(cameraSettings);
3166 camInput->GetCameraDevice()->Open();
3167
3168 sptr<FakeHCameraService> mockHCameraService = new FakeHCameraService(mockCameraHostManager);
3169 sptr<HCameraService> camService = (sptr<HCameraService> &)mockHCameraService;
3170 ASSERT_NE(camService, nullptr);
3171
3172 camService->OnStart();
3173
3174 std::vector<std::string> cameraIds = {};
3175 std::vector<std::shared_ptr<OHOS::Camera::CameraMetadata>> cameraAbilityList = {};
3176 int32_t ret = camService->GetCameras(cameraIds, cameraAbilityList);
3177
3178 int fd = 0;
3179 std::vector<std::u16string> args = {};
3180 ret = camService->Dump(fd, args);
3181 EXPECT_EQ(ret, 0);
3182
3183 std::u16string cameraServiceInfo = u"";
3184 args.push_back(cameraServiceInfo);
3185 ret = camService->Dump(fd, args);
3186 EXPECT_EQ(ret, 0);
3187
3188 input->Close();
3189 }
3190
3191 /*
3192 * Feature: Framework
3193 * Function: Test anomalous branch
3194 * SubFunction: NA
3195 * FunctionPoints: NA
3196 * EnvConditions: NA
3197 * CaseDescription: Test dump with no static capability.
3198 */
3199 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_dump_001, TestSize.Level0)
3200 {
3201 g_mockFlagWithoutAbt = true;
3202 sptr<CameraManager> camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager));
3203 std::vector<sptr<CameraDevice>> cameras = camManager->GetSupportedCameras();
3204
3205 sptr<CaptureInput> input = camManager->CreateCameraInput(cameras[0]);
3206 ASSERT_NE(input, nullptr);
3207
3208 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3209 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3210 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3211 std::string cameraSettings = camInput->GetCameraSettings();
3212 camInput->SetCameraSettings(cameraSettings);
3213 camInput->GetCameraDevice()->Open();
3214
3215 sptr<FakeHCameraService> mockHCameraService = new FakeHCameraService(mockCameraHostManager);
3216 sptr<HCameraService> camService = (sptr<HCameraService> &)mockHCameraService;
3217 ASSERT_NE(camService, nullptr);
3218
3219 camService->OnStart();
3220
3221 std::vector<std::string> cameraIds = {};
3222 std::vector<std::shared_ptr<OHOS::Camera::CameraMetadata>> cameraAbilityList = {};
3223 int32_t ret = camService->GetCameras(cameraIds, cameraAbilityList);
3224
3225 int fd = 0;
3226 std::vector<std::u16string> args = {};
3227 ret = camService->Dump(fd, args);
3228 EXPECT_EQ(ret, 0);
3229
3230 std::u16string cameraServiceInfo = u"";
3231 args.push_back(cameraServiceInfo);
3232 cameraServiceInfo = u"debugOn";
3233 args.push_back(cameraServiceInfo);
3234 ret = camService->Dump(fd, args);
3235 EXPECT_EQ(ret, 0);
3236
3237 input->Close();
3238 }
3239
3240 /*
3241 * Feature: coverage
3242 * Function: Test anomalous branch
3243 * SubFunction: NA
3244 * FunctionPoints: NA
3245 * EnvConditions: NA
3246 * CaseDescription: Test HStreamCapture SetRotation with no static capability.
3247 */
3248 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_011, TestSize.Level0)
3249 {
3250 g_mockFlagWithoutAbt = true;
3251 sptr<CameraManager> camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager));
3252 std::vector<sptr<CameraDevice>> cameras = camManager->GetSupportedCameras();
3253
3254 sptr<CaptureInput> input = camManager->CreateCameraInput(cameras[0]);
3255 ASSERT_NE(input, nullptr);
3256
3257 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3258 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3259 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3260 std::string cameraSettings = camInput->GetCameraSettings();
3261 camInput->SetCameraSettings(cameraSettings);
3262 camInput->GetCameraDevice()->Open();
3263
3264 sptr<CaptureOutput> photo = CreatePhotoOutput();
3265 ASSERT_NE(photo, nullptr);
3266
3267 sptr<CaptureSession> session = camManager->CreateCaptureSession();
3268 ASSERT_NE(session, nullptr);
3269
3270 int32_t ret = session->BeginConfig();
3271 EXPECT_EQ(ret, 0);
3272
3273 ret = session->AddInput(input);
3274 EXPECT_EQ(ret, 0);
3275
3276 ret = session->AddOutput(photo);
3277 EXPECT_EQ(ret, 0);
3278
3279 ret = session->CommitConfig();
3280 EXPECT_EQ(ret, 0);
3281
3282 std::shared_ptr<PhotoCaptureSetting> photoSetting = std::make_shared<PhotoCaptureSetting>();
3283 photoSetting->SetRotation(PhotoCaptureSetting::Rotation_90);
3284 photoSetting->SetQuality(PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM);
3285 EXPECT_EQ(photoSetting->GetRotation(), PhotoCaptureSetting::Rotation_90);
3286 EXPECT_EQ(photoSetting->GetQuality(), PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM);
3287
3288 EXPECT_CALL(*mockStreamOperator, Capture(_,
3289 matchCaptureSetting(photoSetting->GetCaptureMetadataSetting()), false));
3290 ret = ((sptr<PhotoOutput> &)photo)->Capture(photoSetting);
3291 EXPECT_EQ(ret, 0);
3292
3293 input->Close();
3294 session->Release();
3295 input->Release();
3296 }
3297
3298 /*
3299 * Feature: coverage
3300 * Function: Test anomalous branch
3301 * SubFunction: NA
3302 * FunctionPoints: NA
3303 * EnvConditions: NA
3304 * CaseDescription: Test HStreamRepeat with no static capability.
3305 */
3306 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_012, TestSize.Level0)
3307 {
3308 g_mockFlagWithoutAbt = true;
3309 sptr<CameraManager> camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager));
3310 int32_t format = CAMERA_FORMAT_YUV_420_SP;
3311 int32_t width = PHOTO_DEFAULT_WIDTH;
3312 int32_t height = PHOTO_DEFAULT_HEIGHT;
3313
3314 std::vector<sptr<CameraDevice>> cameras = camManager->GetSupportedCameras();
3315
3316 sptr<CaptureInput> input = camManager->CreateCameraInput(cameras[0]);
3317 ASSERT_NE(input, nullptr);
3318
3319 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3320 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3321 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3322 std::string cameraSettings = camInput->GetCameraSettings();
3323 camInput->SetCameraSettings(cameraSettings);
3324 camInput->GetCameraDevice()->Open();
3325
3326 sptr<CaptureOutput> photo = CreatePhotoOutput();
3327 ASSERT_NE(photo, nullptr);
3328
3329 sptr<CaptureOutput> metadatOutput = camManager->CreateMetadataOutput();
3330 ASSERT_NE(metadatOutput, nullptr);
3331
3332 sptr<CaptureSession> session = camManager->CreateCaptureSession();
3333 ASSERT_NE(session, nullptr);
3334
3335 EXPECT_EQ(session->BeginConfig(), 0);
3336
3337 EXPECT_EQ(session->AddInput(input), 0);
3338 EXPECT_EQ(session->AddOutput(photo), 0);
3339 EXPECT_EQ(session->AddOutput(metadatOutput), 0);
3340
3341 EXPECT_EQ(session->CommitConfig(), 0);
3342
3343 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
3344 sptr<IBufferProducer> producer1 = Surface->GetProducer();
3345 auto streamRepeat = new (std::nothrow) HStreamRepeat(producer1, format, width, height, RepeatStreamType::PREVIEW);
3346 ASSERT_NE(streamRepeat, nullptr);
3347
3348 std::shared_ptr<PhotoCaptureSetting> photoSetting = std::make_shared<PhotoCaptureSetting>();
3349 photoSetting->SetRotation(PhotoCaptureSetting::Rotation_90);
3350 photoSetting->SetQuality(PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM);
3351 EXPECT_EQ(photoSetting->GetRotation(), PhotoCaptureSetting::Rotation_90);
3352 EXPECT_EQ(photoSetting->GetQuality(), PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM);
3353 if (streamRepeat->LinkInput(mockStreamOperator, photoSetting->GetCaptureMetadataSetting()) != 0) {
3354 EXPECT_EQ(streamRepeat->Stop(), CAMERA_INVALID_STATE);
3355 EXPECT_EQ(streamRepeat->Start(), CAMERA_INVALID_STATE);
3356
3357 EXPECT_EQ(streamRepeat->AddDeferredSurface(producer1), CAMERA_INVALID_STATE);
3358
3359 EXPECT_EQ(streamRepeat->Start(), CAMERA_INVALID_STATE);
3360 EXPECT_EQ(streamRepeat->Stop(), CAMERA_INVALID_STATE);
3361 }
3362 input->Close();
3363 session->Release();
3364 }
3365
3366 /*
3367 * Feature: coverage
3368 * Function: Test anomalous branch
3369 * SubFunction: NA
3370 * FunctionPoints: NA
3371 * EnvConditions: NA
3372 * CaseDescription: Test HCaptureSession with anomalous branch.
3373 */
3374 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_014, TestSize.Level0)
3375 {
3376 InSequence s;
3377 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
3378 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
3379 ASSERT_NE(input, nullptr);
3380
3381 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3382 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3383 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3384 std::string cameraSettings = camInput->GetCameraSettings();
3385 camInput->SetCameraSettings(cameraSettings);
3386 camInput->GetCameraDevice()->Open();
3387
3388 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
3389 SceneMode mode = PORTRAIT;
3390 sptr<HCaptureSession> camSession = new (std::nothrow) HCaptureSession(callerToken, mode);
3391 ASSERT_NE(camSession, nullptr);
3392
3393 camSession->BeginConfig();
3394 camSession->Start();
3395
3396 sptr<ICameraDeviceService> cameraDevice = camInput->GetCameraDevice();
3397 EXPECT_EQ(camSession->AddInput(cameraDevice), 0);
3398
3399 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
3400 sptr<IBufferProducer> producer = Surface->GetProducer();
3401
3402 auto streamRepeat = new (std::nothrow) HStreamRepeat(producer, 4, 1280, 960, RepeatStreamType::PREVIEW);
3403 ASSERT_NE(streamRepeat, nullptr);
3404 auto streamRepeat1 = new (std::nothrow) HStreamRepeat(producer, 3, 640, 480, RepeatStreamType::PREVIEW);
3405 ASSERT_NE(streamRepeat1, nullptr);
3406 sptr<HStreamCapture> streamCapture = new (std::nothrow) HStreamCapture(producer, 4, 1280, 960);
3407 ASSERT_NE(streamCapture, nullptr);
3408
3409 EXPECT_EQ(camSession->AddOutput(StreamType::REPEAT, streamRepeat), 0);
3410 EXPECT_EQ(camSession->AddOutput(StreamType::REPEAT, streamRepeat1), 0);
3411 EXPECT_EQ(camSession->AddOutput(StreamType::CAPTURE, streamCapture), 0);
3412
3413 CaptureErrorInfo it1;
3414 it1.streamId_ = 2;
3415 it1.error_ = BUFFER_LOST;
3416 CaptureErrorInfo it2;
3417 it2.streamId_ = 1;
3418 it2.error_ = BUFFER_LOST;
3419 std::vector<CaptureErrorInfo> info = {};
3420 info.push_back(it1);
3421 info.push_back(it2);
3422 camSession->OnCaptureError(0, info);
3423
3424 std::vector<int32_t> streamIds = {1, 2};
3425 camSession->OnFrameShutter(0, streamIds, 0);
3426 camSession->OnFrameShutterEnd(0, streamIds, 0);
3427 camSession->OnCaptureReady(0, streamIds, 0);
3428 input->Close();
3429 camSession->Release();
3430 }
3431
3432 /*
3433 * Feature: coverage
3434 * Function: Test anomalous branch
3435 * SubFunction: NA
3436 * FunctionPoints: NA
3437 * EnvConditions: NA
3438 * CaseDescription: Test HCaptureSession with anomalous branch.
3439 */
3440 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_015, TestSize.Level0)
3441 {
3442 InSequence s;
3443 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
3444 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
3445 ASSERT_NE(input, nullptr);
3446
3447 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3448 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3449 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3450 std::string cameraSettings = camInput->GetCameraSettings();
3451 camInput->SetCameraSettings(cameraSettings);
3452 camInput->GetCameraDevice()->Open();
3453
3454 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
3455 SceneMode mode = PORTRAIT;
3456 sptr<HCaptureSession> camSession = new (std::nothrow) HCaptureSession(callerToken, mode);
3457 ASSERT_NE(camSession, nullptr);
3458
3459 camSession->BeginConfig();
3460 camSession->Start();
3461
3462 sptr<ICameraDeviceService> cameraDevice = camInput->GetCameraDevice();
3463 EXPECT_EQ(camSession->AddInput(cameraDevice), 0);
3464
3465 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
3466 sptr<IBufferProducer> producer = Surface->GetProducer();
3467 sptr<HStreamCapture> streamCapture = new (std::nothrow) HStreamCapture(producer, 4, 1280, 960);
3468 sptr<HStreamCapture> streamCapture1 = new (std::nothrow) HStreamCapture(producer, 3, 640, 480);
3469 sptr<HStreamRepeat> streamRepeat =
3470 new (std::nothrow) HStreamRepeat(producer, 4, 1280, 960, RepeatStreamType::PREVIEW);
3471 ASSERT_NE(streamRepeat, nullptr);
3472
3473 EXPECT_EQ(camSession->AddOutput(StreamType::CAPTURE, streamCapture), 0);
3474 EXPECT_EQ(camSession->AddOutput(StreamType::CAPTURE, streamCapture1), 0);
3475 EXPECT_EQ(camSession->AddOutput(StreamType::REPEAT, streamRepeat), 0);
3476
3477 CaptureErrorInfo it1;
3478 it1.streamId_ = 2;
3479 it1.error_ = BUFFER_LOST;
3480 CaptureErrorInfo it2;
3481 it2.streamId_ = 1;
3482 it2.error_ = BUFFER_LOST;
3483 std::vector<CaptureErrorInfo> info = {};
3484 info.push_back(it1);
3485 info.push_back(it2);
3486 camSession->OnCaptureError(0, info);
3487
3488 std::vector<int32_t> streamIds = {1, 2};
3489 camSession->OnFrameShutter(0, streamIds, 0);
3490 camSession->OnFrameShutterEnd(0, streamIds, 0);
3491 camSession->OnCaptureReady(0, streamIds, 0);
3492
3493 input->Close();
3494 camSession->Release();
3495 }
3496
3497 /*
3498 * Feature: coverage
3499 * Function: Test anomalous branch
3500 * SubFunction: NA
3501 * FunctionPoints: NA
3502 * EnvConditions: NA
3503 * CaseDescription: Test HCaptureSession with anomalous branch.
3504 */
3505 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_016, TestSize.Level0)
3506 {
3507 InSequence s;
3508 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
3509
3510 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
3511 ASSERT_NE(input, nullptr);
3512
3513 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3514 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3515 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3516 std::string cameraSettings = camInput->GetCameraSettings();
3517 camInput->SetCameraSettings(cameraSettings);
3518 camInput->GetCameraDevice()->Open();
3519
3520 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
3521 sptr<HCaptureSession> camSession = new (std::nothrow) HCaptureSession(callerToken, PORTRAIT);
3522
3523 EXPECT_EQ(camSession->CommitConfig(), CAMERA_INVALID_STATE);
3524 camSession->BeginConfig();
3525 camSession->Start();
3526
3527 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
3528 sptr<IBufferProducer> producer = Surface->GetProducer();
3529 sptr<HStreamCapture> streamCapture= new(std::nothrow) HStreamCapture(producer, 0, 0, 0);
3530 ASSERT_NE(streamCapture, nullptr);
3531
3532 sptr<ICameraDeviceService> cameraDevice = camInput->GetCameraDevice();
3533 EXPECT_EQ(camSession->AddInput(cameraDevice), 0);
3534 EXPECT_EQ(camSession->AddOutput(StreamType::CAPTURE, streamCapture), 0);
3535
3536 camSession->CommitConfig();
3537
3538 CaptureErrorInfo it1;
3539 it1.streamId_ = 0;
3540 it1.error_ = BUFFER_LOST;
3541 CaptureErrorInfo it2;
3542 it2.streamId_ = 1;
3543 it2.error_ = BUFFER_LOST;
3544 std::vector<CaptureErrorInfo> info = {};
3545 info.push_back(it1);
3546 info.push_back(it2);
3547 camSession->OnCaptureError(0, info);
3548
3549 std::vector<int32_t> streamIds = {0, 1, 2};
3550 camSession->OnFrameShutter(0, streamIds, 0);
3551 camSession->OnFrameShutterEnd(0, streamIds, 0);
3552 camSession->OnCaptureReady(0, streamIds, 0);
3553 camSession->BeginConfig();
3554
3555 input->Close();
3556 camSession->Release();
3557 }
3558
3559 /*
3560 * Feature: coverage
3561 * Function: Test anomalous branch
3562 * SubFunction: NA
3563 * FunctionPoints: NA
3564 * EnvConditions: NA
3565 * CaseDescription: Test HCaptureSession with anomalous branch.
3566 */
3567 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_017, TestSize.Level0)
3568 {
3569 InSequence s;
3570 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
3571
3572 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
3573 ASSERT_NE(input, nullptr);
3574
3575 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3576 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3577 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3578 std::string cameraSettings = camInput->GetCameraSettings();
3579 camInput->SetCameraSettings(cameraSettings);
3580 camInput->GetCameraDevice()->Open();
3581
3582 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
3583 sptr<StreamOperatorCallback> streamOperatorCb = nullptr;
3584 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
3585 SceneMode mode = PORTRAIT;
3586 sptr<HCaptureSession> camSession = new (std::nothrow) HCaptureSession(callerToken, mode);
3587 sptr<HCaptureSession> camSession1 = new (std::nothrow) HCaptureSession(12, mode);
3588 ASSERT_NE(camSession, nullptr);
3589 ASSERT_NE(camSession1, nullptr);
3590 EXPECT_EQ(camSession->Start(), CAMERA_INVALID_STATE);
3591 camSession1->Start();
3592
3593 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
3594 sptr<IBufferProducer> producer = Surface->GetProducer();
3595 sptr<HStreamRepeat> streamRepeat = new (std::nothrow) HStreamRepeat(producer, 0, 0, 0, RepeatStreamType::PREVIEW);
3596 ASSERT_NE(streamRepeat, nullptr);
3597 sptr<HStreamMetadata> streamMetadata= new(std::nothrow) HStreamMetadata(producer, 0, {1});
3598 ASSERT_NE(streamMetadata, nullptr);
3599 EXPECT_EQ(camSession->AddOutput(StreamType::REPEAT, streamRepeat), CAMERA_INVALID_STATE);
3600 EXPECT_EQ(camSession->RemoveOutput(StreamType::REPEAT, streamRepeat), CAMERA_INVALID_STATE);
3601
3602 sptr<ICameraDeviceService> cameraDevice = camInput->GetCameraDevice();
3603 camSession->BeginConfig();
3604 camSession->Start();
3605 camSession->AddOutput(StreamType::METADATA, streamMetadata);
3606 camSession->AddOutput(StreamType::METADATA, streamMetadata);
3607 camSession->RemoveOutput(StreamType::METADATA, streamMetadata);
3608 camSession->AddInput(cameraDevice);
3609
3610 camSession->AddInput(cameraDevice);
3611
3612 sptr<ICaptureSessionCallback> callback1 = nullptr;
3613 camSession->SetCallback(callback1);
3614
3615 CameraInfoDumper infoDumper(0);
3616 camSession->DumpSessionInfo(infoDumper);
3617 camSession->DumpSessions(infoDumper);
3618
3619 input->Close();
3620 camSession->Release();
3621 }
3622
3623 /*
3624 * Feature: Framework
3625 * Function: Test anomalous branch
3626 * SubFunction: NA
3627 * FunctionPoints: NA
3628 * EnvConditions: NA
3629 * CaseDescription: Test GetExposureValue and SetExposureBias with anomalous branch.
3630 */
3631 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_018, TestSize.Level0)
3632 {
3633 InSequence s;
3634 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
3635
3636 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
3637 ASSERT_NE(input, nullptr);
3638
3639 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3640 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3641 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3642 std::string cameraSettings = camInput->GetCameraSettings();
3643 camInput->SetCameraSettings(cameraSettings);
3644 camInput->GetCameraDevice()->Open();
3645
3646 sptr<CaptureOutput> photo = CreatePhotoOutput();
3647 ASSERT_NE(photo, nullptr);
3648
3649 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
3650 ASSERT_NE(session, nullptr);
3651
3652 int32_t ret = session->BeginConfig();
3653 EXPECT_EQ(ret, 0);
3654
3655 ret = session->AddInput(input);
3656 EXPECT_EQ(ret, 0);
3657
3658 ret = session->AddOutput(photo);
3659 EXPECT_EQ(ret, 0);
3660
3661 ret = session->CommitConfig();
3662 EXPECT_EQ(ret, 0);
3663
3664 session->LockForControl();
3665
3666 Point exposurePoint = {1.0, 2.0};
3667 session->SetMeteringPoint(exposurePoint);
3668 session->SetMeteringPoint(exposurePoint);
3669
3670 ExposureMode exposure = EXPOSURE_MODE_AUTO;
3671 bool exposureSupported = session->IsExposureModeSupported(exposure);
3672 if (exposureSupported) {
3673 session->SetExposureMode(exposure);
3674 }
3675
3676 ret = session->GetExposureMode(exposure);
3677 EXPECT_EQ(ret, 0);
3678
3679 ExposureMode exposureMode = session->GetExposureMode();
3680 exposureSupported = session->IsExposureModeSupported(exposureMode);
3681 if (exposureSupported) {
3682 int32_t setExposureMode = session->SetExposureMode(exposureMode);
3683 EXPECT_EQ(setExposureMode, 0);
3684 }
3685 session->UnlockForControl();
3686 input->Close();
3687 session->Release();
3688 }
3689
3690 /*
3691 * Feature: Framework
3692 * Function: Test anomalous branch
3693 * SubFunction: NA
3694 * FunctionPoints: NA
3695 * EnvConditions: NA
3696 * CaseDescription: Test GetMeteringPoint and GetMeteringPoint with anomalous branch.
3697 */
3698 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_019, TestSize.Level0)
3699 {
3700 InSequence s;
3701 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
3702
3703 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
3704 ASSERT_NE(input, nullptr);
3705
3706 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3707 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3708 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3709 std::string cameraSettings = camInput->GetCameraSettings();
3710 camInput->SetCameraSettings(cameraSettings);
3711 camInput->GetCameraDevice()->Open();
3712
3713 sptr<CaptureOutput> photo = CreatePhotoOutput();
3714 ASSERT_NE(photo, nullptr);
3715
3716 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
3717 ASSERT_NE(session, nullptr);
3718
3719 int32_t ret = session->BeginConfig();
3720 EXPECT_EQ(ret, 0);
3721
3722 ret = session->AddInput(input);
3723 EXPECT_EQ(ret, 0);
3724
3725 ret = session->AddOutput(photo);
3726 EXPECT_EQ(ret, 0);
3727
3728 ret = session->CommitConfig();
3729 EXPECT_EQ(ret, 0);
3730
3731 session->LockForControl();
3732
3733 Point exposurePointGet = session->GetMeteringPoint();
3734 int32_t getMeteringPoint = session->GetMeteringPoint(exposurePointGet);
3735 EXPECT_EQ(getMeteringPoint, 0);
3736
3737 float exposureValue = session->GetExposureValue();
3738 int32_t exposureValueGet = session->GetExposureValue(exposureValue);
3739 EXPECT_EQ(exposureValueGet, 0);
3740
3741 int32_t setExposureBias = session->SetExposureBias(exposureValue);
3742 EXPECT_EQ(setExposureBias, 0);
3743
3744 input->Close();
3745 session->Release();
3746 }
3747
3748 /*
3749 * Feature: Framework
3750 * Function: Test anomalous branch
3751 * SubFunction: NA
3752 * FunctionPoints: NA
3753 * EnvConditions: NA
3754 * CaseDescription: Test CaptureSession with anomalous branch
3755 */
3756 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_020, TestSize.Level0)
3757 {
3758 InSequence s;
3759 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
3760
3761 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
3762 ASSERT_NE(input, nullptr);
3763
3764 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3765 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3766 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3767 std::string cameraSettings = camInput->GetCameraSettings();
3768 camInput->SetCameraSettings(cameraSettings);
3769 camInput->GetCameraDevice()->Open();
3770
3771 sptr<CaptureOutput> photo = CreatePhotoOutput();
3772 ASSERT_NE(photo, nullptr);
3773
3774 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
3775 ASSERT_NE(session, nullptr);
3776
3777 int32_t ret = session->BeginConfig();
3778 EXPECT_EQ(ret, 0);
3779
3780 ret = session->AddInput(input);
3781 EXPECT_EQ(ret, 0);
3782
3783 ret = session->AddOutput(photo);
3784 EXPECT_EQ(ret, 0);
3785
3786 ret = session->CommitConfig();
3787 EXPECT_EQ(ret, 0);
3788
3789 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = cameras[0]->GetMetadata();
3790 std::shared_ptr<ExposureCallback> exposureCallback = std::make_shared<CallbackListener>();
3791 session->SetExposureCallback(exposureCallback);
3792 session->ProcessAutoExposureUpdates(metadata);
3793
3794 std::shared_ptr<FocusCallback> focusCallback = std::make_shared<CallbackListener>();
3795 session->SetFocusCallback(focusCallback);
3796 session->ProcessAutoFocusUpdates(metadata);
3797
3798 std::vector<FocusMode> getSupportedFocusModes = session->GetSupportedFocusModes();
3799 EXPECT_EQ(getSupportedFocusModes.empty(), false);
3800 int32_t supportedFocusModesGet = session->GetSupportedFocusModes(getSupportedFocusModes);
3801 EXPECT_EQ(supportedFocusModesGet, 0);
3802
3803 input->Close();
3804 session->Release();
3805 }
3806
3807 /*
3808 * Feature: Framework
3809 * Function: Test anomalous branch
3810 * SubFunction: NA
3811 * FunctionPoints: NA
3812 * EnvConditions: NA
3813 * CaseDescription: Test CaptureSession with anomalous branch.
3814 */
3815 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_021, TestSize.Level0)
3816 {
3817 InSequence s;
3818 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
3819
3820 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
3821 ASSERT_NE(input, nullptr);
3822
3823 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3824 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3825 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3826 std::string cameraSettings = camInput->GetCameraSettings();
3827 camInput->SetCameraSettings(cameraSettings);
3828 camInput->GetCameraDevice()->Open();
3829
3830 sptr<CaptureOutput> photo = CreatePhotoOutput();
3831 ASSERT_NE(photo, nullptr);
3832
3833 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
3834 ASSERT_NE(session, nullptr);
3835
3836 int32_t ret = session->BeginConfig();
3837 EXPECT_EQ(ret, 0);
3838
3839 ret = session->AddInput(input);
3840 EXPECT_EQ(ret, 0);
3841
3842 ret = session->AddOutput(photo);
3843 EXPECT_EQ(ret, 0);
3844
3845 ret = session->CommitConfig();
3846 EXPECT_EQ(ret, 0);
3847
3848 std::vector<FlashMode> getSupportedFlashModes = session->GetSupportedFlashModes();
3849 EXPECT_EQ(getSupportedFlashModes.empty(), false);
3850 int32_t getSupportedFlashMode = session->GetSupportedFlashModes(getSupportedFlashModes);
3851 EXPECT_EQ(getSupportedFlashMode, 0);
3852
3853 FlashMode flashMode = session->GetFlashMode();
3854 int32_t flashModeGet = session->GetFlashMode(flashMode);
3855 EXPECT_EQ(flashModeGet, 0);
3856 int32_t setFlashMode = session->SetFlashMode(flashMode);
3857 EXPECT_EQ(setFlashMode, 0);
3858
3859 input->Close();
3860 session->Release();
3861 }
3862
3863 /*
3864 * Feature: Framework
3865 * Function: Test anomalous branch
3866 * SubFunction: NA
3867 * FunctionPoints: NA
3868 * EnvConditions: NA
3869 * CaseDescription: Test SetFocusPoint & GetFousPoint with anomalous branch.
3870 */
3871 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_022, TestSize.Level0)
3872 {
3873 InSequence s;
3874 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
3875
3876 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
3877 ASSERT_NE(input, nullptr);
3878
3879 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3880 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3881 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3882 std::string cameraSettings = camInput->GetCameraSettings();
3883 camInput->SetCameraSettings(cameraSettings);
3884 camInput->GetCameraDevice()->Open();
3885
3886 sptr<CaptureOutput> photo = CreatePhotoOutput();
3887 ASSERT_NE(photo, nullptr);
3888
3889 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
3890 ASSERT_NE(session, nullptr);
3891
3892 int32_t ret = session->BeginConfig();
3893 EXPECT_EQ(ret, 0);
3894
3895 ret = session->AddInput(input);
3896 EXPECT_EQ(ret, 0);
3897
3898 ret = session->AddOutput(photo);
3899 EXPECT_EQ(ret, 0);
3900
3901 ret = session->CommitConfig();
3902 EXPECT_EQ(ret, 0);
3903
3904 Point FocusPoint = {1.0, 2.0};
3905 session->LockForControl();
3906 session->SetFocusPoint(FocusPoint);
3907 session->UnlockForControl();
3908
3909 session->GetFocusPoint(FocusPoint);
3910
3911 session->RemoveInput(input);
3912 session->RemoveOutput(photo);
3913 photo->Release();
3914 input->Close();
3915 input->Release();
3916 session->Release();
3917 }
3918
3919 /*
3920 * Feature: Framework
3921 * Function: Test anomalous branch.
3922 * SubFunction: NA
3923 * FunctionPoints: NA
3924 * EnvConditions: NA
3925 * CaseDescription: Test CaptureSession with anomalous branch.
3926 */
3927 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_023, TestSize.Level0)
3928 {
3929 InSequence s;
3930 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
3931
3932 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
3933 ASSERT_NE(input, nullptr);
3934
3935 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
3936 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
3937 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
3938 std::string cameraSettings = camInput->GetCameraSettings();
3939 camInput->SetCameraSettings(cameraSettings);
3940 camInput->GetCameraDevice()->Open();
3941
3942 sptr<CaptureOutput> photo = CreatePhotoOutput();
3943 ASSERT_NE(photo, nullptr);
3944
3945 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
3946 ASSERT_NE(session, nullptr);
3947
3948 EXPECT_EQ(session->BeginConfig(), 0);
3949
3950 EXPECT_EQ(session->AddInput(input), 0);
3951 EXPECT_EQ(session->AddOutput(photo), 0);
3952
3953 EXPECT_EQ(session->CommitConfig(), 0);
3954
3955 EXPECT_EQ(session->GetFocusMode(), 2);
3956
3957 session->LockForControl();
3958
3959 FlashMode flash = FLASH_MODE_ALWAYS_OPEN;
3960 session->SetFlashMode(flash);
3961 session->SetFlashMode(flash);
3962
3963 FocusMode focus = FOCUS_MODE_CONTINUOUS_AUTO;
3964 session->SetFocusMode(focus);
3965 session->SetFocusMode(focus);
3966
3967 ExposureMode exposure = EXPOSURE_MODE_AUTO;
3968 session->SetExposureMode(exposure);
3969
3970 float zoomRatioRange = session->GetZoomRatio();
3971 session->SetZoomRatio(zoomRatioRange);
3972 session->SetZoomRatio(zoomRatioRange);
3973
3974 session->UnlockForControl();
3975
3976 EXPECT_EQ(session->GetFocusMode(focus), 0);
3977
3978 cameraManager->GetSupportedOutputCapability(cameras[0], 0);
3979
3980 VideoStabilizationMode stabilizationMode = MIDDLE;
3981 session->GetActiveVideoStabilizationMode();
3982 session->GetActiveVideoStabilizationMode(stabilizationMode);
3983 session->SetVideoStabilizationMode(stabilizationMode);
3984
3985 input->Close();
3986 input->Release();
3987 session->Release();
3988 }
3989
3990 /*
3991 * Feature: Framework
3992 * Function: Test IsCameraNeedClose & CheckPermission
3993 * SubFunction: NA
3994 * FunctionPoints: NA
3995 * EnvConditions: NA
3996 * CaseDescription: Test IsCameraNeedClose & CheckPermission
3997 */
3998 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_024, TestSize.Level0)
3999 {
4000 CamRetCode rc1 = HDI::Camera::V1_0::CAMERA_BUSY;
4001 EXPECT_EQ(HdiToServiceError(rc1), CAMERA_DEVICE_BUSY);
4002 CamRetCode rc2 = HDI::Camera::V1_0::INVALID_ARGUMENT;
4003 EXPECT_EQ(HdiToServiceError(rc2), CAMERA_INVALID_ARG);
4004 CamRetCode rc3 = HDI::Camera::V1_0::CAMERA_CLOSED;
4005 EXPECT_EQ(HdiToServiceError(rc3), CAMERA_DEVICE_CLOSED);
4006 CreateMsg(NULL);
4007
4008 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
4009 pid_t pid = IPCSkeleton::GetCallingPid();
4010 IsCameraNeedClose(callerToken, pid, pid);
4011 IsCameraNeedClose(123, pid, pid);
4012 CheckPermission("unittest", 0);
4013 }
4014
4015 /*
4016 * Feature: Framework
4017 * Function: Test anomalous branch
4018 * SubFunction: NA
4019 * FunctionPoints: NA
4020 * EnvConditions: NA
4021 * CaseDescription: Test HCameraDevice with anomalous branch.
4022 */
4023 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_025, TestSize.Level0)
4024 {
4025 std::vector<int32_t> result;
4026 result.push_back(OHOS_SENSOR_EXPOSURE_TIME);
4027 result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
4028
4029 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4030
4031 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
4032 std::string cameraId = cameras[0]->GetID();
4033 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
4034 sptr<HCameraDevice> camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken);
4035 ASSERT_NE(camDevice, nullptr);
4036
4037 sptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator = nullptr;
4038 sptr<CameraInput> input = cameraManager->CreateCameraInput(cameras[0]);
4039 sptr<ICameraDeviceServiceCallback> callback1 = new(std::nothrow) CameraDeviceServiceCallback(input);
4040 ASSERT_NE(callback1, nullptr);
4041
4042 camDevice->EnableResult(result);
4043 camDevice->DisableResult(result);
4044
4045 int32_t ret = camDevice->Open();
4046 EXPECT_EQ(ret, 0);
4047 camDevice->UpdateSetting(nullptr);
4048 sptr<ICameraDeviceServiceCallback> callback = nullptr;
4049 camDevice->SetCallback(callback);
4050 camDevice->GetDeviceAbility();
4051 camDevice->SetCallback(callback1);
4052 camDevice->OnError(REQUEST_TIMEOUT, 0) ;
4053 camDevice->OnError(DEVICE_PREEMPT, 0) ;
4054 camDevice->OnError(DRIVER_ERROR, 0) ;
4055
4056 EXPECT_EQ(camDevice->Close(), 0);
4057 EXPECT_EQ(camDevice->GetEnabledResults(result), 11);
4058 EXPECT_EQ(camDevice->Close(), 0);
4059 }
4060
4061 /*
4062 * Feature: Framework
4063 * Function: Test HStreamRepeat & HStreamCommon
4064 * SubFunction: NA
4065 * FunctionPoints: NA
4066 * EnvConditions: NA
4067 * CaseDescription: Test HStreamRepeat & HStreamCommon
4068 */
4069 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_026, TestSize.Level0)
4070 {
4071 int32_t format = 0;
4072 int32_t width = 0;
4073 int32_t height = 0;
4074 CameraInfoDumper infoDumper(0);
4075 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4076 sptr<IStreamRepeatCallback> callback = nullptr;
4077 sptr<OHOS::IBufferProducer> producer = nullptr;
4078 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
4079 sptr<IBufferProducer> producer1 = Surface->GetProducer();
4080 sptr<HStreamRepeat> streamRepeat =
4081 new (std::nothrow) HStreamRepeat(nullptr, format, width, height, RepeatStreamType::PREVIEW);
4082 ASSERT_NE(streamRepeat, nullptr);
4083
4084 EXPECT_EQ(streamRepeat->Start(), CAMERA_INVALID_STATE);
4085 EXPECT_EQ(streamRepeat->SetCallback(callback), CAMERA_INVALID_ARG);
4086 EXPECT_EQ(streamRepeat->OnFrameError(BUFFER_LOST), 0);
4087 EXPECT_EQ(streamRepeat->AddDeferredSurface(producer), CAMERA_INVALID_ARG);
4088 streamRepeat->DumpStreamInfo(infoDumper);
4089 EXPECT_EQ(streamRepeat->AddDeferredSurface(producer1), CAMERA_INVALID_STATE);
4090 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = cameras[0]->GetMetadata();
4091 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata1 = nullptr;
4092 EXPECT_EQ(streamRepeat->LinkInput(mockStreamOperator, metadata), CAMERA_OK);
4093 streamRepeat->LinkInput(mockStreamOperator, metadata1);
4094 mockStreamOperator = nullptr;
4095 streamRepeat->LinkInput(mockStreamOperator, metadata);
4096 streamRepeat->DumpStreamInfo(infoDumper);
4097 EXPECT_EQ(streamRepeat->Stop(), CAMERA_INVALID_STATE);
4098 }
4099
4100 /*
4101 * Feature: Framework
4102 * Function: Test HStreamMetadata & HStreamCommon
4103 * SubFunction: NA
4104 * FunctionPoints: NA
4105 * EnvConditions: NA
4106 * CaseDescription: Test HStreamMetadata & HStreamCommon
4107 */
4108 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_027, TestSize.Level0)
4109 {
4110 int32_t format = 0;
4111 CameraInfoDumper infoDumper(0);
4112 std::string dumpString ="HStreamMetadata";
4113 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4114 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
4115 sptr<IBufferProducer> producer = Surface->GetProducer();
4116 sptr<HStreamMetadata> streamMetadata= new(std::nothrow) HStreamMetadata(producer, format, {1});
4117 ASSERT_NE(streamMetadata, nullptr);
4118 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = cameras[0]->GetMetadata();
4119 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata1 = nullptr;
4120 streamMetadata->LinkInput(mockStreamOperator, metadata);
4121 streamMetadata->LinkInput(mockStreamOperator, metadata1);
4122 mockStreamOperator = nullptr;
4123 streamMetadata->LinkInput(mockStreamOperator, metadata);
4124 streamMetadata->Stop();
4125 streamMetadata->Start();
4126 streamMetadata->DumpStreamInfo(infoDumper);
4127 streamMetadata->Start();
4128 streamMetadata->Stop();
4129 }
4130
4131 /*
4132 * Feature: Framework
4133 * Function: Test HStreamMetadata & HStreamCommon
4134 * SubFunction: NA
4135 * FunctionPoints: NA
4136 * EnvConditions: NA
4137 * CaseDescription: Test HStreamMetadata & HStreamCommon
4138 */
4139 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_028, TestSize.Level0)
4140 {
4141 int32_t format = 0;
4142 std::string dumpString ="HStreamMetadata";
4143 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4144 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
4145 sptr<IBufferProducer> producer = Surface->GetProducer();
4146 sptr<HStreamMetadata> streamMetadata= new(std::nothrow) HStreamMetadata(producer, format, {1});
4147 ASSERT_NE(streamMetadata, nullptr);
4148 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = cameras[0]->GetMetadata();
4149 streamMetadata->Start();
4150 streamMetadata->LinkInput(mockStreamOperator, metadata);
4151 streamMetadata->Stop();
4152 }
4153
4154 /*
4155 * Feature: Framework
4156 * Function: Test HStreamCapture & HStreamCommon
4157 * SubFunction: NA
4158 * FunctionPoints: NA
4159 * EnvConditions: NA
4160 * CaseDescription: Test HStreamCapture & HStreamCommon
4161 */
4162 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_029, TestSize.Level0)
4163 {
4164 int32_t format = 0;
4165 int32_t width = 0;
4166 int32_t height = 0;
4167 int32_t captureId = 0;
4168 int32_t frameCount = 0;
4169 uint64_t timestamp = 0;
4170 CameraInfoDumper infoDumper(0);
4171 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4172 sptr<IStreamCaptureCallback> callback = nullptr;
4173 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
4174 sptr<IBufferProducer> producer = Surface->GetProducer();
4175 sptr<OHOS::IBufferProducer> producer1 = nullptr;
4176 sptr<HStreamCapture> streamCapture= new(std::nothrow) HStreamCapture(producer, format, width, height);
4177 ASSERT_NE(streamCapture, nullptr);
4178 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = cameras[0]->GetMetadata();
4179 EXPECT_EQ(streamCapture->SetThumbnail(false, producer1), CAMERA_OK);
4180 EXPECT_EQ(streamCapture->SetThumbnail(false, producer), CAMERA_OK);
4181 EXPECT_EQ(streamCapture->SetThumbnail(true, producer1), CAMERA_OK);
4182 streamCapture->DumpStreamInfo(infoDumper);
4183 EXPECT_EQ(streamCapture->SetThumbnail(true, producer), CAMERA_OK);
4184 streamCapture->SetRotation(metadata, captureId);
4185 mockStreamOperator = nullptr;
4186 streamCapture->LinkInput(mockStreamOperator, metadata);
4187 EXPECT_EQ(streamCapture->Capture(metadata), CAMERA_INVALID_STATE);
4188 EXPECT_EQ(streamCapture->SetCallback(callback), CAMERA_INVALID_ARG);
4189 EXPECT_EQ(streamCapture->OnCaptureEnded(captureId, frameCount), CAMERA_OK);
4190 EXPECT_EQ(streamCapture->OnCaptureError(captureId, frameCount), CAMERA_OK);
4191 EXPECT_EQ(streamCapture->OnCaptureError(captureId, BUFFER_LOST), CAMERA_OK);
4192 EXPECT_EQ(streamCapture->OnFrameShutter(captureId, timestamp), CAMERA_OK);
4193 EXPECT_EQ(streamCapture->OnFrameShutterEnd(captureId, timestamp), CAMERA_OK);
4194 EXPECT_EQ(streamCapture->OnCaptureReady(captureId, timestamp), CAMERA_OK);
4195 streamCapture->DumpStreamInfo(infoDumper);
4196
4197 EXPECT_EQ(streamCapture->Release(), 0);
4198 }
4199
4200 /*
4201 * Feature: Framework
4202 * Function: Test HCameraDevice
4203 * SubFunction: NA
4204 * FunctionPoints: NA
4205 * EnvConditions: NA
4206 * CaseDescription: Test HCameraDevice
4207 */
4208 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_030, TestSize.Level0)
4209 {
4210 std::vector<int32_t> result;
4211 result.push_back(OHOS_SENSOR_EXPOSURE_TIME);
4212 result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
4213
4214 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4215
4216 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
4217 std::string cameraId = cameras[0]->GetID();
4218 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
4219 uint32_t callerToken1 = 3;
4220 sptr<HCameraDevice> camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken);
4221 ASSERT_NE(camDevice, nullptr);
4222 sptr<HCameraDevice> camDevice1 = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken1);
4223 ASSERT_NE(camDevice1, nullptr);
4224
4225 sptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator = nullptr;
4226 sptr<CameraInput> input = cameraManager->CreateCameraInput(cameras[0]);
4227 sptr<ICameraDeviceServiceCallback> callback1 = new(std::nothrow) CameraDeviceServiceCallback(input);
4228 ASSERT_NE(callback1, nullptr);
4229 camDevice->EnableResult(result);
4230 camDevice->DisableResult(result);
4231
4232 int32_t ret = camDevice->Open();
4233 EXPECT_EQ(ret, 0);
4234 camDevice->Open();
4235 g_getCameraAbilityerror = true;
4236 camDevice->GetDeviceAbility();
4237 g_openCameraDevicerror = true;
4238 EXPECT_EQ(camDevice->Open(), 0);
4239
4240 camDevice->Close();
4241 }
4242
4243 /*
4244 * Feature: Framework
4245 * Function: Test anomalous branch
4246 * SubFunction: NA
4247 * FunctionPoints: NA
4248 * EnvConditions: NA
4249 * CaseDescription: Test HCameraHostManager with anomalous branch.
4250 */
4251 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_031, TestSize.Level0)
4252 {
4253 InSequence s;
4254 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4255
4256 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
4257 ASSERT_NE(input, nullptr);
4258
4259 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
4260 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
4261 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
4262 std::string cameraSettings = camInput->GetCameraSettings();
4263 camInput->SetCameraSettings(cameraSettings);
4264 camInput->GetCameraDevice()->Open();
4265
4266 std::vector<std::string> cameraIds = {};
4267 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
4268 cameraHostManager->Init();
4269 ASSERT_NE(cameraHostManager, nullptr);
4270
4271 std::string cameraId = cameras[0]->GetID();
4272 EXPECT_EQ(cameraHostManager->HCameraHostManager::GetCameras(cameraIds), 0);
4273 std::shared_ptr<OHOS::Camera::CameraMetadata> ability = cameras[0]->GetMetadata();
4274 EXPECT_EQ(cameraHostManager->HCameraHostManager::GetCameraAbility(cameraId, ability), 2);
4275 EXPECT_EQ(cameraHostManager->HCameraHostManager::SetFlashlight(cameraId, false), 2);
4276
4277 cameraId = "HCameraHostManager";
4278
4279 cameraHostManager->AddCameraDevice(cameraId, nullptr);
4280 EXPECT_EQ(cameraHostManager->HCameraHostManager::SetFlashlight(cameraId, true), 2);
4281
4282 cameraHostManager->CloseCameraDevice(cameraId);
4283
4284 ability = cameras[0]->GetMetadata();
4285 EXPECT_EQ(cameraHostManager->HCameraHostManager::GetCameraAbility(cameraId, ability), 2);
4286
4287 EXPECT_EQ(cameraHostManager->HCameraHostManager::GetVersionByCamera(cameraId), 0);
4288
4289 sptr<OHOS::HDI::Camera::V1_0::ICameraDevice> pDevice;
4290 cameraHostManager->HCameraHostManager::OpenCameraDevice(cameraId, nullptr, pDevice);
4291
4292 cameraId = cameras[0]->GetID();
4293 HDI::ServiceManager::V1_0::ServiceStatus status;
4294 status.deviceClass = DEVICE_CLASS_CAMERA;
4295 status.serviceName = "distributed_camera_service";
4296 status.status = HDI::ServiceManager::V1_0::SERVIE_STATUS_START;
4297 cameraHostManager->GetRegisterServStatListener()->OnReceive(status);
4298
4299 EXPECT_EQ(cameraHostManager->HCameraHostManager::SetFlashlight(cameraId, false), 2);
4300
4301 std::shared_ptr<MockHCameraHostManager::MockStatusCallback> mockStatusCallback =
4302 std::make_shared<MockHCameraHostManager::MockStatusCallback>();
4303 sptr<MockHCameraHostManager> mockCameraHostManager_2 =
4304 new (std::nothrow) MockHCameraHostManager(mockStatusCallback);
4305 ASSERT_NE(mockCameraHostManager_2, nullptr);
4306 sptr<HCameraHostManager> cameraHostManager_2 = (sptr<HCameraHostManager> &)mockCameraHostManager_2;
4307
4308 cameraHostManager_2->AddCameraDevice(cameraId, nullptr);
4309 cameraHostManager->DeInit();
4310 input->Close();
4311 }
4312
4313
4314 /*
4315 * Feature: Framework
4316 * Function: Test !IsSessionCommited() && !IsSessionConfiged() in AttachSketchSurface,
4317 * IsSketchSupported, StartSketch, StopSketch, OnSketchStatusChanged,
4318 * CreateSketchWrapper, GetSketchRatio
4319 * SubFunction: NA
4320 * FunctionPoints: NA
4321 * EnvConditions: NA
4322 * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged() in AttachSketchSurface,
4323 * IsSketchSupported, StartSketch, StopSketch, OnSketchStatusChanged,
4324 * CreateSketchWrapper, GetSketchRatio
4325 */
4326 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_032, TestSize.Level0)
4327 {
4328 InSequence s;
4329 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4330 Size previewSize = {.width = 1440, .height = 1080};
4331
4332 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
4333 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
4334 ASSERT_NE(input, nullptr);
4335
4336 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
4337 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
4338 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
4339 std::string cameraSettings = camInput->GetCameraSettings();
4340 camInput->SetCameraSettings(cameraSettings);
4341 camInput->GetCameraDevice()->Open();
4342
4343 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
4344 ASSERT_NE(session, nullptr);
4345 sptr<CaptureOutput> preview = CreatePreviewOutput();
4346 ASSERT_NE(preview, nullptr);
4347 auto previewOutput = (sptr<PreviewOutput>&)preview;
4348
4349 EXPECT_EQ(previewOutput->IsSketchSupported(), false);
4350 int32_t ret = session->BeginConfig();
4351 EXPECT_EQ(ret, 0);
4352
4353 EXPECT_EQ(previewOutput->AttachSketchSurface(surface), CameraErrorCode::SESSION_NOT_CONFIG);
4354 EXPECT_EQ(previewOutput->StartSketch(), CameraErrorCode::SESSION_NOT_CONFIG);
4355 EXPECT_EQ(previewOutput->StopSketch(), CameraErrorCode::SESSION_NOT_CONFIG);
4356
4357 EXPECT_EQ(previewOutput->OnSketchStatusChanged(SketchStatus::STOPED), CAMERA_INVALID_STATE);
4358 EXPECT_EQ(previewOutput->IsSketchSupported(), false);
4359
4360 EXPECT_NE(previewOutput->CreateSketchWrapper(previewSize), 0);
4361 EXPECT_EQ(previewOutput->GetSketchRatio(), -1);
4362
4363 ret = session->AddInput(input);
4364 EXPECT_EQ(ret, 0);
4365 ret = session->AddOutput(preview);
4366 EXPECT_EQ(ret, 0);
4367
4368 EXPECT_EQ(session->RemoveOutput(preview), 0);
4369 EXPECT_EQ(session->RemoveInput(input), 0);
4370 EXPECT_EQ(preview->Release(), 0);
4371 EXPECT_EQ(input->Release(), 0);
4372 EXPECT_EQ(session->Release(), 0);
4373 }
4374
4375 /*
4376 * Feature: Framework
4377 * Function: Test !IsSessionCommited() && !IsSessionConfiged() in IsSketchSupported,
4378 * FindSketchSize, EnableSketch
4379 * SubFunction: NA
4380 * FunctionPoints: NA
4381 * EnvConditions: NA
4382 * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged() in IsSketchSupported,
4383 * FindSketchSize, EnableSketch
4384 */
4385 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_033, TestSize.Level0)
4386 {
4387 InSequence s;
4388 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4389 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
4390 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
4391 ASSERT_NE(input, nullptr);
4392
4393 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
4394 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
4395 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
4396 std::string cameraSettings = camInput->GetCameraSettings();
4397 camInput->SetCameraSettings(cameraSettings);
4398 camInput->GetCameraDevice()->Open();
4399
4400 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
4401 ASSERT_NE(session, nullptr);
4402 sptr<CaptureOutput> preview = CreatePreviewOutput();
4403 ASSERT_NE(preview, nullptr);
4404 auto previewOutput = (sptr<PreviewOutput>&)preview;
4405 EXPECT_EQ(previewOutput->IsSketchSupported(), false);
4406 int32_t ret = session->BeginConfig();
4407 EXPECT_EQ(ret, 0);
4408 ret = session->AddInput(input);
4409 EXPECT_EQ(ret, 0);
4410 ret = session->AddOutput(preview);
4411 EXPECT_EQ(ret, 0);
4412
4413 previewOutput->SetSession(session);
4414 previewOutput->FindSketchSize();
4415 EXPECT_EQ(previewOutput->EnableSketch(true), 7400102);
4416 ret = session->CommitConfig();
4417 EXPECT_EQ(ret, 0);
4418 EXPECT_EQ(preview->Release(), 0);
4419 EXPECT_EQ(input->Release(), 0);
4420 EXPECT_EQ(session->Release(), 0);
4421 }
4422
4423 /*
4424 * Feature: Framework
4425 * Function: Test !IsSessionCommited() && !IsSessionConfiged() in IsSketchSupported,
4426 * OnNativeRegisterCallback, OnNativeUnregisterCallback, CameraServerDied, SetCallback
4427 * SubFunction: NA
4428 * FunctionPoints: NA
4429 * EnvConditions: NA
4430 * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged() in IsSketchSupported,
4431 * OnNativeRegisterCallback, OnNativeUnregisterCallback, CameraServerDied, SetCallback
4432 */
4433 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_034, TestSize.Level0)
4434 {
4435 InSequence s;
4436 Size previewSize = {.width = 1440, .height = 1080};
4437 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4438 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
4439 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
4440 ASSERT_NE(input, nullptr);
4441
4442 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
4443 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
4444 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
4445 std::string cameraSettings = camInput->GetCameraSettings();
4446 camInput->SetCameraSettings(cameraSettings);
4447 camInput->GetCameraDevice()->Open();
4448
4449 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
4450 ASSERT_NE(session, nullptr);
4451 sptr<CaptureOutput> preview = CreatePreviewOutput();
4452 ASSERT_NE(preview, nullptr);
4453 auto previewOutput = (sptr<PreviewOutput>&)preview;
4454
4455 EXPECT_EQ(previewOutput->IsSketchSupported(), false);
4456 std::string eventString = "test";
4457 previewOutput->OnNativeRegisterCallback(eventString);
4458 previewOutput->OnNativeUnregisterCallback(eventString);
4459 eventString = "sketchStatusChanged";
4460 previewOutput->sketchWrapper_ = std::make_shared<SketchWrapper>(previewOutput->GetStream(), previewSize);
4461 previewOutput->OnNativeRegisterCallback(eventString);
4462 previewOutput->OnNativeUnregisterCallback(eventString);
4463 previewOutput->CameraServerDied(0);
4464 std::shared_ptr<PreviewStateCallback> previewStateCallback =
4465 std::make_shared<TestPreviewOutputCallback>("PreviewStateCallback");
4466 previewOutput->SetCallback(previewStateCallback);
4467 previewOutput->CameraServerDied(0);
4468
4469 EXPECT_EQ(session->Release(), 0);
4470 EXPECT_EQ(input->Close(), 0);
4471 }
4472
4473 /*
4474 * Feature: Framework
4475 * Function: Test Init, AttachSketchSurface, UpdateSketchRatio,
4476 * SetPreviewStateCallback, OnSketchStatusChanged,
4477 * UpdateSketchReferenceFovRatio in sketchWrapper
4478 * SubFunction: NA
4479 * FunctionPoints: NA
4480 * EnvConditions: NA
4481 * CaseDescription: Test Init, AttachSketchSurface, UpdateSketchRatio,
4482 * SetPreviewStateCallback, OnSketchStatusChanged,
4483 * UpdateSketchReferenceFovRatio in sketchWrapper
4484 */
4485 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_035, TestSize.Level0)
4486 {
4487 InSequence s;
4488 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4489 Size previewSize = { .width = 1440, .height = 1080 };
4490 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
4491 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
4492 ASSERT_NE(input, nullptr);
4493
4494 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
4495 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
4496 sptr<CameraInput> camInput = (sptr<CameraInput>&)input;
4497 std::string cameraSettings = camInput->GetCameraSettings();
4498 camInput->SetCameraSettings(cameraSettings);
4499 camInput->GetCameraDevice()->Open();
4500
4501 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
4502 ASSERT_NE(session, nullptr);
4503
4504 std::shared_ptr<OHOS::Camera::CameraMetadata> deviceMetadata = cameras[0]->GetMetadata();
4505 ASSERT_NE(deviceMetadata, nullptr);
4506 auto modeName = session->GetFeaturesMode();
4507 CameraFormat previewFormat = CAMERA_FORMAT_YCBCR_420_888;
4508 Profile previewProfile = Profile(previewFormat, previewSize);
4509 sptr<CaptureOutput> preview = cameraManager->CreatePreviewOutput(previewProfile, surface);
4510 ASSERT_NE(preview, nullptr);
4511 auto previewOutput = (sptr<PreviewOutput>&)preview;
4512
4513 SketchWrapper* sketchWrapper = new (std::nothrow) SketchWrapper(previewOutput->GetStream(), previewSize);
4514 ASSERT_NE(sketchWrapper, nullptr);
4515 std::shared_ptr<PreviewStateCallback> setCallback =
4516 std::make_shared<TestPreviewOutputCallback>("PreviewStateCallback");
4517 ASSERT_NE(setCallback, nullptr);
4518 camera_metadata_item_t item;
4519 OHOS::Camera::FindCameraMetadataItem(deviceMetadata->get(), OHOS_CONTROL_ZOOM_RATIO, &item);
4520 SceneFeaturesMode defaultSceneFeature(SceneMode::NORMAL, {});
4521 SceneFeaturesMode captureSceneFeature(SceneMode::CAPTURE, {});
4522 EXPECT_EQ(sketchWrapper->Init(deviceMetadata, modeName), 0);
4523 EXPECT_EQ(sketchWrapper->AttachSketchSurface(surface), 10);
4524 EXPECT_EQ(sketchWrapper->UpdateSketchRatio(1.0f), 0);
4525 sketchWrapper->SetPreviewStateCallback(setCallback);
4526 sketchWrapper->OnSketchStatusChanged(defaultSceneFeature);
4527 sketchWrapper->OnSketchStatusChanged(SketchStatus::STARTED, defaultSceneFeature);
4528 sketchWrapper->OnSketchStatusChanged(SketchStatus::STOPED, defaultSceneFeature);
4529 sketchWrapper->currentSketchStatusData_.sketchRatio = 1.0f;
4530 sketchWrapper->OnSketchStatusChanged(modeName);
4531 sketchWrapper->OnSketchStatusChanged(SketchStatus::STOPED, captureSceneFeature);
4532 sketchWrapper->UpdateSketchReferenceFovRatio(item);
4533
4534 EXPECT_EQ(session->Release(), 0);
4535 EXPECT_EQ(input->Close(), 0);
4536 }
4537
4538 /*
4539 * Feature: Framework
4540 * Function: Test AttachSketchSurface, StartSketch, StopSketch,
4541 * OnNativeRegisterCallback in ~PreviewOutput
4542 * SubFunction: NA
4543 * FunctionPoints: NA
4544 * EnvConditions: NA
4545 * CaseDescription: Test AttachSketchSurface, StartSketch,
4546 * StopSketch, OnNativeRegisterCallback in ~PreviewOutput
4547 */
4548 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_036, TestSize.Level0)
4549 {
4550 InSequence s;
4551 Size previewSize = {.width = 1440, .height = 1080};
4552 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4553 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
4554 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
4555 ASSERT_NE(input, nullptr);
4556
4557 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
4558 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
4559 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
4560 std::string cameraSettings = camInput->GetCameraSettings();
4561 camInput->SetCameraSettings(cameraSettings);
4562 camInput->GetCameraDevice()->Open();
4563
4564 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
4565 ASSERT_NE(session, nullptr);
4566 sptr<CaptureOutput> preview = CreatePreviewOutput();
4567 ASSERT_NE(preview, nullptr);
4568 auto previewOutput = (sptr<PreviewOutput>&)preview;
4569
4570 int32_t ret = session->BeginConfig();
4571 ret = session->AddInput(input);
4572 ret = session->AddOutput(preview);
4573 EXPECT_EQ(ret, 0);
4574
4575 ret = session->CommitConfig();
4576 EXPECT_EQ(ret, 0);
4577
4578 previewOutput->Release();
4579 previewOutput->SetSession(session);
4580 EXPECT_EQ(previewOutput->AttachSketchSurface(surface), INVALID_ARGUMENT);
4581 EXPECT_EQ(previewOutput->StartSketch(), 7400201);
4582 EXPECT_EQ(previewOutput->StopSketch(), 7400201);
4583 previewOutput->sketchWrapper_ = std::make_shared<SketchWrapper>(previewOutput->GetStream(), previewSize);
4584 previewOutput->OnNativeRegisterCallback("sketchStatusChanged");
4585
4586 EXPECT_EQ(input->Release(), 0);
4587 EXPECT_EQ(session->Release(), 0);
4588 }
4589
4590 /*
4591 * Feature: Framework
4592 * Function: Test !IsSessionCommited() && !IsSessionConfiged() in
4593 * OnMetadataChanged, OnSketchStatusChanged
4594 * SubFunction: NA
4595 * FunctionPoints: NA
4596 * EnvConditions: NA
4597 * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged()
4598 * in OnMetadataChanged, OnSketchStatusChanged
4599 */
4600 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_037, TestSize.Level0)
4601 {
4602 InSequence s;
4603 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4604 Size previewSize = {.width = 1440, .height = 1080};
4605 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
4606 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
4607 ASSERT_NE(input, nullptr);
4608
4609 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
4610 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
4611 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
4612 std::string cameraSettings = camInput->GetCameraSettings();
4613 camInput->SetCameraSettings(cameraSettings);
4614 camInput->GetCameraDevice()->Open();
4615
4616 std::shared_ptr<OHOS::Camera::CameraMetadata> deviceMetadata = cameras[0]->GetMetadata();
4617 ASSERT_NE(deviceMetadata, nullptr);
4618 camera_metadata_item_t item;
4619 OHOS::Camera::FindCameraMetadataItem(deviceMetadata->get(), OHOS_CONTROL_ZOOM_RATIO, &item);
4620 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
4621 ASSERT_NE(session, nullptr);
4622 sptr<CaptureOutput> preview = CreatePreviewOutput();
4623 ASSERT_NE(preview, nullptr);
4624 auto previewOutput = (sptr<PreviewOutput>&)preview;
4625
4626 EXPECT_EQ(session->BeginConfig(), 0);
4627 EXPECT_EQ(session->AddInput(input), 0);
4628 EXPECT_EQ(session->AddOutput(preview), 0);
4629
4630 item.count = 0;
4631 EXPECT_EQ(previewOutput->OnControlMetadataChanged(OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES, item),
4632 CAM_META_INVALID_PARAM);
4633 item.count = 1;
4634 EXPECT_EQ(previewOutput->OnControlMetadataChanged(OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES, item),
4635 CAM_META_FAILURE);
4636 previewOutput->sketchWrapper_ = std::make_shared<SketchWrapper>(previewOutput->GetStream(), previewSize);
4637
4638 previewOutput->SetSession(nullptr);
4639 EXPECT_EQ(previewOutput->OnSketchStatusChanged(SketchStatus::STOPED), CAMERA_INVALID_STATE);
4640 EXPECT_EQ(previewOutput->OnControlMetadataChanged(OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES, item),
4641 CAM_META_FAILURE);
4642 previewOutput->SetSession(session);
4643 EXPECT_EQ(previewOutput->OnControlMetadataChanged(OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES, item),
4644 CAM_META_SUCCESS);
4645 EXPECT_EQ(previewOutput->OnSketchStatusChanged(SketchStatus::STOPED), CAMERA_OK);
4646
4647 EXPECT_EQ(session->CommitConfig(), 0);
4648 EXPECT_EQ(preview->Release(), 0);
4649 EXPECT_EQ(input->Release(), 0);
4650 EXPECT_EQ(session->Release(), 0);
4651 }
4652
4653 /*
4654 * Feature: Framework
4655 * Function: Test cameraFormat with CAMERA_FORMAT_YUV_420_SP and CAMERA_FORMAT_JPEG
4656 * SubFunction: NA
4657 * FunctionPoints: NA
4658 * EnvConditions: NA
4659 * CaseDescription: Test cameraFormat with CAMERA_FORMAT_YUV_420_SP and CAMERA_FORMAT_JPEG
4660 */
4661 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_038, TestSize.Level0)
4662 {
4663 InSequence s;
4664 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4665 Size previewSize = {.width = 1440, .height = 1080};
4666 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
4667 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
4668 ASSERT_NE(input, nullptr);
4669
4670 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
4671 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
4672 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
4673 std::string cameraSettings = camInput->GetCameraSettings();
4674 camInput->SetCameraSettings(cameraSettings);
4675 camInput->GetCameraDevice()->Open();
4676
4677 std::shared_ptr<OHOS::Camera::CameraMetadata> deviceMetadata = cameras[0]->GetMetadata();
4678 ASSERT_NE(deviceMetadata, nullptr);
4679 camera_metadata_item_t item;
4680 OHOS::Camera::FindCameraMetadataItem(deviceMetadata->get(), OHOS_CONTROL_ZOOM_RATIO, &item);
4681 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
4682 ASSERT_NE(session, nullptr);
4683 CameraFormat previewFormat = CAMERA_FORMAT_YCBCR_420_888;
4684 Profile previewProfile = Profile(previewFormat, previewSize);
4685 sptr<CaptureOutput> preview = cameraManager->CreatePreviewOutput(previewProfile, surface);
4686 ASSERT_NE(preview, nullptr);
4687 auto previewOutput = (sptr<PreviewOutput>&)preview;
4688 EXPECT_EQ(previewOutput->IsSketchSupported(), false);
4689 auto currentPreviewProfile = previewOutput->GetPreviewProfile();
4690 currentPreviewProfile->format_ = CAMERA_FORMAT_YUV_420_SP;
4691 EXPECT_EQ(previewOutput->IsSketchSupported(), false);
4692 currentPreviewProfile->format_ = CAMERA_FORMAT_JPEG;
4693 EXPECT_EQ(previewOutput->IsSketchSupported(), false);
4694
4695 EXPECT_EQ(preview->Release(), 0);
4696 EXPECT_EQ(input->Release(), 0);
4697 EXPECT_EQ(session->Release(), 0);
4698 }
4699
4700 /*
4701 * Feature: Framework
4702 * Function: Test !IsSessionCommited() && !IsSessionConfiged() in
4703 * AttachSketchSurface, StartSketch, StopSketch, OnNativeRegisterCallback
4704 * SubFunction: NA
4705 * FunctionPoints: NA
4706 * EnvConditions: NA
4707 * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged()
4708 * in AttachSketchSurface, StartSketch, StopSketch, OnNativeRegisterCallback
4709 */
4710 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_039, TestSize.Level0)
4711 {
4712 InSequence s;
4713 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4714 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
4715 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
4716 ASSERT_NE(input, nullptr);
4717 Size previewSize = {.width = 1440, .height = 1080};
4718
4719 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
4720 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
4721 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
4722 std::string cameraSettings = camInput->GetCameraSettings();
4723 camInput->SetCameraSettings(cameraSettings);
4724 camInput->GetCameraDevice()->Open();
4725
4726 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
4727 ASSERT_NE(session, nullptr);
4728 sptr<CaptureOutput> preview = CreatePreviewOutput();
4729 ASSERT_NE(preview, nullptr);
4730 auto previewOutput = (sptr<PreviewOutput>&)preview;
4731
4732 int32_t ret = session->BeginConfig();
4733 EXPECT_EQ(ret, 0);
4734 EXPECT_EQ(session->AddInput(input), 0);
4735 EXPECT_EQ(session->AddOutput(preview), 0);
4736 EXPECT_EQ(session->CommitConfig(), 0);
4737 previewOutput->SetSession(session);
4738
4739 EXPECT_EQ(previewOutput->AttachSketchSurface(surface), INVALID_ARGUMENT);
4740 EXPECT_EQ(previewOutput->StartSketch(), 7400201);
4741 EXPECT_EQ(previewOutput->StopSketch(), 7400201);
4742 previewOutput->sketchWrapper_ = std::make_shared<SketchWrapper>(previewOutput->GetStream(), previewSize);
4743 EXPECT_EQ(previewOutput->AttachSketchSurface(surface), 7400201);
4744 EXPECT_EQ(previewOutput->AttachSketchSurface(nullptr), CameraErrorCode::INVALID_ARGUMENT);
4745 EXPECT_EQ(previewOutput->StartSketch(), 7400201);
4746 EXPECT_EQ(previewOutput->StopSketch(), 7400201);
4747 previewOutput->OnNativeRegisterCallback("sketchStatusChanged");
4748
4749 EXPECT_EQ(preview->Release(), 0);
4750 EXPECT_EQ(input->Release(), 0);
4751 EXPECT_EQ(session->Release(), 0);
4752 }
4753
4754 /*
4755 * Feature: Framework
4756 * Function: Test CameraServerDied
4757 * SubFunction: NA
4758 * FunctionPoints: NA
4759 * EnvConditions: NA
4760 * CaseDescription: Test if innerCaptureSession_ == nullptr in CameraServerDied
4761 */
4762 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_040, TestSize.Level0)
4763 {
4764 InSequence s;
4765 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4766 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
4767 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
4768 ASSERT_NE(input, nullptr);
4769
4770 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
4771 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
4772 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
4773 std::string cameraSettings = camInput->GetCameraSettings();
4774 camInput->SetCameraSettings(cameraSettings);
4775 camInput->GetCameraDevice()->Open();
4776
4777 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
4778 ASSERT_NE(session, nullptr);
4779 sptr<CaptureOutput> preview = CreatePreviewOutput();
4780 ASSERT_NE(preview, nullptr);
4781 auto appCallback = std::make_shared<AppSessionCallback>();
4782 ASSERT_NE(appCallback, nullptr);
4783
4784 EXPECT_EQ(session->BeginConfig(), 0);
4785 session->CameraServerDied(0);
4786 session->appCallback_ = appCallback;
4787 session->CameraServerDied(0);
4788 session->innerCaptureSession_ = nullptr;
4789 session->CameraServerDied(0);
4790 session->appCallback_ = nullptr;
4791
4792 EXPECT_EQ(preview->Release(), 0);
4793 EXPECT_EQ(input->Release(), 0);
4794 session->Release();
4795 }
4796
4797 /*
4798 * Feature: Framework
4799 * Function: Test !IsSessionCommited() && !IsSessionConfiged() in
4800 * PrepareZoom, UnPrepareZoom, SetSmoothZoom
4801 * SubFunction: NA
4802 * FunctionPoints: NA
4803 * EnvConditions: NA
4804 * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged()
4805 * in PrepareZoom, UnPrepareZoom, SetSmoothZoom
4806 */
4807 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_041, TestSize.Level0)
4808 {
4809 InSequence s;
4810 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4811 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
4812 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
4813 ASSERT_NE(input, nullptr);
4814
4815 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
4816 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
4817 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
4818 std::string cameraSettings = camInput->GetCameraSettings();
4819 camInput->SetCameraSettings(cameraSettings);
4820 camInput->GetCameraDevice()->Open();
4821
4822 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
4823 ASSERT_NE(session, nullptr);
4824 sptr<CaptureOutput> preview = CreatePreviewOutput();
4825 ASSERT_NE(preview, nullptr);
4826
4827 EXPECT_EQ(session->PrepareZoom(), CameraErrorCode::SESSION_NOT_CONFIG);
4828 EXPECT_EQ(session->UnPrepareZoom(), CameraErrorCode::SESSION_NOT_CONFIG);
4829
4830 EXPECT_EQ(session->BeginConfig(), 0);
4831 EXPECT_EQ(session->PrepareZoom(), CameraErrorCode::SUCCESS);
4832 EXPECT_EQ(session->UnPrepareZoom(), CameraErrorCode::SUCCESS);
4833
4834 EXPECT_EQ(session->AddInput(input), 0);
4835 EXPECT_EQ(session->AddOutput(preview), 0);
4836
4837 session->SetSmoothZoom(0, 0);
4838
4839 EXPECT_EQ(session->CommitConfig(), 0);
4840 EXPECT_EQ(session->PrepareZoom(), CameraErrorCode::SUCCESS);
4841 EXPECT_EQ(session->UnPrepareZoom(), CameraErrorCode::SUCCESS);
4842 EXPECT_EQ(session->SetSmoothZoom(0, 0), CameraErrorCode::SUCCESS);
4843
4844 session->LockForControl();
4845 session->PrepareZoom();
4846 session->UnPrepareZoom();
4847 session->UnlockForControl();
4848
4849 EXPECT_EQ(preview->Release(), 0);
4850 EXPECT_EQ(input->Release(), 0);
4851 session->Release();
4852 }
4853
4854 /*
4855 * Feature: Framework
4856 * Function: Test !IsSessionCommited() && !IsSessionConfiged() in
4857 * PrepareZoom, UnPrepareZoom, SetSmoothZoom,
4858 * SetBeauty of ~CaptureSession
4859 * SubFunction: NA
4860 * FunctionPoints: NA
4861 * EnvConditions: NA
4862 * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged()
4863 * in PrepareZoom, UnPrepareZoom, SetSmoothZoom,
4864 * SetBeauty of ~CaptureSession
4865 */
4866 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_042, TestSize.Level0)
4867 {
4868 InSequence s;
4869 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4870 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
4871 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
4872 ASSERT_NE(input, nullptr);
4873
4874 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
4875 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
4876 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
4877 std::string cameraSettings = camInput->GetCameraSettings();
4878 camInput->SetCameraSettings(cameraSettings);
4879 camInput->GetCameraDevice()->Open();
4880
4881 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
4882 ASSERT_NE(session, nullptr);
4883 sptr<CaptureOutput> preview = CreatePreviewOutput();
4884 ASSERT_NE(preview, nullptr);
4885
4886 EXPECT_EQ(session->BeginConfig(), 0);
4887 EXPECT_EQ(session->AddInput(input), 0);
4888 EXPECT_EQ(session->AddOutput(preview), 0);
4889
4890 EXPECT_EQ(session->CommitConfig(), 0);
4891 session->Release();
4892 EXPECT_EQ(session->PrepareZoom(), CameraErrorCode::SESSION_NOT_CONFIG);
4893 EXPECT_EQ(session->UnPrepareZoom(), CameraErrorCode::SESSION_NOT_CONFIG);
4894 EXPECT_EQ(session->SetSmoothZoom(0, 0), CameraErrorCode::SESSION_NOT_CONFIG);
4895 session->SetBeauty(AUTO_TYPE, 0);
4896
4897 EXPECT_EQ(input->Release(), 0);
4898 }
4899
4900 /*
4901 * Feature: Framework
4902 * Function: Test !IsSessionCommited() && !IsSessionConfiged() in
4903 * SetBeautyValue, SetBeauty, CalculateExposureValue, SetFilter
4904 * SubFunction: NA
4905 * FunctionPoints: NA
4906 * EnvConditions: NA
4907 * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged()
4908 * in SetBeautyValue, SetBeauty, CalculateExposureValue, SetFilter
4909 */
4910 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_043, TestSize.Level0)
4911 {
4912 InSequence s;
4913 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4914 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
4915 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
4916 ASSERT_NE(input, nullptr);
4917
4918 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
4919 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
4920 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
4921 std::string cameraSettings = camInput->GetCameraSettings();
4922 camInput->SetCameraSettings(cameraSettings);
4923 camInput->GetCameraDevice()->Open();
4924
4925 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
4926 ASSERT_NE(session, nullptr);
4927 sptr<CaptureOutput> preview = CreatePreviewOutput();
4928 ASSERT_NE(preview, nullptr);
4929
4930 EXPECT_EQ(session->SetBeautyValue(AUTO_TYPE, 0), false);
4931
4932 session->SetBeauty(AUTO_TYPE, 0);
4933 EXPECT_EQ(session->BeginConfig(), 0);
4934 session->SetBeauty(AUTO_TYPE, 0);
4935 EXPECT_EQ(session->AddInput(input), 0);
4936 EXPECT_EQ(session->AddOutput(preview), 0);
4937
4938 EXPECT_EQ(session->CommitConfig(), 0);
4939 session->SetBeauty(AUTO_TYPE, 0);
4940
4941 EXPECT_EQ(session->CalculateExposureValue(100.0), 2147483647);
4942
4943 session->LockForControl();
4944 session->SetBeauty(AUTO_TYPE, 0);
4945 session->SetFilter(NONE);
4946 session->UnlockForControl();
4947
4948 EXPECT_EQ(preview->Release(), 0);
4949 EXPECT_EQ(input->Release(), 0);
4950 EXPECT_EQ(session->Release(), 0);
4951 }
4952
4953 /*
4954 * Feature: Framework
4955 * Function: Test innerInputDevice_ in GetColorEffect,
4956 * EnableMacro, IsMacroSupported,
4957 * SetColorEffect, ProcessMacroStatusChange
4958 * FunctionPoints: NA
4959 * EnvConditions: NA
4960 * CaseDescription: Test innerInputDevice_ in GetColorEffect,
4961 * EnableMacro, IsMacroSupported,
4962 * SetColorEffect, ProcessMacroStatusChange
4963 */
4964 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_044, TestSize.Level0)
4965 {
4966 InSequence s;
4967 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
4968 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
4969 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
4970 ASSERT_NE(input, nullptr);
4971
4972 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
4973 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
4974 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
4975 std::string cameraSettings = camInput->GetCameraSettings();
4976 camInput->SetCameraSettings(cameraSettings);
4977 camInput->GetCameraDevice()->Open();
4978
4979 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
4980 ASSERT_NE(session, nullptr);
4981 sptr<CaptureOutput> preview = CreatePreviewOutput();
4982 ASSERT_NE(preview, nullptr);
4983 auto macroStatusCallback = std::make_shared<AppMacroStatusCallback>();
4984 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = cameras[0]->GetMetadata();
4985
4986 EXPECT_EQ(session->GetColorEffect(), COLOR_EFFECT_NORMAL);
4987 EXPECT_EQ(session->EnableMacro(true), OPERATION_NOT_ALLOWED);
4988
4989 EXPECT_EQ(session->BeginConfig(), 0);
4990
4991 EXPECT_EQ(session->AddInput(input), 0);
4992 EXPECT_EQ(session->AddOutput(preview), 0);
4993
4994 EXPECT_EQ(session->CommitConfig(), 0);
4995 EXPECT_EQ(session->GetColorEffect(), COLOR_EFFECT_NORMAL);
4996
4997 ((sptr<CameraInput>&)(session->innerInputDevice_))->cameraObj_ = nullptr;
4998 EXPECT_EQ(session->GetColorEffect(), COLOR_EFFECT_NORMAL);
4999 EXPECT_EQ(session->IsMacroSupported(), false);
5000 session->innerInputDevice_ = nullptr;
5001 EXPECT_EQ(session->GetColorEffect(), COLOR_EFFECT_NORMAL);
5002 EXPECT_EQ(session->IsMacroSupported(), false);
5003 EXPECT_EQ(session->EnableMacro(true), OPERATION_NOT_ALLOWED);
5004
5005 session->LockForControl();
5006 session->SetColorEffect(COLOR_EFFECT_NORMAL);
5007 session->UnlockForControl();
5008
5009 session->macroStatusCallback_ = macroStatusCallback;
5010 session->ProcessMacroStatusChange(metadata);
5011
5012 EXPECT_EQ(preview->Release(), 0);
5013 EXPECT_EQ(input->Release(), 0);
5014 EXPECT_EQ(session->Release(), 0);
5015 }
5016
5017 /*
5018 * Feature: Framework
5019 * Function: Test HCameraService in UpdateSkinSmoothSetting,
5020 * UpdateFaceSlenderSetting, UpdateSkinToneSetting
5021 * SubFunction: NA
5022 * FunctionPoints: NA
5023 * EnvConditions: NA
5024 * CaseDescription: Test HCameraService in UpdateSkinSmoothSetting,
5025 * UpdateFaceSlenderSetting, UpdateSkinToneSetting
5026 */
5027 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_045, TestSize.Level0)
5028 {
5029 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5030 auto hCameraService = new HCameraService(0, true);
5031 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = cameras[0]->GetMetadata();
5032
5033 EXPECT_EQ(hCameraService->UpdateSkinSmoothSetting(metadata, 0), CAMERA_OK);
5034 EXPECT_EQ(hCameraService->UpdateSkinSmoothSetting(metadata, 1), CAMERA_OK);
5035 EXPECT_EQ(hCameraService->UpdateSkinSmoothSetting(nullptr, 1), CAMERA_OK);
5036 EXPECT_EQ(hCameraService->UpdateFaceSlenderSetting(metadata, 0), CAMERA_OK);
5037 EXPECT_EQ(hCameraService->UpdateFaceSlenderSetting(metadata, 1), CAMERA_OK);
5038 EXPECT_EQ(hCameraService->UpdateFaceSlenderSetting(nullptr, 1), CAMERA_OK);
5039 EXPECT_EQ(hCameraService->UpdateSkinToneSetting(metadata, 0), CAMERA_OK);
5040 EXPECT_EQ(hCameraService->UpdateSkinToneSetting(metadata, 1), CAMERA_OK);
5041 EXPECT_EQ(hCameraService->UpdateSkinToneSetting(nullptr, 1), CAMERA_OK);
5042 }
5043
5044 /*
5045 * Feature: Framework
5046 * Function: Test !IsSessionConfiged() || input == nullptr in CanAddInput
5047 * SubFunction: NA
5048 * FunctionPoints: NA
5049 * EnvConditions: NA
5050 * CaseDescription: Test !IsSessionConfiged() || input == nullptr in CanAddInput
5051 */
5052 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_046, TestSize.Level0)
5053 {
5054 InSequence s;
5055 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5056 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
5057 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
5058 sptr<CaptureInput> input1 = nullptr;
5059 ASSERT_NE(input, nullptr);
5060
5061 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
5062 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
5063 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
5064 std::string cameraSettings = camInput->GetCameraSettings();
5065 camInput->SetCameraSettings(cameraSettings);
5066 camInput->GetCameraDevice()->Open();
5067
5068 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
5069 ASSERT_NE(session, nullptr);
5070 sptr<CaptureOutput> preview = CreatePreviewOutput();
5071 ASSERT_NE(preview, nullptr);
5072
5073 EXPECT_EQ(session->CanAddInput(input), false);
5074 EXPECT_EQ(session->BeginConfig(), 0);
5075 EXPECT_EQ(session->CanAddInput(input), true);
5076 EXPECT_EQ(session->CanAddInput(input1), false);
5077 session->innerCaptureSession_ = nullptr;
5078 EXPECT_EQ(session->CanAddInput(input), false);
5079
5080 EXPECT_EQ(session->AddInput(input), OPERATION_NOT_ALLOWED);
5081 EXPECT_EQ(session->AddOutput(preview), OPERATION_NOT_ALLOWED);
5082
5083 EXPECT_EQ(session->CommitConfig(), OPERATION_NOT_ALLOWED);
5084
5085 EXPECT_EQ(session->RemoveOutput(preview), OPERATION_NOT_ALLOWED);
5086 EXPECT_EQ(session->RemoveInput(input), OPERATION_NOT_ALLOWED);
5087 EXPECT_EQ(preview->Release(), 0);
5088 EXPECT_EQ(input->Release(), 0);
5089 }
5090
5091 /*
5092 * Feature: Framework
5093 * Function: Test !IsSessionConfiged() || output == nullptr in CanAddOutput
5094 * SubFunction: NA
5095 * FunctionPoints: NA
5096 * EnvConditions: NA
5097 * CaseDescription: Test !IsSessionConfiged() || output == nullptr in CanAddOutput
5098 */
5099 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_047, TestSize.Level0)
5100 {
5101 InSequence s;
5102 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5103 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
5104 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
5105
5106 ASSERT_NE(input, nullptr);
5107
5108 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
5109 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
5110 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
5111 std::string cameraSettings = camInput->GetCameraSettings();
5112 camInput->SetCameraSettings(cameraSettings);
5113 camInput->GetCameraDevice()->Open();
5114
5115 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
5116 ASSERT_NE(session, nullptr);
5117 sptr<CaptureOutput> preview = CreatePreviewOutput();
5118 sptr<CaptureOutput> output = nullptr;
5119 ASSERT_NE(preview, nullptr);
5120
5121 EXPECT_EQ(session->CanAddOutput(preview), false);
5122 EXPECT_EQ(session->BeginConfig(), 0);
5123 EXPECT_EQ(session->CanAddOutput(output), false);
5124 preview->Release();
5125 EXPECT_EQ(session->CanAddOutput(preview), false);
5126
5127 EXPECT_EQ(input->Close(), 0);
5128 }
5129
5130 /*
5131 * Feature: Framework
5132 * Function: Test VerifyAbility, SetBeauty
5133 * SubFunction: NA
5134 * FunctionPoints: NA
5135 * EnvConditions: NA
5136 * CaseDescription: Test VerifyAbility, SetBeauty
5137 */
5138 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_048, TestSize.Level0)
5139 {
5140 InSequence s;
5141 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5142 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
5143 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
5144 ASSERT_NE(input, nullptr);
5145
5146 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
5147 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
5148 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
5149 std::string cameraSettings = camInput->GetCameraSettings();
5150 camInput->SetCameraSettings(cameraSettings);
5151 camInput->GetCameraDevice()->Open();
5152
5153 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
5154 ASSERT_NE(session, nullptr);
5155 sptr<CaptureOutput> preview = CreatePreviewOutput();
5156 ASSERT_NE(preview, nullptr);
5157
5158 EXPECT_EQ(session->BeginConfig(), 0);
5159
5160 EXPECT_EQ(session->AddInput(input), 0);
5161 EXPECT_EQ(session->AddOutput(preview), 0);
5162
5163 EXPECT_EQ(session->VerifyAbility(static_cast<uint32_t>(OHOS_ABILITY_SCENE_FILTER_TYPES)), CAMERA_INVALID_ARG);
5164 session->LockForControl();
5165 session->SetBeauty(FACE_SLENDER, 3);
5166 session->UnlockForControl();
5167
5168 EXPECT_EQ(session->CommitConfig(), 0);
5169
5170 EXPECT_EQ(preview->Release(), 0);
5171 EXPECT_EQ(input->Release(), 0);
5172 EXPECT_EQ(session->Release(), 0);
5173 }
5174
5175 /*
5176 * Feature: Framework
5177 * Function: Test !IsSessionCommited() && !IsSessionConfiged() in
5178 * AttachSketchSurface, CreateSketchWrapper，
5179 * GetSketchRatio, GetDeviceMetadata, OnSketchStatusChanged, StartSketch, StopSketch
5180 * SubFunction: NA
5181 * FunctionPoints: NA
5182 * EnvConditions: NA
5183 * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged()
5184 * in AttachSketchSurface, CreateSketchWrapper， GetSketchRatio,
5185 * GetDeviceMetadata, OnSketchStatusChanged, StartSketch, StopSketch
5186 */
5187 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_049, TestSize.Level0)
5188 {
5189 InSequence s;
5190 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5191 Size previewSize = {.width = 1440, .height = 1080};
5192
5193 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
5194 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
5195 ASSERT_NE(input, nullptr);
5196
5197 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
5198 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
5199 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
5200 std::string cameraSettings = camInput->GetCameraSettings();
5201 camInput->SetCameraSettings(cameraSettings);
5202 camInput->GetCameraDevice()->Open();
5203
5204 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
5205 ASSERT_NE(session, nullptr);
5206 sptr<CaptureOutput> preview = CreatePreviewOutput();
5207 ASSERT_NE(preview, nullptr);
5208 auto previewOutput = (sptr<PreviewOutput>&)preview;
5209
5210 EXPECT_EQ(session->BeginConfig(), 0);
5211 EXPECT_EQ(session->AddInput(input), 0);
5212 EXPECT_EQ(session->AddOutput(preview), 0);
5213
5214 previewOutput->SetSession(session);
5215 EXPECT_EQ(previewOutput->AttachSketchSurface(surface), CameraErrorCode::SESSION_NOT_CONFIG);
5216 EXPECT_EQ(previewOutput->CreateSketchWrapper(previewSize), 0);
5217 EXPECT_EQ(previewOutput->GetSketchRatio(), -1.0);
5218 EXPECT_NE(previewOutput->GetDeviceMetadata(), nullptr);
5219 previewOutput->FindSketchSize();
5220 previewOutput->OnSketchStatusChanged(SketchStatus::STOPED);
5221 EXPECT_EQ(previewOutput->StartSketch(), SESSION_NOT_CONFIG);
5222 EXPECT_EQ(previewOutput->StopSketch(), SESSION_NOT_CONFIG);
5223
5224 EXPECT_EQ(session->CommitConfig(), 0);
5225 EXPECT_EQ(previewOutput->StartSketch(), SERVICE_FATL_ERROR);
5226 EXPECT_EQ(previewOutput->StopSketch(), SERVICE_FATL_ERROR);
5227
5228 previewOutput->sketchWrapper_ = std::make_shared<SketchWrapper>(previewOutput->GetStream(), previewSize);
5229 EXPECT_EQ(previewOutput->StartSketch(), SERVICE_FATL_ERROR);
5230 EXPECT_EQ(previewOutput->StopSketch(), SERVICE_FATL_ERROR);
5231 EXPECT_EQ(previewOutput->AttachSketchSurface(surface), SERVICE_FATL_ERROR); // Need EnableSketch
5232
5233 EXPECT_EQ(session->RemoveOutput(preview), OPERATION_NOT_ALLOWED);
5234 EXPECT_EQ(session->RemoveInput(input), OPERATION_NOT_ALLOWED);
5235 EXPECT_EQ(preview->Release(), 0);
5236 EXPECT_EQ(input->Release(), 0);
5237 EXPECT_EQ(session->Release(), 0);
5238 }
5239
5240 /*
5241 * Feature: Framework
5242 * Function: Test !IsSessionCommited() && !IsSessionConfiged() in OnNativeRegisterCallback,
5243 * OnNativeUnregisterCallback, FindSketchSize
5244 * SubFunction: NA
5245 * FunctionPoints: NA
5246 * EnvConditions: NA
5247 * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged() in
5248 * OnNativeRegisterCallback, OnNativeUnregisterCallback, FindSketchSize
5249 */
5250 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_050, TestSize.Level0)
5251 {
5252 InSequence s;
5253 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5254 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
5255 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
5256 ASSERT_NE(input, nullptr);
5257
5258 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
5259 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
5260 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
5261 std::string cameraSettings = camInput->GetCameraSettings();
5262 camInput->SetCameraSettings(cameraSettings);
5263 camInput->GetCameraDevice()->Open();
5264
5265 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
5266 ASSERT_NE(session, nullptr);
5267 sptr<CaptureOutput> preview = CreatePreviewOutput();
5268 ASSERT_NE(preview, nullptr);
5269 auto previewOutput = (sptr<PreviewOutput>&)preview;
5270
5271 EXPECT_EQ(session->BeginConfig(), 0);
5272 EXPECT_EQ(session->AddInput(input), 0);
5273
5274 EXPECT_EQ(session->AddOutput(preview), 0);
5275
5276 previewOutput->SetSession(session);
5277 previewOutput->FindSketchSize();
5278
5279 std::string eventString = "test";
5280 previewOutput->OnNativeRegisterCallback(eventString);
5281 previewOutput->OnNativeUnregisterCallback(eventString);
5282 eventString = "sketchStatusChanged";
5283 previewOutput->OnNativeRegisterCallback(eventString);
5284 previewOutput->OnNativeUnregisterCallback(eventString);
5285
5286 EXPECT_EQ(session->CommitConfig(), 0);
5287
5288 eventString = "test";
5289 previewOutput->OnNativeRegisterCallback(eventString);
5290 previewOutput->OnNativeUnregisterCallback(eventString);
5291 eventString = "sketchStatusChanged";
5292 previewOutput->OnNativeRegisterCallback(eventString);
5293 previewOutput->OnNativeUnregisterCallback(eventString);
5294
5295 EXPECT_EQ(preview->Release(), 0);
5296 EXPECT_EQ(input->Release(), 0);
5297 EXPECT_EQ(session->Release(), 0);
5298 }
5299
5300 /*
5301 * Feature: Framework
5302 * Function: Test GetSketchReferenceFovRatio, UpdateSketchReferenceFovRatio
5303 * SubFunction: NA
5304 * FunctionPoints: NA
5305 * EnvConditions: NA
5306 * CaseDescription: Test GetSketchReferenceFovRatio, UpdateSketchReferenceFovRatio
5307 */
5308 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_051, TestSize.Level0)
5309 {
5310 InSequence s;
5311 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5312 Size previewSize = { .width = 1440, .height = 1080 };
5313 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
5314 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
5315 ASSERT_NE(input, nullptr);
5316
5317 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
5318 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
5319 sptr<CameraInput> camInput = (sptr<CameraInput>&)input;
5320 std::string cameraSettings = camInput->GetCameraSettings();
5321 camInput->SetCameraSettings(cameraSettings);
5322 camInput->GetCameraDevice()->Open();
5323
5324 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
5325 ASSERT_NE(session, nullptr);
5326
5327 std::shared_ptr<OHOS::Camera::CameraMetadata> deviceMetadata = cameras[0]->GetMetadata();
5328 ASSERT_NE(deviceMetadata, nullptr);
5329 session->GetFeaturesMode();
5330 CameraFormat previewFormat = CAMERA_FORMAT_YCBCR_420_888;
5331 Profile previewProfile = Profile(previewFormat, previewSize);
5332 sptr<CaptureOutput> preview = cameraManager->CreatePreviewOutput(previewProfile, surface);
5333 ASSERT_NE(preview, nullptr);
5334 auto previewOutput = (sptr<PreviewOutput>&)preview;
5335
5336 SketchWrapper* sketchWrapper = new (std::nothrow) SketchWrapper(previewOutput->GetStream(), previewSize);
5337 ASSERT_NE(sketchWrapper, nullptr);
5338 std::shared_ptr<PreviewStateCallback> setCallback =
5339 std::make_shared<TestPreviewOutputCallback>("PreviewStateCallback");
5340 ASSERT_NE(setCallback, nullptr);
5341 camera_metadata_item_t item;
5342 OHOS::Camera::FindCameraMetadataItem(deviceMetadata->get(), OHOS_CONTROL_ZOOM_RATIO, &item);
5343
5344 auto sketchReferenceFovRangeVec = std::vector<SketchReferenceFovRange>(5);
5345 SketchReferenceFovRange sketchReferenceFovRange = { .zoomMin = -1.0f, .zoomMax = -1.0f, .referenceValue = -1.0f };
5346 sketchReferenceFovRangeVec[0] = sketchReferenceFovRange;
5347 sketchReferenceFovRange = { .zoomMin = -1.0f, .zoomMax = 100.0f, .referenceValue = -1.0f };
5348 SceneFeaturesMode illegalFeaturesMode(static_cast<SceneMode>(-1), {});
5349 SketchWrapper::g_sketchReferenceFovRatioMap_[illegalFeaturesMode] = sketchReferenceFovRangeVec;
5350 EXPECT_EQ(sketchWrapper->GetSketchReferenceFovRatio(illegalFeaturesMode, -1.0f), -1.0f);
5351 sketchReferenceFovRangeVec[1] = sketchReferenceFovRange;
5352 sketchReferenceFovRange = { .zoomMin = 100.0f, .zoomMax = 1.0f, .referenceValue = -1.0f };
5353 sketchReferenceFovRangeVec[2] = sketchReferenceFovRange;
5354 sketchReferenceFovRange = { .zoomMin = 100.0f, .zoomMax = 100.0f, .referenceValue = -1.0f };
5355 sketchReferenceFovRangeVec[3] = sketchReferenceFovRange;
5356 sketchReferenceFovRange = { .zoomMin = 100.0f, .zoomMax = 200.0f, .referenceValue = -1.0f };
5357 sketchReferenceFovRangeVec[4] = sketchReferenceFovRange;
5358
5359 SceneFeaturesMode illegalFeaturesMode2(static_cast<SceneMode>(100), {});
5360 SketchWrapper::g_sketchReferenceFovRatioMap_[illegalFeaturesMode2] = sketchReferenceFovRangeVec;
5361 EXPECT_EQ(sketchWrapper->GetSketchReferenceFovRatio(illegalFeaturesMode2, -1.0f), -1.0f);
5362 EXPECT_EQ(sketchWrapper->GetSketchReferenceFovRatio(illegalFeaturesMode2, 200.0f), -1.0f);
5363 EXPECT_EQ(sketchWrapper->GetSketchReferenceFovRatio(illegalFeaturesMode2, 100.0f), -1.0f);
5364 sketchWrapper->UpdateSketchReferenceFovRatio(item);
5365
5366 EXPECT_EQ(preview->Release(), 0);
5367 EXPECT_EQ(input->Release(), 0);
5368 EXPECT_EQ(session->Release(), 0);
5369 }
5370
5371 /*
5372 * Feature: Framework
5373 * Function: Test cameramanager with updatetorchmode
5374 * SubFunction: NA
5375 * FunctionPoints: NA
5376 * EnvConditions: NA
5377 * CaseDescription: Test cameramanager with updatetorchmode
5378 */
5379 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_052, TestSize.Level0)
5380 {
5381 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5382 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], 0);
5383
5384 SceneMode mode = PORTRAIT;
5385 cameraManager->SetServiceProxy(nullptr);
5386 cameraManager->CreateCaptureSession(mode);
5387 cameraManager->ClearCameraDeviceListCache();
5388
5389 TorchMode mode1 = TorchMode::TORCH_MODE_OFF;
5390 TorchMode mode2 = TorchMode::TORCH_MODE_ON;
5391 cameraManager->torchMode_ = mode1;
5392 cameraManager->UpdateTorchMode(mode1);
5393 cameraManager->UpdateTorchMode(mode2);
5394 }
5395
5396 /*
5397 * Feature: Framework
5398 * Function: Test cameramanager with parsebasiccapability
5399 * SubFunction: NA
5400 * FunctionPoints: NA
5401 * EnvConditions: NA
5402 * CaseDescription: Test cameramanager with parsebasiccapability
5403 */
5404 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_053, TestSize.Level0)
5405 {
5406 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5407 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], 0);
5408
5409 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = cameras[0]->GetMetadata();
5410 camera_metadata_item_t item;
5411 OHOS::Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &item);
5412 CameraManager::ProfilesWrapper wrapper = {};
5413 cameraManager->ParseBasicCapability(wrapper, metadata, item);
5414 }
5415
5416 /*
5417 * Feature: Framework
5418 * Function: Test cameramanager with no cameraid and cameraobjlist
5419 * SubFunction: NA
5420 * FunctionPoints: NA
5421 * EnvConditions: NA
5422 * CaseDescription: Test cameramanager with no cameraid and cameraobjlist
5423 */
5424 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_054, TestSize.Level0)
5425 {
5426 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5427 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], 0);
5428
5429 pid_t pid = 0;
5430 cameraManager->CameraServerDied(pid);
5431 sptr<ICameraServiceCallback> cameraServiceCallback = nullptr;
5432 cameraManager->SetCameraServiceCallback(cameraServiceCallback);
5433 sptr<ITorchServiceCallback> torchServiceCallback = nullptr;
5434 cameraManager->SetTorchServiceCallback(torchServiceCallback);
5435 sptr<ICameraMuteServiceCallback> cameraMuteServiceCallback = nullptr;
5436 cameraManager->SetCameraMuteServiceCallback(cameraMuteServiceCallback);
5437 float level = 9.2;
5438 int32_t ret = cameraManager->SetTorchLevel(level);
5439 EXPECT_EQ(ret, 7400201);
5440 string cameraId = "";
5441 int activeTime = 0;
5442 EffectParam effectParam = {0, 0, 0};
5443 ret = cameraManager->SetPrelaunchConfig(cameraId, RestoreParamTypeOhos::TRANSIENT_ACTIVE_PARAM_OHOS,
5444 activeTime, effectParam);
5445 EXPECT_EQ(ret, 7400201);
5446 cameraManager->cameraDeviceList_ = {};
5447 bool isTorchSupported = cameraManager->IsTorchSupported();
5448 EXPECT_EQ(isTorchSupported, false);
5449 }
5450
5451 /*
5452 * Feature: Framework
5453 * Function: Test cameramanager with serviceProxy_ is nullptr
5454 * SubFunction: NA
5455 * FunctionPoints: NA
5456 * EnvConditions: NA
5457 * CaseDescription: Test cameramanager with serviceProxy_ is nullptr
5458 */
5459 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_055, TestSize.Level0)
5460 {
5461 sptr<ICameraServiceCallback> callback = new(std::nothrow) CameraStatusServiceCallback(cameraManager);
5462 ASSERT_NE(callback, nullptr);
5463 cameraManager->cameraSvcCallback_ = callback;
5464
5465 pid_t pid = 0;
5466 cameraManager->SetServiceProxy(nullptr);
5467 cameraManager->CameraServerDied(pid);
5468 sptr<ICameraServiceCallback> cameraServiceCallback = nullptr;
5469 cameraManager->SetCameraServiceCallback(cameraServiceCallback);
5470 sptr<ITorchServiceCallback> torchServiceCallback = nullptr;
5471 cameraManager->SetTorchServiceCallback(torchServiceCallback);
5472 sptr<ICameraMuteServiceCallback> cameraMuteServiceCallback = nullptr;
5473 cameraManager->SetCameraMuteServiceCallback(cameraMuteServiceCallback);
5474
5475 cameraManager->cameraDeviceList_ = {};
5476 string cameraId = "";
5477 cameraManager->GetCameraDeviceFromId(cameraId);
5478 bool isTorchSupported = cameraManager->IsTorchSupported();
5479 EXPECT_EQ(isTorchSupported, false);
5480 }
5481
5482 /*
5483 * Feature: Framework
5484 * Function: Test cameramanager with preswitchcamera
5485 * SubFunction: NA
5486 * FunctionPoints: NA
5487 * EnvConditions: NA
5488 * CaseDescription: Test cameramanager with preswitchcamera
5489 */
5490 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_056, TestSize.Level0)
5491 {
5492 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5493 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], 0);
5494
5495 std::string cameraId = cameras[0]->GetID();
5496 int32_t ret = cameraManager->PreSwitchCamera(cameraId);
5497 EXPECT_EQ(ret, 7400201);
5498
5499 cameraManager->SetServiceProxy(nullptr);
5500 cameraManager->PreSwitchCamera(cameraId);
5501 EXPECT_EQ(ret, 7400201);
5502 }
5503
5504 /*
5505 * Feature: Framework
5506 * Function: Test cameradevice with position and zoomratiorange
5507 * SubFunction: NA
5508 * FunctionPoints: NA
5509 * EnvConditions: NA
5510 * CaseDescription: Test cameradevice with position and zoomratiorange
5511 */
5512 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_057, TestSize.Level0)
5513 {
5514 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5515
5516 cameras[0]->foldScreenType_ = CAMERA_FOLDSCREEN_INNER;
5517 cameras[0]->cameraPosition_ = CAMERA_POSITION_FRONT;
5518 cameras[0]->GetPosition();
5519
5520 cameras[0]->zoomRatioRange_ = {1.1, 2.1};
5521 EXPECT_EQ(cameras[0]->GetZoomRatioRange(), cameras[0]->zoomRatioRange_);
5522 }
5523
5524 /*
5525 * Feature: Framework
5526 * Function: Test camerainput with cameraserverdied
5527 * SubFunction: NA
5528 * FunctionPoints: NA
5529 * EnvConditions: NA
5530 * CaseDescription: Test camerainput with cameraserverdied
5531 */
5532 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_058, TestSize.Level0)
5533 {
5534 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5535 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
5536 ASSERT_NE(input, nullptr);
5537 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
5538
5539 pid_t pid = 0;
5540 camInput->CameraServerDied(pid);
5541 }
5542
5543 /*
5544 * Feature: Framework
5545 * Function: Test camerainput with deviceObj_ is nullptr
5546 * SubFunction: NA
5547 * FunctionPoints: NA
5548 * EnvConditions: NA
5549 * CaseDescription: Test camerainput with deviceObj_ is nullptr
5550 */
5551 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_059, TestSize.Level0)
5552 {
5553 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5554
5555 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
5556 ASSERT_NE(input, nullptr);
5557 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
5558
5559 pid_t pid = 0;
5560 std::shared_ptr<TestDeviceCallback> setCallback = std::make_shared<TestDeviceCallback>("InputCallback");
5561 camInput->deviceObj_ = nullptr;
5562 camInput->SetErrorCallback(setCallback);
5563 camInput->CameraServerDied(pid);
5564 }
5565
5566 /*
5567 * Feature: Framework
5568 * Function: Test metadataoutput with cameraserverdied and stop
5569 * SubFunction: NA
5570 * FunctionPoints: NA
5571 * EnvConditions: NA
5572 * CaseDescription: Test metadataoutput with cameraserverdied and stop
5573 */
5574 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_060, TestSize.Level0)
5575 {
5576 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5577 sptr<CaptureOutput> output = cameraManager->CreateMetadataOutput();
5578 ASSERT_NE(output, nullptr);
5579 sptr<MetadataOutput> metadatOutput = (sptr<MetadataOutput>&)output;
5580
5581 pid_t pid = 0;
5582 metadatOutput->CameraServerDied(pid);
5583 EXPECT_EQ(metadatOutput->Stop(), CameraErrorCode::SERVICE_FATL_ERROR);
5584 }
5585
5586 /*
5587 * Feature: Framework
5588 * Function: Test metadataoutput with stream_ is nullptr
5589 * SubFunction: NA
5590 * FunctionPoints: NA
5591 * EnvConditions: NA
5592 * CaseDescription: Test metadataoutput with stream_ is nullptr
5593 */
5594 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_061, TestSize.Level0)
5595 {
5596 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5597
5598 sptr<CaptureOutput> output = cameraManager->CreateMetadataOutput();
5599 ASSERT_NE(output, nullptr);
5600 sptr<MetadataOutput> metadatOutput = (sptr<MetadataOutput>&)output;
5601
5602 pid_t pid = 0;
5603 metadatOutput->stream_ = nullptr;
5604 metadatOutput->CameraServerDied(pid);
5605 EXPECT_EQ(metadatOutput->Stop(), CameraErrorCode::SERVICE_FATL_ERROR);
5606 EXPECT_EQ(metadatOutput->Release(), CameraErrorCode::SERVICE_FATL_ERROR);
5607 }
5608
5609 /*
5610 * Feature: Framework
5611 * Function: Test metadataoutput with surface_ is nullptr
5612 * SubFunction: NA
5613 * FunctionPoints: NA
5614 * EnvConditions: NA
5615 * CaseDescription: Test metadataoutput with surface_ is nullptr
5616 */
5617 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_062, TestSize.Level0)
5618 {
5619 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5620
5621 sptr<CaptureOutput> output = cameraManager->CreateMetadataOutput();
5622 ASSERT_NE(output, nullptr);
5623 sptr<MetadataOutput> metadatOutput = (sptr<MetadataOutput>&)output;
5624
5625 metadatOutput->surface_ = nullptr;
5626 EXPECT_EQ(metadatOutput->Release(), 0);
5627 }
5628
5629 /*
5630 * Feature: Framework
5631 * Function: Test metadataoutput with start when session_ is nullptr
5632 * SubFunction: NA
5633 * FunctionPoints: NA
5634 * EnvConditions: NA
5635 * CaseDescription: Test metadataoutput with start when session_ is nullptr
5636 */
5637 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_063, TestSize.Level0)
5638 {
5639 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5640
5641 sptr<CaptureOutput> metadata = cameraManager->CreateMetadataOutput();
5642 ASSERT_NE(metadata, nullptr);
5643 sptr<MetadataOutput> metadatOutput = (sptr<MetadataOutput>&)metadata;
5644
5645 metadatOutput->session_ = nullptr;
5646 EXPECT_EQ(metadatOutput->Start(), CameraErrorCode::SUCCESS);
5647 }
5648
5649 /*
5650 * Feature: Framework
5651 * Function: Test metadataoutput with start when not commit
5652 * SubFunction: NA
5653 * FunctionPoints: NA
5654 * EnvConditions: NA
5655 * CaseDescription: Test metadataoutput with start when not commit
5656 */
5657 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_064, TestSize.Level0)
5658 {
5659 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5660
5661 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
5662 ASSERT_NE(input, nullptr);
5663
5664 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
5665 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
5666 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
5667 std::string cameraSettings = camInput->GetCameraSettings();
5668 camInput->SetCameraSettings(cameraSettings);
5669 camInput->GetCameraDevice()->Open();
5670
5671 sptr<CaptureOutput> metadata = cameraManager->CreateMetadataOutput();
5672 ASSERT_NE(metadata, nullptr);
5673 sptr<MetadataOutput> metadatOutput = (sptr<MetadataOutput>&)metadata;
5674
5675 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
5676 ASSERT_NE(session, nullptr);
5677
5678 session->BeginConfig();
5679 session->AddInput(input);
5680 session->AddOutput(metadata);
5681
5682 EXPECT_EQ(metadatOutput->Start(), CameraErrorCode::SUCCESS);
5683
5684 session->CommitConfig();
5685 session->Start();
5686
5687 input->Close();
5688 }
5689
5690 /*
5691 * Feature: Framework
5692 * Function: Test metadataoutput with start when stream_ is nullptr
5693 * SubFunction: NA
5694 * FunctionPoints: NA
5695 * EnvConditions: NA
5696 * CaseDescription: Test metadataoutput with start when stream_ is nullptr
5697 */
5698 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_065, TestSize.Level0)
5699 {
5700 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5701
5702 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
5703 ASSERT_NE(input, nullptr);
5704 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
5705
5706 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
5707 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
5708 std::string cameraSettings = camInput->GetCameraSettings();
5709 camInput->SetCameraSettings(cameraSettings);
5710 camInput->GetCameraDevice()->Open();
5711
5712 sptr<CaptureOutput> metadata = cameraManager->CreateMetadataOutput();
5713 ASSERT_NE(metadata, nullptr);
5714 sptr<MetadataOutput> metadatOutput = (sptr<MetadataOutput>&)metadata;
5715
5716 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
5717 ASSERT_NE(session, nullptr);
5718
5719 session->BeginConfig();
5720
5721 session->AddInput(input);
5722 session->AddOutput(metadata);
5723
5724 session->CommitConfig();
5725 session->Start();
5726
5727 metadatOutput->stream_ = nullptr;
5728 EXPECT_EQ(metadatOutput->Start(), CameraErrorCode::SUCCESS);
5729
5730 input->Close();
5731 }
5732
5733 /*
5734 * Feature: Framework
5735 * Function: Test metadataoutput with start
5736 * SubFunction: NA
5737 * FunctionPoints: NA
5738 * EnvConditions: NA
5739 * CaseDescription: Test metadataoutput with start
5740 */
5741 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_066, TestSize.Level0)
5742 {
5743 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5744
5745 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
5746 ASSERT_NE(input, nullptr);
5747 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
5748
5749 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
5750 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
5751 std::string cameraSettings = camInput->GetCameraSettings();
5752 camInput->SetCameraSettings(cameraSettings);
5753 camInput->GetCameraDevice()->Open();
5754
5755 sptr<CaptureOutput> metadata = cameraManager->CreateMetadataOutput();
5756 ASSERT_NE(metadata, nullptr);
5757 sptr<MetadataOutput> metadatOutput = (sptr<MetadataOutput>&)metadata;
5758
5759 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
5760 ASSERT_NE(session, nullptr);
5761
5762 session->BeginConfig();
5763
5764 session->AddInput(input);
5765 session->AddOutput(metadata);
5766
5767 session->CommitConfig();
5768 session->Start();
5769
5770 EXPECT_EQ(metadatOutput->Start(), CameraErrorCode::SUCCESS);
5771 EXPECT_EQ(metadatOutput->Stop(), CameraErrorCode::SUCCESS);
5772 metadatOutput->Release();
5773
5774 input->Close();
5775 }
5776
5777 /*
5778 * Feature: Framework
5779 * Function: Test metadataoutput when destruction
5780 * SubFunction: NA
5781 * FunctionPoints: NA
5782 * EnvConditions: NA
5783 * CaseDescription: Test metadataoutput when destruction
5784 */
5785 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_067, TestSize.Level0)
5786 {
5787 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5788
5789 sptr<CaptureOutput> output = cameraManager->CreateMetadataOutput();
5790 ASSERT_NE(output, nullptr);
5791 sptr<MetadataOutput> metadatOutput = (sptr<MetadataOutput>&)output;
5792
5793 metadatOutput->Release();
5794 EXPECT_EQ(metadatOutput->Stop(), CameraErrorCode::SERVICE_FATL_ERROR);
5795 }
5796
5797 /*
5798 * Feature: Framework
5799 * Function: Test photooutput with cameraserverdied
5800 * SubFunction: NA
5801 * FunctionPoints: NA
5802 * EnvConditions: NA
5803 * CaseDescription: Test photooutput with cameraserverdied
5804 */
5805 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_068, TestSize.Level0)
5806 {
5807 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5808
5809 sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
5810 ASSERT_NE(photoOutput, nullptr);
5811
5812 pid_t pid = 0;
5813 photoOutput->CameraServerDied(pid);
5814 }
5815
5816 /*
5817 * Feature: Framework
5818 * Function: Test photooutput with cameraserverdied
5819 * SubFunction: NA
5820 * FunctionPoints: NA
5821 * EnvConditions: NA
5822 * CaseDescription: Test photooutput with cameraserverdied
5823 */
5824 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_069, TestSize.Level0)
5825 {
5826 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5827
5828 sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
5829 ASSERT_NE(photoOutput, nullptr);
5830
5831 pid_t pid = 0;
5832 std::shared_ptr<PhotoStateCallback> setCallback =
5833 std::make_shared<TestPhotoOutputCallback>("PhotoStateCallback");
5834 ((sptr<PhotoOutput>&)photoOutput)->SetCallback(setCallback);
5835 photoOutput->CameraServerDied(pid);
5836 }
5837
5838 /*
5839 * Feature: Framework
5840 * Function: Test photooutput with cameraserverdied when stream_ is nullptr
5841 * SubFunction: NA
5842 * FunctionPoints: NA
5843 * EnvConditions: NA
5844 * CaseDescription: Test photooutput with cameraserverdied when stream_ is nullptr
5845 */
5846 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_070, TestSize.Level0)
5847 {
5848 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5849
5850 sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
5851 ASSERT_NE(photoOutput, nullptr);
5852
5853 pid_t pid = 0;
5854 sptr<PhotoOutput> phtOutput = (sptr<PhotoOutput>&)photoOutput;
5855 phtOutput->stream_ = nullptr;
5856 photoOutput->CameraServerDied(pid);
5857 }
5858
5859 /*
5860 * Feature: Framework
5861 * Function: Test photooutput with confirmcapture when stream_ is nullptr
5862 * SubFunction: NA
5863 * FunctionPoints: NA
5864 * EnvConditions: NA
5865 * CaseDescription: Test photooutput with confirmcapture when stream_ is nullptr
5866 */
5867 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_071, TestSize.Level0)
5868 {
5869 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5870 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
5871 ASSERT_NE(input, nullptr);
5872
5873 sptr<CaptureOutput> photoOutput = CreatePhotoOutput();
5874 ASSERT_NE(photoOutput, nullptr);
5875 sptr<PhotoOutput> phtOutput = (sptr<PhotoOutput>&)photoOutput;
5876
5877 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
5878 ASSERT_NE(session, nullptr);
5879
5880 int32_t ret = session->BeginConfig();
5881 EXPECT_EQ(ret, 0);
5882
5883 ret = session->AddOutput(photoOutput);
5884 session->CommitConfig();
5885
5886 phtOutput->stream_ = nullptr;
5887 EXPECT_EQ(phtOutput->ConfirmCapture(), CameraErrorCode::SESSION_NOT_RUNNING);
5888
5889 phtOutput->Release();
5890 EXPECT_EQ(phtOutput->ConfirmCapture(), CameraErrorCode::SESSION_NOT_RUNNING);
5891
5892 session->Release();
5893 }
5894
5895 /*
5896 * Feature: Framework
5897 * Function: Test previewoutput
5898 * SubFunction: NA
5899 * FunctionPoints: NA
5900 * EnvConditions: NA
5901 * CaseDescription: Test previewoutput
5902 */
5903 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_072, TestSize.Level0)
5904 {
5905 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5906
5907 sptr<CaptureOutput> preview = CreatePreviewOutput();
5908 ASSERT_NE(preview, nullptr);
5909
5910 auto previewOutput = (sptr<PreviewOutput>&)preview;
5911 previewOutput->stream_ = nullptr;
5912 previewOutput->session_ = nullptr;
5913
5914 EXPECT_EQ(previewOutput->OnSketchStatusChanged(SketchStatus::STOPED), CAMERA_INVALID_STATE);
5915 EXPECT_EQ(previewOutput->IsSketchSupported(), false);
5916
5917 Size previewSize = {};
5918 previewOutput->stream_ = nullptr;
5919 EXPECT_EQ(previewOutput->CreateSketchWrapper(previewSize), CameraErrorCode::SERVICE_FATL_ERROR);
5920 }
5921
5922 /*
5923 * Feature: Framework
5924 * Function: Test previewoutput with callback and cameraserverdied
5925 * SubFunction: NA
5926 * FunctionPoints: NA
5927 * EnvConditions: NA
5928 * CaseDescription: Test previewoutput with callback and cameraserverdied
5929 */
5930 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_073, TestSize.Level0)
5931 {
5932 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5933
5934 sptr<CaptureOutput> preview = CreatePreviewOutput();
5935 ASSERT_NE(preview, nullptr);
5936
5937 auto previewOutput = (sptr<PreviewOutput>&)preview;
5938
5939 std::string eventString = "sketchStatusChanged";
5940 previewOutput->sketchWrapper_ = nullptr;
5941 previewOutput->OnNativeRegisterCallback(eventString);
5942 previewOutput->OnNativeUnregisterCallback(eventString);
5943
5944 pid_t pid = 0;
5945 previewOutput->stream_ = nullptr;
5946 previewOutput->CameraServerDied(pid);
5947 }
5948
5949 /*
5950 * Feature: Framework
5951 * Function: Test sketchwrapper
5952 * SubFunction: NA
5953 * FunctionPoints: NA
5954 * EnvConditions: NA
5955 * CaseDescription: Test sketchwrapper
5956 */
5957 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_074, TestSize.Level0)
5958 {
5959 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
5960
5961 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
5962 ASSERT_NE(input, nullptr);
5963 sptr<CameraInput> cameraInput = (sptr<CameraInput>&)input;
5964
5965 std::shared_ptr<OHOS::Camera::CameraMetadata> deviceMetadata = cameraInput->GetCameraDeviceInfo()->GetMetadata();
5966 ASSERT_NE(deviceMetadata, nullptr);
5967
5968 int32_t width = 1440;
5969 int32_t height = 1080;
5970 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
5971 Size previewSize;
5972 previewSize.width = width;
5973 previewSize.height = height;
5974 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
5975 Profile previewProfile = Profile(previewFormat, previewSize);
5976 sptr<CaptureOutput> previewOutput = cameraManager->CreatePreviewOutput(previewProfile, surface);
5977 ASSERT_NE(previewOutput, nullptr);
5978
5979 Size sketchSize;
5980 sketchSize.width = 640;
5981 sketchSize.height = 480;
5982
5983 SketchWrapper* sketchWrapper = new (std::nothrow) SketchWrapper(previewOutput->GetStream(), sketchSize);
5984 ASSERT_NE(sketchWrapper, nullptr);
5985 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
5986 ASSERT_NE(session, nullptr);
5987 auto modeName = session->GetFeaturesMode();
5988 int ret = sketchWrapper->Init(deviceMetadata, modeName);
5989 EXPECT_EQ(ret, CAMERA_OK);
5990
5991 sketchWrapper->sketchStream_ = nullptr;
5992 ret = sketchWrapper->AttachSketchSurface(nullptr);
5993 EXPECT_EQ(ret, CAMERA_INVALID_STATE);
5994 EXPECT_EQ(sketchWrapper->StartSketchStream(), CAMERA_UNKNOWN_ERROR);
5995
5996 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata;
5997 sketchWrapper->UpdateSketchEnableRatio(metadata);
5998 sketchWrapper->UpdateSketchReferenceFovRatio(metadata);
5999 sketchWrapper->UpdateSketchConfigFromMoonCaptureBoostConfig(metadata);
6000 }
6001
6002 /*
6003 * Feature: Framework
6004 * Function: Test sketchwrapper
6005 * SubFunction: NA
6006 * FunctionPoints: NA
6007 * EnvConditions: NA
6008 * CaseDescription: Test sketchwrapper
6009 */
6010 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_075, TestSize.Level0)
6011 {
6012 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6013
6014 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
6015 ASSERT_NE(input, nullptr);
6016 sptr<CameraInput> cameraInput = (sptr<CameraInput>&)input;
6017
6018 std::shared_ptr<OHOS::Camera::CameraMetadata> deviceMetadata =
6019 cameraInput->GetCameraDeviceInfo()->GetMetadata();
6020 ASSERT_NE(deviceMetadata, nullptr);
6021
6022 int32_t width = 1440;
6023 int32_t height = 1080;
6024 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
6025 Size previewSize;
6026 previewSize.width = width;
6027 previewSize.height = height;
6028 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
6029 Profile previewProfile = Profile(previewFormat, previewSize);
6030 sptr<CaptureOutput> previewOutput =
6031 cameraManager->CreatePreviewOutput(previewProfile, surface);
6032 ASSERT_NE(previewOutput, nullptr);
6033
6034 Size sketchSize;
6035 sketchSize.width = 640;
6036 sketchSize.height = 480;
6037
6038 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
6039 ASSERT_NE(session, nullptr);
6040 SketchWrapper *sketchWrapper = new (std::nothrow)
6041 SketchWrapper(previewOutput->GetStream(), sketchSize);
6042 ASSERT_NE(sketchWrapper, nullptr);
6043
6044 auto modeName = session->GetFeaturesMode();
6045 int ret = sketchWrapper->Init(deviceMetadata, modeName);
6046 EXPECT_EQ(ret, CAMERA_OK);
6047
6048 float sketchRatio = sketchWrapper->GetSketchEnableRatio(session->GetFeaturesMode());
6049 EXPECT_EQ(sketchRatio, -1.0);
6050 sketchWrapper->hostStream_ = nullptr;
6051 EXPECT_EQ(sketchWrapper->UpdateSketchRatio(sketchRatio), CAMERA_INVALID_STATE);
6052 EXPECT_EQ(sketchWrapper->Destroy(), CAMERA_INVALID_STATE);
6053 }
6054
6055 /*
6056 * Feature: Framework
6057 * Function: Test sketchwrapper with different tag
6058 * SubFunction: NA
6059 * FunctionPoints: NA
6060 * EnvConditions: NA
6061 * CaseDescription: Test sketchwrapper with different tag
6062 */
6063 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_076, TestSize.Level0)
6064 {
6065 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6066
6067 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
6068 ASSERT_NE(input, nullptr);
6069 sptr<CameraInput> cameraInput = (sptr<CameraInput>&)input;
6070
6071 std::shared_ptr<OHOS::Camera::CameraMetadata> deviceMetadata =
6072 cameraInput->GetCameraDeviceInfo()->GetMetadata();
6073 ASSERT_NE(deviceMetadata, nullptr);
6074
6075 int32_t width = 1440;
6076 int32_t height = 1080;
6077 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
6078 Size previewSize;
6079 previewSize.width = width;
6080 previewSize.height = height;
6081 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
6082 Profile previewProfile = Profile(previewFormat, previewSize);
6083 sptr<CaptureOutput> previewOutput = cameraManager->CreatePreviewOutput(previewProfile, surface);
6084 ASSERT_NE(previewOutput, nullptr);
6085
6086 Size sketchSize;
6087 sketchSize.width = 640;
6088 sketchSize.height = 480;
6089
6090 sptr<CaptureSession> session = cameraManager->CreateCaptureSession();
6091 ASSERT_NE(session, nullptr);
6092 SketchWrapper *sketchWrapper = new (std::nothrow)
6093 SketchWrapper(previewOutput->GetStream(), sketchSize);
6094 ASSERT_NE(sketchWrapper, nullptr);
6095
6096 auto modeName = session->GetFeaturesMode();
6097 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = cameras[0]->GetMetadata();
6098 camera_metadata_item_t item;
6099 OHOS::Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &item);
6100 const camera_device_metadata_tag_t tag1 = OHOS_CONTROL_ZOOM_RATIO;
6101 EXPECT_EQ(sketchWrapper->OnMetadataDispatch(modeName, tag1, item), 0);
6102 const camera_device_metadata_tag_t tag2 = OHOS_CONTROL_CAMERA_MACRO;
6103 EXPECT_EQ(sketchWrapper->OnMetadataDispatch(modeName, tag2, item), CAM_META_SUCCESS);
6104 }
6105
6106 /*
6107 * Feature: Framework
6108 * Function: Test videooutput with cameraserverdied
6109 * SubFunction: NA
6110 * FunctionPoints: NA
6111 * EnvConditions: NA
6112 * CaseDescription: Test videooutput with cameraserverdied
6113 */
6114 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_077, TestSize.Level0)
6115 {
6116 int32_t width = VIDEO_DEFAULT_WIDTH;
6117 int32_t height = VIDEO_DEFAULT_HEIGHT;
6118 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
6119 CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
6120 Size videoSize;
6121 videoSize.width = width;
6122 videoSize.height = height;
6123 std::vector<int32_t> videoFramerates = {30, 30};
6124 VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates);
6125 sptr<VideoOutput> video = cameraManager->CreateVideoOutput(videoProfile, surface);
6126 ASSERT_NE(video, nullptr);
6127
6128 pid_t pid = 0;
6129 video->CameraServerDied(pid);
6130 }
6131
6132 /*
6133 * Feature: Framework
6134 * Function: Test videooutput with cameraserverdied when stream_ is nullptr
6135 * SubFunction: NA
6136 * FunctionPoints: NA
6137 * EnvConditions: NA
6138 * CaseDescription: Test videooutput with cameraserverdied when stream_ is nullptr
6139 */
6140 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_078, TestSize.Level0)
6141 {
6142 int32_t width = VIDEO_DEFAULT_WIDTH;
6143 int32_t height = VIDEO_DEFAULT_HEIGHT;
6144 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
6145 CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
6146 Size videoSize;
6147 videoSize.width = width;
6148 videoSize.height = height;
6149 std::vector<int32_t> videoFramerates = {30, 30};
6150 VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates);
6151 sptr<VideoOutput> video = cameraManager->CreateVideoOutput(videoProfile, surface);
6152 ASSERT_NE(video, nullptr);
6153
6154 pid_t pid = 0;
6155 video->stream_ = nullptr;
6156 std::shared_ptr<VideoStateCallback> setCallback =
6157 std::make_shared<TestVideoOutputCallback>("VideoStateCallback");
6158 video->SetCallback(setCallback);
6159 video->CameraServerDied(pid);
6160 }
6161
6162 /*
6163 * Feature: Framework
6164 * Function: Test videooutput when destruction
6165 * SubFunction: NA
6166 * FunctionPoints: NA
6167 * EnvConditions: NA
6168 * CaseDescription: Test videooutput when destruction
6169 */
6170 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_079, TestSize.Level0)
6171 {
6172 int32_t width = VIDEO_DEFAULT_WIDTH;
6173 int32_t height = VIDEO_DEFAULT_HEIGHT;
6174 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer();
6175 CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
6176 Size videoSize;
6177 videoSize.width = width;
6178 videoSize.height = height;
6179 std::vector<int32_t> videoFramerates = {30, 30};
6180 VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates);
6181 sptr<VideoOutput> video = cameraManager->CreateVideoOutput(videoProfile, surface);
6182 ASSERT_NE(video, nullptr);
6183 }
6184
6185 /*
6186 * Feature: Framework
6187 * Function: Test HCameraDevice when settings is nullptr
6188 * SubFunction: NA
6189 * FunctionPoints: NA
6190 * EnvConditions: NA
6191 * CaseDescription: Test HCameraDevice when settings is nullptr
6192 */
6193 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_080, TestSize.Level0)
6194 {
6195 std::vector<int32_t> result;
6196 result.push_back(OHOS_SENSOR_EXPOSURE_TIME);
6197 result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
6198
6199 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6200
6201 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
6202 std::string cameraId = cameras[0]->GetID();
6203 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6204 sptr<HCameraDevice> camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken);
6205 ASSERT_NE(camDevice, nullptr);
6206 std::shared_ptr<OHOS::Camera::CameraMetadata> settings;
6207 EXPECT_EQ(camDevice->UpdateSettingOnce(settings), CAMERA_INVALID_ARG);
6208 }
6209
6210 /*
6211 * Feature: Framework
6212 * Function: Test HCameraDevice
6213 * SubFunction: NA
6214 * FunctionPoints: NA
6215 * EnvConditions: NA
6216 * CaseDescription: Test HCameraDevice
6217 */
6218 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_081, TestSize.Level0)
6219 {
6220 std::vector<int32_t> result;
6221 result.push_back(OHOS_SENSOR_EXPOSURE_TIME);
6222 result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
6223
6224 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6225
6226 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
6227 std::string cameraId = cameras[0]->GetID();
6228 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6229 sptr<HCameraDevice> camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken);
6230 ASSERT_NE(camDevice, nullptr);
6231 std::shared_ptr<OHOS::Camera::CameraMetadata> settings = cameras[0]->GetMetadata();
6232 EXPECT_EQ(camDevice->UpdateSettingOnce(settings), 0);
6233
6234 camDevice->RegisterFoldStatusListener();
6235 camDevice->UnRegisterFoldStatusListener();
6236 }
6237
6238 /*
6239 * Feature: Framework
6240 * Function: Test HCameraDevice
6241 * SubFunction: NA
6242 * FunctionPoints: NA
6243 * EnvConditions: NA
6244 * CaseDescription: Test HCameraDevice
6245 */
6246 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_082, TestSize.Level0)
6247 {
6248 std::vector<int32_t> result;
6249 result.push_back(OHOS_SENSOR_EXPOSURE_TIME);
6250 result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
6251
6252 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6253
6254 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
6255 std::string cameraId = cameras[0]->GetID();
6256 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6257 sptr<HCameraDevice> camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken);
6258 ASSERT_NE(camDevice, nullptr);
6259
6260 camDevice->UnRegisterFoldStatusListener();
6261 camDevice->RegisterFoldStatusListener();
6262 camDevice->UnRegisterFoldStatusListener();
6263 camDevice->cameraHostManager_ = nullptr;
6264 camDevice->RegisterFoldStatusListener();
6265 camDevice->UnRegisterFoldStatusListener();
6266
6267 std::vector<int32_t> results = {};
6268 EXPECT_EQ(camDevice->EnableResult(results), CAMERA_INVALID_ARG);
6269 EXPECT_EQ(camDevice->DisableResult(results), CAMERA_INVALID_ARG);
6270
6271 std::shared_ptr<OHOS::Camera::CameraMetadata> metaIn;
6272 std::shared_ptr<OHOS::Camera::CameraMetadata> metaOut;
6273 EXPECT_EQ(camDevice->GetStatus(metaIn, metaOut), CAMERA_INVALID_ARG);
6274
6275 camDevice->Close();
6276 }
6277
6278 /*
6279 * Feature: Framework
6280 * Function: Test HCameraDevice when hdiCameraDevice_ is nullptr
6281 * SubFunction: NA
6282 * FunctionPoints: NA
6283 * EnvConditions: NA
6284 * CaseDescription: Test HCameraDevice when hdiCameraDevice_ is nullptr
6285 */
6286 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_083, TestSize.Level0)
6287 {
6288 std::vector<int32_t> result;
6289 result.push_back(OHOS_SENSOR_EXPOSURE_TIME);
6290 result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
6291
6292 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6293
6294 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
6295 std::string cameraId = cameras[0]->GetID();
6296 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6297 sptr<HCameraDevice> camDevice = new(std::nothrow)
6298 HCameraDevice(cameraHostManager, cameraId, callerToken);
6299 ASSERT_NE(camDevice, nullptr);
6300
6301 camDevice->hdiCameraDevice_ = nullptr;
6302 EXPECT_EQ(camDevice->InitStreamOperator(), CAMERA_UNKNOWN_ERROR);
6303 }
6304
6305 /*
6306 * Feature: Framework
6307 * Function: Test HCameraDevice when streamOperator_ is nullptr
6308 * SubFunction: NA
6309 * FunctionPoints: NA
6310 * EnvConditions: NA
6311 * CaseDescription: Test HCameraDevice when streamOperator_ is nullptr
6312 */
6313 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_084, TestSize.Level0)
6314 {
6315 std::vector<int32_t> result;
6316 result.push_back(OHOS_SENSOR_EXPOSURE_TIME);
6317 result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
6318
6319 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6320
6321 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
6322 std::string cameraId = cameras[0]->GetID();
6323 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6324 sptr<HCameraDevice> camDevice = new(std::nothrow)
6325 HCameraDevice(cameraHostManager, cameraId, callerToken);
6326 ASSERT_NE(camDevice, nullptr);
6327
6328 std::vector<HDI::Camera::V1_1::StreamInfo_V1_1> streamInfos = {};
6329 camDevice->CreateStreams(streamInfos);
6330
6331 std::shared_ptr<OHOS::Camera::CameraMetadata> deviceSettings = cameras[0]->GetMetadata();
6332 int32_t operationMode = 0;
6333 camDevice->streamOperator_ = nullptr;
6334 EXPECT_EQ(camDevice->CommitStreams(deviceSettings, operationMode), CAMERA_UNKNOWN_ERROR);
6335 }
6336
6337 /*
6338 * Feature: Framework
6339 * Function: Test HCameraDevice when streamOperator is nullptr
6340 * SubFunction: NA
6341 * FunctionPoints: NA
6342 * EnvConditions: NA
6343 * CaseDescription: Test HCameraDevice when streamOperator is nullptr
6344 */
6345 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_085, TestSize.Level0)
6346 {
6347 std::vector<int32_t> result;
6348 result.push_back(OHOS_SENSOR_EXPOSURE_TIME);
6349 result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
6350
6351 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6352
6353 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
6354 std::string cameraId = cameras[0]->GetID();
6355 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6356 sptr<HCameraDevice> camDevice = new(std::nothrow)
6357 HCameraDevice(cameraHostManager, cameraId, callerToken);
6358 ASSERT_NE(camDevice, nullptr);
6359
6360 std::vector<StreamInfo_V1_1> streamInfos = {};
6361 EXPECT_EQ(camDevice->UpdateStreams(streamInfos), CAMERA_UNKNOWN_ERROR);
6362 }
6363
6364 /*
6365 * Feature: Framework
6366 * Function: Test HCameraDevice when streamOperatorCallback is nullptr
6367 * SubFunction: NA
6368 * FunctionPoints: NA
6369 * EnvConditions: NA
6370 * CaseDescription: Test HCameraDevice when streamOperatorCallback is nullptr
6371 */
6372 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_086, TestSize.Level0)
6373 {
6374 std::vector<int32_t> result;
6375 result.push_back(OHOS_SENSOR_EXPOSURE_TIME);
6376 result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
6377
6378 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6379
6380 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
6381 std::string cameraId = cameras[0]->GetID();
6382 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6383 sptr<HCameraDevice> camDevice = new(std::nothrow)
6384 HCameraDevice(cameraHostManager, cameraId, callerToken);
6385 ASSERT_NE(camDevice, nullptr);
6386
6387 int32_t captureId = 0;
6388 const std::vector<int32_t> streamIds = {1, 2};
6389 EXPECT_EQ(camDevice->OnCaptureStarted(captureId, streamIds), CAMERA_INVALID_STATE);
6390
6391 HDI::Camera::V1_2::CaptureStartedInfo it1;
6392 it1.streamId_ = 1;
6393 it1.exposureTime_ = 1;
6394 HDI::Camera::V1_2::CaptureStartedInfo it2;
6395 it2.streamId_ = 2;
6396 it2.exposureTime_ = 2;
6397 std::vector<OHOS::HDI::Camera::V1_2::CaptureStartedInfo> captureStartedInfo = {};
6398 captureStartedInfo.push_back(it1);
6399 captureStartedInfo.push_back(it2);
6400 EXPECT_EQ(camDevice->OnCaptureStarted_V1_2(captureId, captureStartedInfo), CAMERA_INVALID_STATE);
6401 }
6402
6403 /*
6404 * Feature: Framework
6405 * Function: Test HCameraDevice when streamOperatorCallback is nullptr
6406 * SubFunction: NA
6407 * FunctionPoints: NA
6408 * EnvConditions: NA
6409 * CaseDescription: Test HCameraDevice when streamOperatorCallback is nullptr
6410 */
6411 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_087, TestSize.Level0)
6412 {
6413 std::vector<int32_t> result;
6414 result.push_back(OHOS_SENSOR_EXPOSURE_TIME);
6415 result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
6416
6417 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6418
6419 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
6420 std::string cameraId = cameras[0]->GetID();
6421 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6422 sptr<HCameraDevice> camDevice = new(std::nothrow)
6423 HCameraDevice(cameraHostManager, cameraId, callerToken);
6424 ASSERT_NE(camDevice, nullptr);
6425
6426 int32_t captureId = 0;
6427 const std::vector<int32_t> streamIds = {1, 2};
6428 EXPECT_EQ(camDevice->OnCaptureStarted(captureId, streamIds), CAMERA_INVALID_STATE);
6429 const std::vector<OHOS::HDI::Camera::V1_2::CaptureStartedInfo> captureStartedInfo = {};
6430 EXPECT_EQ(camDevice->OnCaptureStarted_V1_2(captureId, captureStartedInfo), CAMERA_INVALID_STATE);
6431
6432 CaptureEndedInfo it1;
6433 it1.streamId_ = 1;
6434 it1.frameCount_ = 1;
6435 CaptureEndedInfo it2;
6436 it2.streamId_ = 2;
6437 it2.frameCount_ = 2;
6438 std::vector<CaptureEndedInfo> captureEndedInfo = {};
6439 captureEndedInfo.push_back(it1);
6440 captureEndedInfo.push_back(it2);
6441 EXPECT_EQ(camDevice->OnCaptureEnded(captureId, captureEndedInfo), CAMERA_INVALID_STATE);
6442 }
6443
6444 /*
6445 * Feature: Framework
6446 * Function: Test HCameraDevice when streamOperatorCallback is nullptr
6447 * SubFunction: NA
6448 * FunctionPoints: NA
6449 * EnvConditions: NA
6450 * CaseDescription: Test HCameraDevice when streamOperatorCallback is nullptr
6451 */
6452 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_088, TestSize.Level0)
6453 {
6454 std::vector<int32_t> result;
6455 result.push_back(OHOS_SENSOR_EXPOSURE_TIME);
6456 result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
6457
6458 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6459
6460 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
6461 std::string cameraId = cameras[0]->GetID();
6462 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6463 sptr<HCameraDevice> camDevice = new(std::nothrow)
6464 HCameraDevice(cameraHostManager, cameraId, callerToken);
6465 ASSERT_NE(camDevice, nullptr);
6466
6467 int32_t captureId = 0;
6468 CaptureErrorInfo it1;
6469 it1.streamId_ = 2;
6470 it1.error_ = BUFFER_LOST;
6471 CaptureErrorInfo it2;
6472 it2.streamId_ = 1;
6473 it2.error_ = BUFFER_LOST;
6474 std::vector<CaptureErrorInfo> captureErrorInfo = {};
6475 captureErrorInfo.push_back(it1);
6476 captureErrorInfo.push_back(it2);
6477 EXPECT_EQ(camDevice->OnCaptureError(captureId, captureErrorInfo), CAMERA_INVALID_STATE);
6478
6479 const std::vector<int32_t> streamIds = {1, 2};
6480 uint64_t timestamp = 5;
6481 EXPECT_EQ(camDevice->OnFrameShutter(captureId, streamIds, timestamp), CAMERA_INVALID_STATE);
6482 EXPECT_EQ(camDevice->OnFrameShutterEnd(captureId, streamIds, timestamp), CAMERA_INVALID_STATE);
6483 EXPECT_EQ(camDevice->OnCaptureReady(captureId, streamIds, timestamp), CAMERA_INVALID_STATE);
6484 }
6485
6486 /*
6487 * Feature: Framework
6488 * Function: Test HCameraDevice with CheckOnResultData
6489 * SubFunction: NA
6490 * FunctionPoints: NA
6491 * EnvConditions: NA
6492 * CaseDescription: Test HCameraDevice with CheckOnResultData
6493 */
6494 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_089, TestSize.Level0)
6495 {
6496 std::vector<int32_t> result;
6497 result.push_back(OHOS_SENSOR_EXPOSURE_TIME);
6498 result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
6499
6500 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6501
6502 sptr<HCameraHostManager> cameraHostManager = (sptr<HCameraHostManager> &)mockCameraHostManager;
6503 std::string cameraId = cameras[0]->GetID();
6504 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6505 sptr<HCameraDevice> camDevice = new(std::nothrow)
6506 HCameraDevice(cameraHostManager, cameraId, callerToken);
6507 ASSERT_NE(camDevice, nullptr);
6508
6509 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult = cameras[0]->GetMetadata();
6510 camDevice->CheckOnResultData(nullptr);
6511 camDevice->CheckOnResultData(cameraResult);
6512 }
6513
6514 /*
6515 * Feature: coverage
6516 * Function: Test HStreamRepeat
6517 * SubFunction: NA
6518 * FunctionPoints: NA
6519 * EnvConditions: NA
6520 * CaseDescription: Test HStreamRepeat
6521 */
6522 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_090, TestSize.Level0)
6523 {
6524 int32_t format = CAMERA_FORMAT_YUV_420_SP;
6525 int32_t width = PHOTO_DEFAULT_WIDTH;
6526 int32_t height = PHOTO_DEFAULT_HEIGHT;
6527
6528 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
6529 sptr<IBufferProducer> producer = Surface->GetProducer();
6530 auto streamRepeat = new (std::nothrow)
6531 HStreamRepeat(producer, format, width, height, RepeatStreamType::PREVIEW);
6532 ASSERT_NE(streamRepeat, nullptr);
6533 sptr<HStreamRepeat> streamRepeat1 =
6534 new (std::nothrow) HStreamRepeat(producer, 4, 1280, 960, RepeatStreamType::PREVIEW);
6535 ASSERT_NE(streamRepeat1, nullptr);
6536
6537 SketchStatus status = SketchStatus::STARTED;
6538 streamRepeat->repeatStreamType_ = RepeatStreamType::SKETCH;
6539 streamRepeat->parentStreamRepeat_ = streamRepeat1;
6540 streamRepeat->UpdateSketchStatus(status);
6541 }
6542
6543 /*
6544 * Feature: coverage
6545 * Function: Test HStreamRepeat when status is STARTED
6546 * SubFunction: NA
6547 * FunctionPoints: NA
6548 * EnvConditions: NA
6549 * CaseDescription: Test HStreamRepeat when status is STARTED
6550 */
6551 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_091, TestSize.Level0)
6552 {
6553 int32_t format = CAMERA_FORMAT_YUV_420_SP;
6554 int32_t width = PHOTO_DEFAULT_WIDTH;
6555 int32_t height = PHOTO_DEFAULT_HEIGHT;
6556
6557 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
6558 sptr<IBufferProducer> producer = Surface->GetProducer();
6559 auto streamRepeat = new (std::nothrow)
6560 HStreamRepeat(producer, format, width, height, RepeatStreamType::PREVIEW);
6561 ASSERT_NE(streamRepeat, nullptr);
6562
6563 SketchStatus status = SketchStatus::STARTED;
6564 EXPECT_EQ(streamRepeat->OnSketchStatusChanged(status), 0);
6565 }
6566
6567 /*
6568 * Feature: coverage
6569 * Function: Test HStreamRepeat when sketchStream is nullptr
6570 * SubFunction: NA
6571 * FunctionPoints: NA
6572 * EnvConditions: NA
6573 * CaseDescription: Test HStreamRepeat when sketchStream is nullptr
6574 */
6575 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_092, TestSize.Level0)
6576 {
6577 int32_t format = CAMERA_FORMAT_YUV_420_SP;
6578 int32_t width = PHOTO_DEFAULT_WIDTH;
6579 int32_t height = PHOTO_DEFAULT_HEIGHT;
6580
6581 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
6582 sptr<IBufferProducer> producer = Surface->GetProducer();
6583 auto streamRepeat = new (std::nothrow)
6584 HStreamRepeat(producer, format, width, height, RepeatStreamType::PREVIEW);
6585 ASSERT_NE(streamRepeat, nullptr);
6586
6587 sptr<IStreamRepeat> sketchStream = nullptr;
6588 float sketchRatio = 0;
6589 EXPECT_EQ(streamRepeat->ForkSketchStreamRepeat(0, 1, sketchStream, sketchRatio), CAMERA_INVALID_ARG);
6590 EXPECT_EQ(streamRepeat->ForkSketchStreamRepeat(1, 0, sketchStream, sketchRatio), CAMERA_INVALID_ARG);
6591 }
6592
6593 /*
6594 * Feature: coverage
6595 * Function: Test HStreamRepeat when sketchStreamRepeat_ is nullptr
6596 * SubFunction: NA
6597 * FunctionPoints: NA
6598 * EnvConditions: NA
6599 * CaseDescription: Test HStreamRepeat when sketchStreamRepeat_ is nullptr
6600 */
6601 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_093, TestSize.Level0)
6602 {
6603 int32_t format = CAMERA_FORMAT_YUV_420_SP;
6604 int32_t width = PHOTO_DEFAULT_WIDTH;
6605 int32_t height = PHOTO_DEFAULT_HEIGHT;
6606
6607 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
6608 sptr<IBufferProducer> producer = Surface->GetProducer();
6609 auto streamRepeat = new (std::nothrow)
6610 HStreamRepeat(producer, format, width, height, RepeatStreamType::PREVIEW);
6611 ASSERT_NE(streamRepeat, nullptr);
6612
6613 float sketchRatio = 0;
6614 streamRepeat->sketchStreamRepeat_ = nullptr;
6615 EXPECT_EQ(streamRepeat->RemoveSketchStreamRepeat(), 0);
6616 EXPECT_EQ(streamRepeat->UpdateSketchRatio(sketchRatio), CAMERA_INVALID_STATE);
6617 }
6618
6619 /*
6620 * Feature: coverage
6621 * Function: Test HStreamRepeat
6622 * SubFunction: NA
6623 * FunctionPoints: NA
6624 * EnvConditions: NA
6625 * CaseDescription: Test HStreamRepeat
6626 */
6627 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_094, TestSize.Level0)
6628 {
6629 int32_t format = CAMERA_FORMAT_YUV_420_SP;
6630 int32_t width = PHOTO_DEFAULT_WIDTH;
6631 int32_t height = PHOTO_DEFAULT_HEIGHT;
6632
6633 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
6634 sptr<IBufferProducer> producer = Surface->GetProducer();
6635 auto streamRepeat = new (std::nothrow)
6636 HStreamRepeat(producer, format, width, height, RepeatStreamType::PREVIEW);
6637 ASSERT_NE(streamRepeat, nullptr);
6638
6639 uint32_t interfaceCode = 5;
6640 EXPECT_EQ(streamRepeat->OperatePermissionCheck(interfaceCode), 0);
6641 }
6642
6643 /*
6644 * Feature: coverage
6645 * Function: Test HCaptureSession when stream is nullptr
6646 * SubFunction: NA
6647 * FunctionPoints: NA
6648 * EnvConditions: NA
6649 * CaseDescription: Test HCaptureSession when stream is nullptr
6650 */
6651 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_095, TestSize.Level0)
6652 {
6653 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6654 SceneMode mode = PORTRAIT;
6655 sptr<HCaptureSession> camSession = new (std::nothrow) HCaptureSession(callerToken, mode);
6656 ASSERT_NE(camSession, nullptr);
6657
6658 std::vector<StreamInfo_V1_1> streamInfos = {};
6659 EXPECT_EQ(camSession->GetCurrentStreamInfos(streamInfos), 0);
6660 EXPECT_EQ(camSession->AddOutputStream(nullptr), CAMERA_INVALID_ARG);
6661 EXPECT_EQ(camSession->RemoveOutputStream(nullptr), CAMERA_INVALID_ARG);
6662 }
6663
6664 /*
6665 * Feature: coverage
6666 * Function: Test HCaptureSession when cameraDevice_ is nullptr
6667 * SubFunction: NA
6668 * FunctionPoints: NA
6669 * EnvConditions: NA
6670 * CaseDescription: Test HCaptureSession when cameraDevice_ is nullptr
6671 */
6672 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_096, TestSize.Level0)
6673 {
6674 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6675 SceneMode mode = PORTRAIT;
6676 sptr<HCaptureSession> camSession = new (std::nothrow) HCaptureSession(callerToken, mode);
6677 ASSERT_NE(camSession, nullptr);
6678
6679 camSession->cameraDevice_ = nullptr;
6680 EXPECT_EQ(camSession->LinkInputAndOutputs(), CAMERA_INVALID_SESSION_CFG);
6681 }
6682
6683 /*
6684 * Feature: coverage
6685 * Function: Test HCaptureSession with SetColorSpace
6686 * SubFunction: NA
6687 * FunctionPoints: NA
6688 * EnvConditions: NA
6689 * CaseDescription: Test HCaptureSession with SetColorSpace
6690 */
6691 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_097, TestSize.Level0)
6692 {
6693 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6694 SceneMode mode = PORTRAIT;
6695 sptr<HCaptureSession> camSession = new (std::nothrow) HCaptureSession(callerToken, mode);
6696 ASSERT_NE(camSession, nullptr);
6697
6698 bool isNeedUpdate = false;
6699 ColorSpace colorSpace = ColorSpace::SRGB;
6700 ColorSpace captureColorSpace = ColorSpace::SRGB;
6701 camSession->currColorSpace_ = ColorSpace::BT709;
6702 camSession->currCaptureColorSpace_ = ColorSpace::BT709;
6703 EXPECT_EQ(camSession->SetColorSpace(colorSpace, captureColorSpace, isNeedUpdate), CAMERA_INVALID_STATE);
6704 camSession->currColorSpace_ = ColorSpace::SRGB;
6705 EXPECT_EQ(camSession->SetColorSpace(colorSpace, captureColorSpace, isNeedUpdate), CAMERA_INVALID_STATE);
6706 }
6707
6708 /*
6709 * Feature: coverage
6710 * Function: Test HCaptureSession with CheckIfColorSpaceMatchesFormat
6711 * SubFunction: NA
6712 * FunctionPoints: NA
6713 * EnvConditions: NA
6714 * CaseDescription: Test HCaptureSession with CheckIfColorSpaceMatchesFormat
6715 */
6716 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_098, TestSize.Level0)
6717 {
6718 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6719 SceneMode mode = PORTRAIT;
6720 sptr<HCaptureSession> camSession = new (std::nothrow) HCaptureSession(callerToken, mode);
6721 ASSERT_NE(camSession, nullptr);
6722
6723 camSession->RestartStreams();
6724
6725 ColorSpace colorSpace = ColorSpace::SRGB;
6726 EXPECT_EQ(camSession->CheckIfColorSpaceMatchesFormat(colorSpace), 0);
6727 colorSpace = ColorSpace::BT2020_HLG ;
6728 EXPECT_EQ(camSession->CheckIfColorSpaceMatchesFormat(colorSpace), 0);
6729 colorSpace = ColorSpace::BT2020_PQ ;
6730 EXPECT_EQ(camSession->CheckIfColorSpaceMatchesFormat(colorSpace), 0);
6731 colorSpace = ColorSpace::BT2020_HLG_LIMIT ;
6732 EXPECT_EQ(camSession->CheckIfColorSpaceMatchesFormat(colorSpace), 0);
6733 colorSpace = ColorSpace::BT2020_PQ_LIMIT;
6734 EXPECT_EQ(camSession->CheckIfColorSpaceMatchesFormat(colorSpace), 0);
6735 }
6736
6737 /*
6738 * Feature: coverage
6739 * Function: Test HCaptureSession
6740 * SubFunction: NA
6741 * FunctionPoints: NA
6742 * EnvConditions: NA
6743 * CaseDescription: Test HCaptureSession
6744 */
6745 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_099, TestSize.Level0)
6746 {
6747 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6748 SceneMode mode = PORTRAIT;
6749 sptr<HCaptureSession> camSession = new (std::nothrow) HCaptureSession(callerToken, mode);
6750 ASSERT_NE(camSession, nullptr);
6751 }
6752
6753 /*
6754 * Feature: coverage
6755 * Function: Test HCaptureSession when isSessionStarted_ is true
6756 * SubFunction: NA
6757 * FunctionPoints: NA
6758 * EnvConditions: NA
6759 * CaseDescription: Test HCaptureSession when isSessionStarted_ is true
6760 */
6761 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_100, TestSize.Level0)
6762 {
6763 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6764 SceneMode mode = PORTRAIT;
6765 sptr<HCaptureSession> camSession = new (std::nothrow) HCaptureSession(callerToken, mode);
6766 ASSERT_NE(camSession, nullptr);
6767
6768 camSession->SetColorSpaceForStreams();
6769
6770 std::vector<StreamInfo_V1_1> streamInfos = {};
6771 camSession->CancelStreamsAndGetStreamInfos(streamInfos);
6772
6773 camSession->isSessionStarted_ = true;
6774 camSession->RestartStreams();
6775 }
6776
6777 /*
6778 * Feature: coverage
6779 * Function: Test HCaptureSession when cameraDevice is nullptr
6780 * SubFunction: NA
6781 * FunctionPoints: NA
6782 * EnvConditions: NA
6783 * CaseDescription: Test HCaptureSession when cameraDevice is nullptr
6784 */
6785 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_101, TestSize.Level0)
6786 {
6787 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
6788 SceneMode mode = PORTRAIT;
6789 sptr<HCaptureSession> camSession = new (std::nothrow) HCaptureSession(callerToken, mode);
6790 ASSERT_NE(camSession, nullptr);
6791
6792 float currentFps = 0;
6793 float currentZoomRatio = 0;
6794 EXPECT_EQ(camSession->QueryFpsAndZoomRatio(currentFps, currentZoomRatio), false);
6795 std::vector<float> crossZoomAndTime = {0, 0};
6796 int32_t operationMode = 0;
6797 EXPECT_EQ(camSession->QueryZoomPerformance(crossZoomAndTime, operationMode), false);
6798 int32_t smoothZoomType = 0;
6799 float targetZoomRatio = 0;
6800 float duration = 0;
6801 EXPECT_EQ(camSession->SetSmoothZoom(smoothZoomType, operationMode,
6802 targetZoomRatio, duration), 11);
6803 }
6804
6805 /*
6806 * Feature: Framework
6807 * Function: Test metadataoutput when appStateCallback_ is not nullptr
6808 * SubFunction: NA
6809 * FunctionPoints: NA
6810 * EnvConditions: NA
6811 * CaseDescription: Test metadataoutput when appStateCallback_ is not nullptr
6812 */
6813 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_102, TestSize.Level0)
6814 {
6815 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6816
6817 sptr<CaptureOutput> output = cameraManager->CreateMetadataOutput();
6818 ASSERT_NE(output, nullptr);
6819 sptr<MetadataOutput> metadatOutput = (sptr<MetadataOutput>&)output;
6820
6821 std::shared_ptr<MetadataStateCallback> metadataStateCallback =
6822 std::make_shared<AppMetadataCallback>();
6823 metadatOutput->SetCallback(metadataStateCallback);
6824
6825 pid_t pid = 0;
6826 metadatOutput->CameraServerDied(pid);
6827 }
6828
6829 /*
6830 * Feature: coverage
6831 * Function: Test HStreamRepeat when repeatStreamType_ is SKETCH
6832 * SubFunction: NA
6833 * FunctionPoints: NA
6834 * EnvConditions: NA
6835 * CaseDescription: Test HStreamRepeat when repeatStreamType_ is SKETCH
6836 */
6837 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_103, TestSize.Level0)
6838 {
6839 int32_t format = CAMERA_FORMAT_YUV_420_SP;
6840 int32_t width = PHOTO_DEFAULT_WIDTH;
6841 int32_t height = PHOTO_DEFAULT_HEIGHT;
6842
6843 sptr<IConsumerSurface> Surface = IConsumerSurface::Create();
6844 sptr<IBufferProducer> producer = Surface->GetProducer();
6845 auto streamRepeat = new (std::nothrow)
6846 HStreamRepeat(producer, format, width, height, RepeatStreamType::PREVIEW);
6847 ASSERT_NE(streamRepeat, nullptr);
6848
6849 StreamInfo_V1_1 streamInfo;
6850 streamRepeat->repeatStreamType_ = RepeatStreamType::SKETCH;
6851 streamRepeat->SetStreamInfo(streamInfo);
6852 }
6853
6854 /*
6855 * Feature: Framework
6856 * Function: Test PortraitSession when output is nullptr
6857 * SubFunction: NA
6858 * FunctionPoints: NA
6859 * EnvConditions: NA
6860 * CaseDescription: Test PortraitSession when output is nullptr
6861 */
6862 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_104, TestSize.Level0)
6863 {
6864 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6865 SceneMode mode = PORTRAIT;
6866 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
6867 ASSERT_TRUE(modes.size() != 0);
6868
6869 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
6870 ASSERT_NE(ability, nullptr);
6871 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = cameras[0]->GetMetadata();
6872 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
6873 ASSERT_NE(input, nullptr);
6874 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
6875 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
6876 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
6877 std::string cameraSettings = camInput->GetCameraSettings();
6878 camInput->SetCameraSettings(cameraSettings);
6879 camInput->GetCameraDevice()->Open();
6880
6881 sptr<CaptureOutput> preview = CreatePreviewOutput();
6882 ASSERT_NE(preview, nullptr);
6883 sptr<CaptureOutput> photo = CreatePhotoOutput();
6884 ASSERT_NE(photo, nullptr);
6885 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(mode);
6886 ASSERT_NE(captureSession, nullptr);
6887 sptr<PortraitSession> portraitSession = nullptr;
6888 portraitSession = static_cast<PortraitSession *> (captureSession.GetRefPtr());
6889 ASSERT_NE(portraitSession, nullptr);
6890 sptr<CaptureOutput> output = nullptr;
6891 EXPECT_EQ(portraitSession->CanAddOutput(output), false);
6892 EXPECT_EQ(portraitSession->BeginConfig(), 0);
6893 EXPECT_EQ(portraitSession->AddInput(input), 0);
6894 EXPECT_EQ(portraitSession->AddOutput(preview), 0);
6895 EXPECT_EQ(portraitSession->AddOutput(photo), 0);
6896 EXPECT_EQ(portraitSession->CommitConfig(), 0);
6897
6898 const float aperture = 0.1;
6899 EXPECT_EQ(portraitSession->CanAddOutput(output), false);
6900 std::vector<float> supportedVirtualApertures = {};
6901 std::vector<float> virtualApertures = {};
6902 portraitSession->GetSupportedVirtualApertures(virtualApertures);
6903 EXPECT_EQ(virtualApertures, supportedVirtualApertures);
6904 float virtualAperture = 0.0f;
6905 portraitSession->GetVirtualAperture(virtualAperture);
6906 EXPECT_EQ(virtualAperture, 0.0);
6907 portraitSession->SetVirtualAperture(aperture);
6908 std::vector<std::vector<float>> supportedPhysicalApertures;
6909 std::vector<std::vector<float>> physicalApertures;
6910 portraitSession->GetSupportedPhysicalApertures(physicalApertures);
6911 EXPECT_EQ(physicalApertures, supportedPhysicalApertures);
6912 float physicalAperture = 0.0f;
6913 portraitSession->GetPhysicalAperture(physicalAperture);
6914 EXPECT_EQ(physicalAperture, 0.0f);
6915 portraitSession->SetPhysicalAperture(aperture);
6916
6917 portraitSession->Release();
6918 input->Close();
6919 }
6920
6921 /*
6922 * Feature: Framework
6923 * Function: Test PortraitSession without CommitConfig
6924 * SubFunction: NA
6925 * FunctionPoints: NA
6926 * EnvConditions: NA
6927 * CaseDescription: Test PortraitSession without CommitConfig
6928 */
6929 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_105, TestSize.Level0)
6930 {
6931 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6932 SceneMode mode = PORTRAIT;
6933 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
6934 ASSERT_TRUE(modes.size() != 0);
6935 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
6936 ASSERT_NE(ability, nullptr);
6937 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
6938 ASSERT_NE(input, nullptr);
6939 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
6940 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
6941 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
6942 std::string cameraSettings = camInput->GetCameraSettings();
6943 camInput->SetCameraSettings(cameraSettings);
6944 camInput->GetCameraDevice()->Open();
6945
6946 sptr<CaptureOutput> preview = CreatePreviewOutput();
6947 ASSERT_NE(preview, nullptr);
6948 sptr<CaptureOutput> photo = CreatePhotoOutput();
6949 ASSERT_NE(photo, nullptr);
6950 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(mode);
6951 ASSERT_NE(captureSession, nullptr);
6952 sptr<PortraitSession> portraitSession = nullptr;
6953 portraitSession = static_cast<PortraitSession *> (captureSession.GetRefPtr());
6954 ASSERT_NE(portraitSession, nullptr);
6955
6956 EXPECT_EQ(portraitSession->BeginConfig(), 0);
6957 EXPECT_EQ(portraitSession->AddInput(input), 0);
6958 EXPECT_EQ(portraitSession->AddOutput(preview), 0);
6959 EXPECT_EQ(portraitSession->AddOutput(photo), 0);
6960
6961 const float physicalAperture = 0.1;
6962 const float virtualAperture = 0.1;
6963 std::vector<float> supportedVirtualApertures = {};
6964 std::vector<float> virtualApertures = {};
6965 portraitSession->GetSupportedVirtualApertures(virtualApertures);
6966 EXPECT_EQ(virtualApertures, supportedVirtualApertures);
6967 float virtualApertureResult = 0.0f;
6968 portraitSession->GetVirtualAperture(virtualApertureResult);
6969 EXPECT_EQ(virtualApertureResult, 0.0);
6970 portraitSession->SetVirtualAperture(virtualAperture);
6971 std::vector<std::vector<float>> supportedPhysicalApertures;
6972 std::vector<std::vector<float>> physicalApertures;
6973 portraitSession->GetSupportedPhysicalApertures(physicalApertures);
6974 EXPECT_EQ(physicalApertures, supportedPhysicalApertures);
6975 float physicalApertureResult = 0.0f;
6976 portraitSession->GetPhysicalAperture(physicalApertureResult);
6977 EXPECT_EQ(physicalApertureResult, 0.0f);
6978 portraitSession->SetPhysicalAperture(physicalAperture);
6979 portraitSession->Release();
6980 input->Close();
6981 }
6982
6983 /*
6984 * Feature: Framework
6985 * Function: Test PortraitSession when innerInputDevice_ is nullptr
6986 * SubFunction: NA
6987 * FunctionPoints: NA
6988 * EnvConditions: NA
6989 * CaseDescription: Test PortraitSession when innerInputDevice_ is nullptr
6990 */
6991 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_106, TestSize.Level0)
6992 {
6993 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
6994 SceneMode mode = PORTRAIT;
6995 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
6996 ASSERT_TRUE(modes.size() != 0);
6997
6998 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
6999 ASSERT_NE(ability, nullptr);
7000 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
7001 ASSERT_NE(input, nullptr);
7002 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7003 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7004 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7005 std::string cameraSettings = camInput->GetCameraSettings();
7006 camInput->SetCameraSettings(cameraSettings);
7007 camInput->GetCameraDevice()->Open();
7008
7009 sptr<CaptureOutput> preview = CreatePreviewOutput();
7010 ASSERT_NE(preview, nullptr);
7011 sptr<CaptureOutput> photo = CreatePhotoOutput();
7012 ASSERT_NE(photo, nullptr);
7013 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(mode);
7014 ASSERT_NE(captureSession, nullptr);
7015 sptr<PortraitSession> portraitSession = nullptr;
7016 portraitSession = static_cast<PortraitSession *> (captureSession.GetRefPtr());
7017 ASSERT_NE(portraitSession, nullptr);
7018
7019 EXPECT_EQ(portraitSession->BeginConfig(), 0);
7020 EXPECT_EQ(portraitSession->AddInput(input), 0);
7021 EXPECT_EQ(portraitSession->AddOutput(preview), 0);
7022 EXPECT_EQ(portraitSession->AddOutput(photo), 0);
7023 EXPECT_EQ(portraitSession->CommitConfig(), 0);
7024
7025 portraitSession->innerInputDevice_ = nullptr;
7026 std::vector<PortraitEffect> supportedPortraitEffects = {};
7027 EXPECT_EQ(portraitSession->GetSupportedPortraitEffects(), supportedPortraitEffects);
7028 EXPECT_EQ(portraitSession->GetPortraitEffect(), PortraitEffect::OFF_EFFECT);
7029 std::vector<float> supportedVirtualApertures = {};
7030 std::vector<float> virtualApertures = {};
7031 portraitSession->GetSupportedVirtualApertures(virtualApertures);
7032 EXPECT_EQ(virtualApertures, supportedVirtualApertures);
7033 float virtualAperture = 0.0f;
7034 portraitSession->GetVirtualAperture(virtualAperture);
7035 EXPECT_EQ(virtualAperture, 0.0);
7036 std::vector<std::vector<float>> supportedPhysicalApertures;
7037 std::vector<std::vector<float>> physicalApertures;
7038 portraitSession->GetSupportedPhysicalApertures(physicalApertures);
7039 EXPECT_EQ(physicalApertures, supportedPhysicalApertures);
7040 float physicalAperture = 0.0f;
7041 portraitSession->GetPhysicalAperture(physicalAperture);
7042 EXPECT_EQ(physicalAperture, 0.0);
7043
7044 portraitSession->Release();
7045 input->Close();
7046 }
7047
7048 /*
7049 * Feature: Framework
7050 * Function: Test NightSession about exposure
7051 * SubFunction: NA
7052 * FunctionPoints: NA
7053 * EnvConditions: NA
7054 * CaseDescription: Test NightSession about exposure
7055 */
7056 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_107, TestSize.Level0)
7057 {
7058 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7059 SceneMode mode = NIGHT;
7060 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
7061 ASSERT_TRUE(modes.size() != 0);
7062 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
7063 ASSERT_NE(ability, nullptr);
7064 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
7065 ASSERT_NE(input, nullptr);
7066 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7067 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7068 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7069 std::string cameraSettings = camInput->GetCameraSettings();
7070 camInput->SetCameraSettings(cameraSettings);
7071 camInput->GetCameraDevice()->Open();
7072
7073 sptr<CaptureOutput> preview = CreatePreviewOutput();
7074 ASSERT_NE(preview, nullptr);
7075 sptr<CaptureOutput> photo = CreatePhotoOutput();
7076 ASSERT_NE(photo, nullptr);
7077 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(mode);
7078 ASSERT_NE(captureSession, nullptr);
7079 sptr<NightSession> nightSession = static_cast<NightSession*>(captureSession.GetRefPtr());
7080 ASSERT_NE(nightSession, nullptr);
7081
7082 EXPECT_EQ(nightSession->BeginConfig(), 0);
7083 EXPECT_EQ(nightSession->AddInput(input), 0);
7084 EXPECT_EQ(nightSession->AddOutput(preview), 0);
7085 EXPECT_EQ(nightSession->AddOutput(photo), 0);
7086 EXPECT_EQ(nightSession->CommitConfig(), 0);
7087
7088 std::vector<uint32_t> exposureRange = {};
7089 uint32_t exposureValue = 0;
7090 EXPECT_EQ(nightSession->GetExposureRange(exposureRange), CameraErrorCode::INVALID_ARGUMENT);
7091 EXPECT_EQ(nightSession->GetExposure(exposureValue), CameraErrorCode::INVALID_ARGUMENT);
7092
7093 nightSession->Release();
7094 input->Close();
7095 }
7096
7097 /*
7098 * Feature: Framework
7099 * Function: Test NightSession when innerInputDevice_ and output is nullptr
7100 * SubFunction: NA
7101 * FunctionPoints: NA
7102 * EnvConditions: NA
7103 * CaseDescription: Test NightSession when innerInputDevice_ and output is nullptr
7104 */
7105 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_108, TestSize.Level0)
7106 {
7107 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7108 SceneMode mode = NIGHT;
7109 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
7110 ASSERT_TRUE(modes.size() != 0);
7111 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
7112 ASSERT_NE(ability, nullptr);
7113 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = cameras[0]->GetMetadata();
7114 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
7115 ASSERT_NE(input, nullptr);
7116
7117 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7118 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7119 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7120 std::string cameraSettings = camInput->GetCameraSettings();
7121 camInput->SetCameraSettings(cameraSettings);
7122 camInput->GetCameraDevice()->Open();
7123
7124 sptr<CaptureOutput> preview = CreatePreviewOutput();
7125 ASSERT_NE(preview, nullptr);
7126 sptr<CaptureOutput> photo = CreatePhotoOutput();
7127 ASSERT_NE(photo, nullptr);
7128 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(mode);
7129 ASSERT_NE(captureSession, nullptr);
7130 sptr<NightSession> nightSession = static_cast<NightSession*>(captureSession.GetRefPtr());
7131 ASSERT_NE(nightSession, nullptr);
7132
7133 EXPECT_EQ(nightSession->BeginConfig(), 0);
7134 EXPECT_EQ(nightSession->AddInput(input), 0);
7135 EXPECT_EQ(nightSession->AddOutput(preview), 0);
7136 EXPECT_EQ(nightSession->AddOutput(photo), 0);
7137 EXPECT_EQ(nightSession->CommitConfig(), 0);
7138
7139 nightSession->innerInputDevice_ = nullptr;
7140 std::vector<uint32_t> exposureRange = {};
7141 EXPECT_EQ(nightSession->GetExposureRange(exposureRange), CameraErrorCode::INVALID_ARGUMENT);
7142 sptr<CaptureOutput> output = nullptr;
7143 EXPECT_EQ(nightSession->CanAddOutput(output), false);
7144
7145 nightSession->Release();
7146 input->Close();
7147 }
7148
7149 /*
7150 * Feature: Framework
7151 * Function: Test ScanSession when output is nullptr
7152 * SubFunction: NA
7153 * FunctionPoints: NA
7154 * EnvConditions: NA
7155 * CaseDescription: Test ScanSession when output is nullptr
7156 */
7157 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_109, TestSize.Level0)
7158 {
7159 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7160 SceneMode mode = SCAN;
7161 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
7162 ASSERT_TRUE(modes.size() != 0);
7163
7164 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
7165 ASSERT_NE(ability, nullptr);
7166
7167 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
7168 ASSERT_NE(input, nullptr);
7169
7170 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7171 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7172 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7173 std::string cameraSettings = camInput->GetCameraSettings();
7174 camInput->SetCameraSettings(cameraSettings);
7175 camInput->GetCameraDevice()->Open();
7176
7177 sptr<CaptureOutput> preview = CreatePreviewOutput();
7178 ASSERT_NE(preview, nullptr);
7179
7180 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(mode);
7181 ASSERT_NE(captureSession, nullptr);
7182 sptr<ScanSession> scanSession = static_cast<ScanSession*>(captureSession.GetRefPtr());
7183 ASSERT_NE(scanSession, nullptr);
7184
7185 EXPECT_EQ(scanSession->BeginConfig(), 0);
7186 EXPECT_EQ(scanSession->AddInput(input), 0);
7187 EXPECT_EQ(scanSession->AddOutput(preview), 0);
7188 EXPECT_EQ(scanSession->CommitConfig(), 0);
7189
7190 sptr<CaptureOutput> output = nullptr;
7191 scanSession->CanAddOutput(output);
7192
7193 scanSession->Release();
7194 input->Close();
7195 }
7196
7197 /*
7198 * Feature: Framework
7199 * Function: Test ScanSession when innerInputDevice_ is nullptr
7200 * SubFunction: NA
7201 * FunctionPoints: NA
7202 * EnvConditions: NA
7203 * CaseDescription: Test ScanSession when innerInputDevice_ is nullptr
7204 */
7205 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_110, TestSize.Level0)
7206 {
7207 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7208 SceneMode mode = SCAN;
7209 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
7210 ASSERT_TRUE(modes.size() != 0);
7211
7212 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
7213 ASSERT_NE(ability, nullptr);
7214
7215 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
7216 ASSERT_NE(input, nullptr);
7217
7218 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7219 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7220 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7221 std::string cameraSettings = camInput->GetCameraSettings();
7222 camInput->SetCameraSettings(cameraSettings);
7223 camInput->GetCameraDevice()->Open();
7224
7225 sptr<CaptureOutput> preview = CreatePreviewOutput();
7226 ASSERT_NE(preview, nullptr);
7227
7228 sptr<CaptureOutput> photo = CreatePhotoOutput();
7229 ASSERT_NE(photo, nullptr);
7230
7231 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(mode);
7232 ASSERT_NE(captureSession, nullptr);
7233 sptr<ScanSession> scanSession = static_cast<ScanSession*>(captureSession.GetRefPtr());
7234 ASSERT_NE(scanSession, nullptr);
7235
7236 EXPECT_EQ(scanSession->CanAddOutput(photo), false);
7237 EXPECT_EQ(scanSession->BeginConfig(), 0);
7238 EXPECT_EQ(scanSession->AddInput(input), 0);
7239 EXPECT_EQ(scanSession->AddOutput(preview), 0);
7240
7241 scanSession->CanAddOutput(photo);
7242
7243 scanSession->innerInputDevice_ = nullptr;
7244 int32_t ret = scanSession->AddOutput(preview);
7245 EXPECT_EQ(ret, SESSION_NOT_CONFIG);
7246
7247 ret = scanSession->CommitConfig();
7248 EXPECT_EQ(ret, 0);
7249
7250 scanSession->Release();
7251 input->Close();
7252 }
7253
7254 /*
7255 * Feature: Framework
7256 * Function: Test ScanSession
7257 * SubFunction: NA
7258 * FunctionPoints: NA
7259 * EnvConditions: NA
7260 * CaseDescription: Test ScanSession
7261 */
7262 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_111, TestSize.Level0)
7263 {
7264 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7265 SceneMode mode = SCAN;
7266 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
7267 ASSERT_TRUE(modes.size() != 0);
7268
7269 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
7270 ASSERT_NE(ability, nullptr);
7271
7272 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
7273 ASSERT_NE(input, nullptr);
7274
7275 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7276 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7277 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7278 std::string cameraSettings = camInput->GetCameraSettings();
7279 camInput->SetCameraSettings(cameraSettings);
7280 camInput->GetCameraDevice()->Open();
7281
7282 sptr<CaptureOutput> preview = CreatePreviewOutput();
7283 ASSERT_NE(preview, nullptr);
7284
7285 sptr<CaptureOutput> photo = CreatePhotoOutput();
7286 ASSERT_NE(photo, nullptr);
7287
7288 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(mode);
7289 ASSERT_NE(captureSession, nullptr);
7290 sptr<ScanSession> scanSession = static_cast<ScanSession*>(captureSession.GetRefPtr());
7291 ASSERT_NE(scanSession, nullptr);
7292
7293 EXPECT_EQ(scanSession->CanAddOutput(photo), false);
7294 EXPECT_EQ(scanSession->BeginConfig(), 0);
7295 EXPECT_EQ(scanSession->AddInput(input), 0);
7296 EXPECT_EQ(scanSession->AddOutput(preview), 0);
7297
7298 scanSession->CanAddOutput(photo);
7299
7300 scanSession->innerInputDevice_ = nullptr;
7301 int32_t ret = scanSession->AddOutput(preview);
7302 EXPECT_EQ(ret, SESSION_NOT_CONFIG);
7303
7304 ret = scanSession->CommitConfig();
7305 EXPECT_EQ(ret, 0);
7306
7307 scanSession->Release();
7308 input->Close();
7309 }
7310
7311 /*
7312 * Feature: Framework
7313 * Function: Test anomalous branch
7314 * SubFunction: NA
7315 * FunctionPoints: NA
7316 * EnvConditions: NA
7317 * CaseDescription: Test HCameraService with anomalous branch
7318 */
7319 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_112, TestSize.Level0)
7320 {
7321 InSequence s;
7322 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7323
7324 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
7325 ASSERT_NE(input, nullptr);
7326
7327 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7328 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7329 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7330 std::string cameraSettings = camInput->GetCameraSettings();
7331 camInput->SetCameraSettings(cameraSettings);
7332 camInput->GetCameraDevice()->Open();
7333
7334 sptr<FakeHCameraService> mockHCameraService = new FakeHCameraService(mockCameraHostManager);
7335 sptr<HCameraService> cameraService = (sptr<HCameraService> &)mockHCameraService;
7336 ASSERT_NE(cameraService, nullptr);
7337
7338 sptr<ICameraServiceCallback> callback = nullptr;
7339 int32_t intResult = cameraService->SetCameraCallback(callback);
7340 EXPECT_EQ(intResult, 2);
7341
7342 callback = new(std::nothrow) CameraStatusServiceCallback(cameraManager);
7343 ASSERT_NE(callback, nullptr);
7344 intResult = cameraService->SetCameraCallback(callback);
7345 EXPECT_EQ(intResult, 0);
7346
7347 sptr<ICameraDeviceService> deviceObj = camInput->GetCameraDevice();
7348 ASSERT_NE(deviceObj, nullptr);
7349
7350 sptr<ICameraMuteServiceCallback> callback_2 = nullptr;
7351 intResult = cameraService->SetMuteCallback(callback_2);
7352 EXPECT_EQ(intResult, 2);
7353
7354 callback_2 = new(std::nothrow) CameraMuteServiceCallback(cameraManager);
7355 ASSERT_NE(callback_2, nullptr);
7356 intResult = cameraService->SetMuteCallback(callback_2);
7357 EXPECT_EQ(intResult, 0);
7358
7359 std::string cameraId = camInput->GetCameraId();
7360 int activeTime = 0;
7361 EffectParam effectParam = {0, 0, 0};
7362 intResult = cameraService->SetPrelaunchConfig(cameraId, RestoreParamTypeOhos::TRANSIENT_ACTIVE_PARAM_OHOS,
7363 activeTime, effectParam);
7364 EXPECT_EQ(intResult, 2);
7365
7366 intResult = cameraService->SetPrelaunchConfig(cameraId, RestoreParamTypeOhos::PERSISTENT_DEFAULT_PARAM_OHOS,
7367 activeTime, effectParam);
7368 EXPECT_EQ(intResult, 2);
7369
7370 input->Close();
7371 }
7372
TestPhotoSessionPreconfig(sptr<CaptureInput> & input,PreconfigType preconfigType,ProfileSizeRatio profileSizeRatio)7373 void CameraFrameworkUnitTest::TestPhotoSessionPreconfig(
7374 sptr<CaptureInput>& input, PreconfigType preconfigType, ProfileSizeRatio profileSizeRatio)
7375 {
7376 sptr<CaptureSession> photoSession = cameraManager->CreateCaptureSession(SceneMode::CAPTURE);
7377 ASSERT_NE(photoSession, nullptr);
7378 if (photoSession->CanPreconfig(preconfigType, profileSizeRatio)) {
7379 int32_t intResult = photoSession->Preconfig(preconfigType, profileSizeRatio);
7380 EXPECT_EQ(intResult, 0);
7381
7382 sptr<Surface> preivewSurface = Surface::CreateSurfaceAsConsumer();
7383 ASSERT_NE(preivewSurface, nullptr);
7384
7385 sptr<PreviewOutput> previewOutput = nullptr;
7386 intResult = cameraManager->CreatePreviewOutputWithoutProfile(preivewSurface, &previewOutput);
7387 EXPECT_EQ(intResult, 0);
7388 ASSERT_NE(previewOutput, nullptr);
7389
7390 sptr<IConsumerSurface> photoSurface = IConsumerSurface::Create();
7391 ASSERT_NE(photoSurface, nullptr);
7392 auto photoProducer = photoSurface->GetProducer();
7393 ASSERT_NE(photoProducer, nullptr);
7394 sptr<PhotoOutput> photoOutput = nullptr;
7395 intResult = cameraManager->CreatePhotoOutputWithoutProfile(photoProducer, &photoOutput);
7396 EXPECT_EQ(intResult, 0);
7397 ASSERT_NE(photoOutput, nullptr);
7398
7399 intResult = photoSession->BeginConfig();
7400 EXPECT_EQ(intResult, 0);
7401
7402 intResult = photoSession->AddInput(input);
7403 EXPECT_EQ(intResult, 0);
7404
7405 sptr<CaptureOutput> previewOutputCaptureUpper = previewOutput;
7406 intResult = photoSession->AddOutput(previewOutputCaptureUpper);
7407 EXPECT_EQ(intResult, 0);
7408 sptr<CaptureOutput> photoOutputCaptureUpper = photoOutput;
7409 intResult = photoSession->AddOutput(photoOutputCaptureUpper);
7410 EXPECT_EQ(intResult, 0);
7411
7412 intResult = photoSession->CommitConfig();
7413 EXPECT_EQ(intResult, 0);
7414
7415 intResult = photoSession->Start();
7416 EXPECT_EQ(intResult, 0);
7417
7418 intResult = photoSession->Stop();
7419 EXPECT_EQ(intResult, 0);
7420
7421 intResult = photoSession->BeginConfig();
7422 EXPECT_EQ(intResult, 0);
7423
7424 intResult = photoSession->RemoveInput(input);
7425 EXPECT_EQ(intResult, 0);
7426
7427 intResult = photoSession->Release();
7428 EXPECT_EQ(intResult, 0);
7429 }
7430 }
7431
7432 /*
7433 * Feature: Framework
7434 * Function: Test PhotoSession preconfig
7435 * SubFunction: NA
7436 * FunctionPoints: NA
7437 * EnvConditions: NA
7438 * CaseDescription: Test preconfig PhotoSession all config.
7439 */
7440 HWTEST_F(CameraFrameworkUnitTest, camera_preconfig_unittest_001, TestSize.Level0)
7441 {
7442 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7443 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
7444 ASSERT_NE(input, nullptr);
7445
7446 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7447 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7448 sptr<CameraInput> camInput = (sptr<CameraInput>&)input;
7449 std::string cameraSettings = camInput->GetCameraSettings();
7450 camInput->SetCameraSettings(cameraSettings);
7451 camInput->GetCameraDevice()->Open();
7452
7453 sptr<FakeHCameraService> mockHCameraService = new FakeHCameraService(mockCameraHostManager);
7454 sptr<HCameraService> cameraService = (sptr<HCameraService>&)mockHCameraService;
7455 ASSERT_NE(cameraService, nullptr);
7456
7457 sptr<ICameraServiceCallback> callback = new (std::nothrow) CameraStatusServiceCallback(cameraManager);
7458 ASSERT_NE(callback, nullptr);
7459 int32_t intResult = cameraService->SetCameraCallback(callback);
7460 EXPECT_EQ(intResult, 0);
7461
7462 sptr<ICameraDeviceService> deviceObj = camInput->GetCameraDevice();
7463 ASSERT_NE(deviceObj, nullptr);
7464
7465 std::vector<PreconfigType> preconfigTypes = { PRECONFIG_720P, PRECONFIG_1080P, PRECONFIG_4K,
7466 PRECONFIG_HIGH_QUALITY };
7467 std::vector<ProfileSizeRatio> profileSizeRatios = { UNSPECIFIED, RATIO_1_1, RATIO_4_3, RATIO_16_9 };
7468 for (auto& preconfigType : preconfigTypes) {
7469 for (auto& profileSizeRatio : profileSizeRatios) {
7470 TestPhotoSessionPreconfig(input, preconfigType, profileSizeRatio);
7471 }
7472 }
7473
7474 input->Close();
7475 }
7476
TestVideoSessionPreconfig(sptr<CaptureInput> & input,PreconfigType preconfigType,ProfileSizeRatio profileSizeRatio)7477 void CameraFrameworkUnitTest::TestVideoSessionPreconfig(
7478 sptr<CaptureInput>& input, PreconfigType preconfigType, ProfileSizeRatio profileSizeRatio)
7479 {
7480 sptr<CaptureSession> videoSession = cameraManager->CreateCaptureSession(SceneMode::VIDEO);
7481 ASSERT_NE(videoSession, nullptr);
7482 if (videoSession->CanPreconfig(preconfigType, profileSizeRatio)) {
7483 int32_t intResult = videoSession->Preconfig(preconfigType, profileSizeRatio);
7484 EXPECT_EQ(intResult, 0);
7485
7486 sptr<PreviewOutput> previewOutput = nullptr;
7487 intResult =
7488 cameraManager->CreatePreviewOutputWithoutProfile(Surface::CreateSurfaceAsConsumer(), &previewOutput);
7489 EXPECT_EQ(intResult, 0);
7490 ASSERT_NE(previewOutput, nullptr);
7491
7492 sptr<IConsumerSurface> photoSurface = IConsumerSurface::Create();
7493 ASSERT_NE(photoSurface, nullptr);
7494 auto photoProducer = photoSurface->GetProducer();
7495 ASSERT_NE(photoProducer, nullptr);
7496 sptr<PhotoOutput> photoOutput = nullptr;
7497 intResult = cameraManager->CreatePhotoOutputWithoutProfile(photoProducer, &photoOutput);
7498 EXPECT_EQ(intResult, 0);
7499 ASSERT_NE(photoOutput, nullptr);
7500
7501 sptr<VideoOutput> videoOutput = nullptr;
7502 intResult = cameraManager->CreateVideoOutputWithoutProfile(Surface::CreateSurfaceAsConsumer(), &videoOutput);
7503 EXPECT_EQ(intResult, 0);
7504 ASSERT_NE(videoOutput, nullptr);
7505
7506 intResult = videoSession->BeginConfig();
7507 EXPECT_EQ(intResult, 0);
7508
7509 intResult = videoSession->AddInput(input);
7510 EXPECT_EQ(intResult, 0);
7511
7512 sptr<CaptureOutput> previewOutputCaptureUpper = previewOutput;
7513 intResult = videoSession->AddOutput(previewOutputCaptureUpper);
7514 EXPECT_EQ(intResult, 0);
7515 sptr<CaptureOutput> photoOutputCaptureUpper = photoOutput;
7516 intResult = videoSession->AddOutput(photoOutputCaptureUpper);
7517 EXPECT_EQ(intResult, 0);
7518 sptr<CaptureOutput> videoOutputCaptureUpper = videoOutput;
7519 intResult = videoSession->AddOutput(videoOutputCaptureUpper);
7520 EXPECT_EQ(intResult, 0);
7521
7522 intResult = videoSession->CommitConfig();
7523 EXPECT_EQ(intResult, 0);
7524
7525 intResult = videoSession->Start();
7526 EXPECT_EQ(intResult, 0);
7527
7528 intResult = videoSession->Stop();
7529 EXPECT_EQ(intResult, 0);
7530
7531 intResult = videoSession->BeginConfig();
7532 EXPECT_EQ(intResult, 0);
7533
7534 intResult = videoSession->RemoveInput(input);
7535 EXPECT_EQ(intResult, 0);
7536
7537 intResult = videoSession->Release();
7538 EXPECT_EQ(intResult, 0);
7539 }
7540 }
7541
7542 /*
7543 * Feature: Framework
7544 * Function: Test VideoSession preconfig
7545 * SubFunction: NA
7546 * FunctionPoints: NA
7547 * EnvConditions: NA
7548 * CaseDescription: Test preconfig VideoSession all config.
7549 */
7550 HWTEST_F(CameraFrameworkUnitTest, camera_preconfig_unittest_002, TestSize.Level0)
7551 {
7552 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7553 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
7554 ASSERT_NE(input, nullptr);
7555
7556 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7557 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7558 sptr<CameraInput> camInput = (sptr<CameraInput>&)input;
7559 std::string cameraSettings = camInput->GetCameraSettings();
7560 camInput->SetCameraSettings(cameraSettings);
7561 camInput->GetCameraDevice()->Open();
7562
7563 sptr<FakeHCameraService> mockHCameraService = new FakeHCameraService(mockCameraHostManager);
7564 sptr<HCameraService> cameraService = (sptr<HCameraService>&)mockHCameraService;
7565 ASSERT_NE(cameraService, nullptr);
7566
7567 sptr<ICameraServiceCallback> callback = new (std::nothrow) CameraStatusServiceCallback(cameraManager);
7568 ASSERT_NE(callback, nullptr);
7569 int32_t intResult = cameraService->SetCameraCallback(callback);
7570 EXPECT_EQ(intResult, 0);
7571
7572 sptr<ICameraDeviceService> deviceObj = camInput->GetCameraDevice();
7573 ASSERT_NE(deviceObj, nullptr);
7574
7575 std::vector<PreconfigType> preconfigTypes = { PRECONFIG_720P, PRECONFIG_1080P, PRECONFIG_4K,
7576 PRECONFIG_HIGH_QUALITY };
7577 std::vector<ProfileSizeRatio> profileSizeRatios = { UNSPECIFIED, RATIO_1_1, RATIO_4_3, RATIO_16_9 };
7578 for (auto& preconfigType : preconfigTypes) {
7579 for (auto& profileSizeRatio : profileSizeRatios) {
7580 TestVideoSessionPreconfig(input, preconfigType, profileSizeRatio);
7581 }
7582 }
7583
7584 input->Close();
7585 }
7586
7587 /*
7588 * Feature: Framework
7589 * Function: Test HCaptureSession::NewInstance
7590 * SubFunction: NA
7591 * FunctionPoints: NA
7592 * EnvConditions: NA
7593 * CaseDescription: Test HCaptureSession::NewInstance
7594 */
7595 HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_121, TestSize.Level0)
7596 {
7597 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
7598 SceneMode opMode = PORTRAIT;
7599 sptr<HCaptureSession> session = HCaptureSession::NewInstance(callerToken, opMode);
7600 ASSERT_NE(session, nullptr);
7601 }
7602
7603 /*
7604 * Feature: Framework
7605 * Function: Test normal branch that is support secure camera for open camera
7606 * SubFunction: NA
7607 * FunctionPoints: NA
7608 * EnvConditions: NA
7609 * CaseDescription: Test normal branch for open camera
7610 */
7611 HWTEST_F(CameraFrameworkUnitTest, camera_opencamera_unittest_001, TestSize.Level0)
7612 {
7613 InSequence s;
7614 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7615
7616 for (sptr<CameraDevice> camDevice : cameras) {
7617 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(camDevice);
7618 ASSERT_TRUE(modes.size() != 0);
7619
7620 if (find(modes.begin(), modes.end(), SceneMode::SECURE) != modes.end()) {
7621 sptr<CaptureInput> input = cameraManager->CreateCameraInput(camDevice);
7622 ASSERT_NE(input, nullptr);
7623 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7624 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7625 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7626 std::string cameraSettings = camInput->GetCameraSettings();
7627 camInput->SetCameraSettings(cameraSettings);
7628
7629 uint64_t secureSeqId = 0;
7630 sptr<ICameraDeviceService> deviceObj = camInput->GetCameraDevice();
7631 ASSERT_NE(deviceObj, nullptr);
7632
7633 int intResult = camInput->Open(true, &secureSeqId);
7634 EXPECT_EQ(intResult, 0);
7635 EXPECT_NE(secureSeqId, 0);
7636 input->Close();
7637 break;
7638 }
7639 }
7640 }
7641
7642 /*
7643 * Feature: Framework
7644 * Function: Test anomalous branch that is not support secure camera for open camera
7645 * SubFunction: NA
7646 * FunctionPoints: NA
7647 * EnvConditions: NA
7648 * CaseDescription: Test anomalous branch for open camera
7649 */
7650 HWTEST_F(CameraFrameworkUnitTest, camera_opencamera_unittest_002, TestSize.Level0)
7651 {
7652 InSequence s;
7653 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7654
7655 for (sptr<CameraDevice> camDevice : cameras) {
7656 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(camDevice);
7657 ASSERT_TRUE(modes.size() != 0);
7658
7659 if (find(modes.begin(), modes.end(), SceneMode::SECURE) == modes.end()) {
7660 sptr<CaptureInput> input = cameraManager->CreateCameraInput(camDevice);
7661 ASSERT_NE(input, nullptr);
7662 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7663 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7664 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7665 std::string cameraSettings = camInput->GetCameraSettings();
7666 camInput->SetCameraSettings(cameraSettings);
7667
7668 uint64_t secureSeqId = 0;
7669 sptr<ICameraDeviceService> deviceObj = camInput->GetCameraDevice();
7670 ASSERT_NE(deviceObj, nullptr);
7671
7672 int intResult = camInput->Open(true, &secureSeqId);
7673 EXPECT_EQ(intResult, 0);
7674 EXPECT_EQ(secureSeqId, 0);
7675 input->Close();
7676 break;
7677 }
7678 }
7679 }
7680
7681 /*
7682 * Feature: Framework
7683 * Function: Test anomalous branch when open secure camera that seq is null
7684 * SubFunction: NA
7685 * FunctionPoints: NA
7686 * EnvConditions: NA
7687 * CaseDescription: Test anomalous branch for open camera
7688 */
7689 HWTEST_F(CameraFrameworkUnitTest, camera_opencamera_unittest_003, TestSize.Level0)
7690 {
7691 InSequence s;
7692 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7693
7694 for (sptr<CameraDevice> camDevice : cameras) {
7695 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(camDevice);
7696 ASSERT_TRUE(modes.size() != 0);
7697
7698 if (find(modes.begin(), modes.end(), SceneMode::SECURE) != modes.end()) {
7699 sptr<CaptureInput> input = cameraManager->CreateCameraInput(camDevice);
7700 ASSERT_NE(input, nullptr);
7701 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7702 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7703 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7704 std::string cameraSettings = camInput->GetCameraSettings();
7705 camInput->SetCameraSettings(cameraSettings);
7706
7707 sptr<ICameraDeviceService> deviceObj = camInput->GetCameraDevice();
7708 ASSERT_NE(deviceObj, nullptr);
7709
7710 uint64_t* secureSeqId = nullptr;
7711 int intResult = camInput->Open(true, secureSeqId);
7712 EXPECT_EQ(intResult, CAMERA_INVALID_ARG);
7713 input->Close();
7714 break;
7715 }
7716 }
7717 }
7718
7719 /*
7720 * Feature: Framework
7721 * Function: Test normal branch that is open non-secure camera
7722 * SubFunction: NA
7723 * FunctionPoints: NA
7724 * EnvConditions: NA
7725 * CaseDescription: Test normal branch that is open non-secure camera
7726 */
7727 HWTEST_F(CameraFrameworkUnitTest, camera_opencamera_unittest_004, TestSize.Level0)
7728 {
7729 InSequence s;
7730 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7731
7732 for (sptr<CameraDevice> camDevice : cameras) {
7733 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(camDevice);
7734 ASSERT_TRUE(modes.size() != 0);
7735
7736 if (find(modes.begin(), modes.end(), SceneMode::SECURE) == modes.end()) {
7737 sptr<CaptureInput> input = cameraManager->CreateCameraInput(camDevice);
7738 ASSERT_NE(input, nullptr);
7739 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7740 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7741 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7742 std::string cameraSettings = camInput->GetCameraSettings();
7743 camInput->SetCameraSettings(cameraSettings);
7744
7745 sptr<ICameraDeviceService> deviceObj = camInput->GetCameraDevice();
7746 ASSERT_NE(deviceObj, nullptr);
7747
7748 uint64_t secureSeqId = 0;
7749 int intResult = camInput->Open(false, &secureSeqId);
7750 EXPECT_EQ(intResult, CAMERA_OK);
7751 EXPECT_EQ(secureSeqId, 0);
7752 input->Close();
7753 break;
7754 }
7755 }
7756 }
7757
7758 /*
7759 * Feature: Framework
7760 * Function: Test normal branch that is add secure output flag
7761 * SubFunction: NA
7762 * FunctionPoints: NA
7763 * EnvConditions: NA
7764 * CaseDescription: Test normal branch that is add secure output flag
7765 */
7766 HWTEST_F(CameraFrameworkUnitTest, camera_securecamera_unittest_001, TestSize.Level0)
7767 {
7768 InSequence s;
7769 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7770
7771 for (sptr<CameraDevice> camDevice : cameras) {
7772 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(camDevice);
7773 ASSERT_TRUE(modes.size() != 0);
7774
7775 if (find(modes.begin(), modes.end(), SceneMode::SECURE) != modes.end()) {
7776 sptr<CameraOutputCapability> ability = cameraManager->
7777 GetSupportedOutputCapability(camDevice, SceneMode::SECURE);
7778 ASSERT_NE(ability, nullptr);
7779 sptr<CaptureInput> input = cameraManager->CreateCameraInput(camDevice);
7780 ASSERT_NE(input, nullptr);
7781 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7782 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7783 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7784 std::string cameraSettings = camInput->GetCameraSettings();
7785 camInput->SetCameraSettings(cameraSettings);
7786 uint64_t secureSeqId = 0;
7787 int intResult = camInput->Open(true, &secureSeqId);
7788 EXPECT_EQ(intResult, CAMERA_OK);
7789 EXPECT_NE(secureSeqId, 0);
7790
7791 sptr<CaptureOutput> preview = CreatePreviewOutput();
7792 ASSERT_NE(preview, nullptr);
7793 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(SceneMode::SECURE);
7794 ASSERT_NE(captureSession, nullptr);
7795 sptr<SecureCameraSession> secureSession = nullptr;
7796 secureSession = static_cast<SecureCameraSession *> (captureSession.GetRefPtr());
7797 ASSERT_NE(secureSession, nullptr);
7798
7799 EXPECT_EQ(secureSession->BeginConfig(), 0);
7800 EXPECT_EQ(secureSession->AddInput(input), 0);
7801 EXPECT_EQ(secureSession->AddOutput(preview), 0);
7802 EXPECT_EQ(secureSession->AddSecureOutput(preview), 0);
7803 EXPECT_EQ(secureSession->CommitConfig(), 0);
7804 secureSession->Release();
7805 input->Close();
7806 break;
7807 }
7808 }
7809 }
7810
7811 /*
7812 * Feature: Framework
7813 * Function: Test normal branch that is add secure output flag
7814 * SubFunction: NA
7815 * FunctionPoints: NA
7816 * EnvConditions: NA
7817 * CaseDescription: Test normal branch that is add secure output flag
7818 */
7819 HWTEST_F(CameraFrameworkUnitTest, camera_securecamera_unittest_002, TestSize.Level0)
7820 {
7821 InSequence s;
7822 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7823
7824 for (sptr<CameraDevice> camDevice : cameras) {
7825 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(camDevice);
7826 ASSERT_TRUE(modes.size() != 0);
7827
7828 if (find(modes.begin(), modes.end(), SceneMode::SECURE) != modes.end()) {
7829 sptr<CameraOutputCapability> ability = cameraManager->
7830 GetSupportedOutputCapability(camDevice, SceneMode::SECURE);
7831 ASSERT_NE(ability, nullptr);
7832 sptr<CaptureInput> input = cameraManager->CreateCameraInput(camDevice);
7833 ASSERT_NE(input, nullptr);
7834 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7835 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7836 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7837 std::string cameraSettings = camInput->GetCameraSettings();
7838 camInput->SetCameraSettings(cameraSettings);
7839 uint64_t secureSeqId = 0;
7840 int intResult = camInput->Open(false, &secureSeqId);
7841 EXPECT_EQ(intResult, CAMERA_OK);
7842 EXPECT_NE(secureSeqId, 0);
7843 sptr<CaptureOutput> preview = CreatePreviewOutput();
7844 ASSERT_NE(preview, nullptr);
7845 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(SceneMode::SECURE);
7846 ASSERT_NE(captureSession, nullptr);
7847 sptr<SecureCameraSession> secureSession = nullptr;
7848 secureSession = static_cast<SecureCameraSession *> (captureSession.GetRefPtr());
7849 ASSERT_NE(secureSession, nullptr);
7850
7851 EXPECT_EQ(secureSession->BeginConfig(), 0);
7852 EXPECT_EQ(secureSession->AddInput(input), 0);
7853 EXPECT_EQ(secureSession->AddOutput(preview), 0);
7854 EXPECT_EQ(secureSession->AddSecureOutput(preview), 0);
7855 EXPECT_EQ(secureSession->CommitConfig(), 0);
7856 secureSession->Release();
7857 input->Close();
7858 break;
7859 }
7860 }
7861 }
7862
7863 /*
7864 * Feature: Framework
7865 * Function: Test abnormal branch that is add secure output flag twice
7866 * SubFunction: NA
7867 * FunctionPoints: NA
7868 * EnvConditions: NA
7869 * CaseDescription: Test abnormal branch that is add secure output flag twice
7870 */
7871 HWTEST_F(CameraFrameworkUnitTest, camera_securecamera_unittest_003, TestSize.Level0)
7872 {
7873 InSequence s;
7874 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7875
7876 for (sptr<CameraDevice> camDevice : cameras) {
7877 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(camDevice);
7878 ASSERT_TRUE(modes.size() != 0);
7879
7880 if (find(modes.begin(), modes.end(), SceneMode::SECURE) != modes.end()) {
7881 sptr<CameraOutputCapability> ability = cameraManager->
7882 GetSupportedOutputCapability(camDevice, SceneMode::SECURE);
7883 ASSERT_NE(ability, nullptr);
7884 sptr<CaptureInput> input = cameraManager->CreateCameraInput(camDevice);
7885 ASSERT_NE(input, nullptr);
7886 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7887 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7888 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7889 std::string cameraSettings = camInput->GetCameraSettings();
7890 camInput->SetCameraSettings(cameraSettings);
7891 uint64_t secureSeqId = 0;
7892 int intResult = camInput->Open(false, &secureSeqId);
7893 EXPECT_EQ(intResult, CAMERA_OK);
7894 EXPECT_NE(secureSeqId, 0);
7895
7896 sptr<CaptureOutput> preview1 = CreatePreviewOutput();
7897 ASSERT_NE(preview1, nullptr);
7898 sptr<CaptureOutput> preview2 = CreatePreviewOutput();
7899 ASSERT_NE(preview2, nullptr);
7900 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(SceneMode::SECURE);
7901 ASSERT_NE(captureSession, nullptr);
7902 sptr<SecureCameraSession> secureSession = nullptr;
7903 secureSession = static_cast<SecureCameraSession *> (captureSession.GetRefPtr());
7904 ASSERT_NE(secureSession, nullptr);
7905
7906 EXPECT_EQ(secureSession->BeginConfig(), 0);
7907 EXPECT_EQ(secureSession->AddInput(input), 0);
7908 EXPECT_EQ(secureSession->AddOutput(preview1), 0);
7909 EXPECT_EQ(secureSession->AddOutput(preview2), 0);
7910 EXPECT_EQ(secureSession->AddSecureOutput(preview1), 0);
7911 EXPECT_EQ(secureSession->AddSecureOutput(preview2), OPERATION_NOT_ALLOWED);
7912 EXPECT_EQ(secureSession->CommitConfig(), 0);
7913 secureSession->Release();
7914 input->Close();
7915 break;
7916 }
7917 }
7918 }
7919
7920 /*
7921 * Feature: Framework
7922 * Function: Test abnormal branch that is add secure output flag twice
7923 * SubFunction: NA
7924 * FunctionPoints: NA
7925 * EnvConditions: NA
7926 * CaseDescription: Test abnormal branch that is add secure output flag twice
7927 */
7928 HWTEST_F(CameraFrameworkUnitTest, camera_securecamera_unittest_004, TestSize.Level0)
7929 {
7930 InSequence s;
7931 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7932
7933 for (sptr<CameraDevice> camDevice : cameras) {
7934 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(camDevice);
7935 ASSERT_TRUE(modes.size() != 0);
7936
7937 if (find(modes.begin(), modes.end(), SceneMode::SECURE) != modes.end()) {
7938 sptr<CameraOutputCapability> ability = cameraManager->
7939 GetSupportedOutputCapability(camDevice, SceneMode::SECURE);
7940 ASSERT_NE(ability, nullptr);
7941 sptr<CaptureInput> input = cameraManager->CreateCameraInput(camDevice);
7942 ASSERT_NE(input, nullptr);
7943 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
7944 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
7945 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
7946 std::string cameraSettings = camInput->GetCameraSettings();
7947 camInput->SetCameraSettings(cameraSettings);
7948 uint64_t secureSeqId = 0;
7949 int intResult = camInput->Open(false, &secureSeqId);
7950 EXPECT_EQ(intResult, CAMERA_OK);
7951 EXPECT_NE(secureSeqId, 0);
7952 sptr<CaptureOutput> preview1 = CreatePreviewOutput();
7953 ASSERT_NE(preview1, nullptr);
7954 sptr<CaptureOutput> preview2 = CreatePreviewOutput();
7955 ASSERT_NE(preview2, nullptr);
7956 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(SceneMode::SECURE);
7957 ASSERT_NE(captureSession, nullptr);
7958 sptr<SecureCameraSession> secureSession = nullptr;
7959 secureSession = static_cast<SecureCameraSession *> (captureSession.GetRefPtr());
7960 ASSERT_NE(secureSession, nullptr);
7961
7962 EXPECT_EQ(secureSession->BeginConfig(), 0);
7963 EXPECT_EQ(secureSession->AddInput(input), 0);
7964 EXPECT_EQ(secureSession->AddOutput(preview1), 0);
7965 EXPECT_EQ(secureSession->AddOutput(preview2), 0);
7966 EXPECT_EQ(secureSession->AddSecureOutput(preview1), 0);
7967 EXPECT_EQ(secureSession->AddSecureOutput(preview2), OPERATION_NOT_ALLOWED);
7968 EXPECT_EQ(secureSession->CommitConfig(), 0);
7969 secureSession->Release();
7970 input->Close();
7971 break;
7972 }
7973 }
7974 }
7975
7976 /*
7977 * Feature: Framework
7978 * Function: Test abnormal branch that secure output is added after commiting
7979 * SubFunction: NA
7980 * FunctionPoints: NA
7981 * EnvConditions: NA
7982 * CaseDescription: Test abnormal branch that secure output is added after commiting
7983 */
7984 HWTEST_F(CameraFrameworkUnitTest, camera_securecamera_unittest_005, TestSize.Level0)
7985 {
7986 InSequence s;
7987 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
7988
7989 for (sptr<CameraDevice> camDevice : cameras) {
7990 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(camDevice);
7991 ASSERT_TRUE(modes.size() != 0);
7992
7993 if (find(modes.begin(), modes.end(), SceneMode::SECURE) != modes.end()) {
7994 sptr<CameraOutputCapability> ability = cameraManager->
7995 GetSupportedOutputCapability(camDevice, SceneMode::SECURE);
7996 ASSERT_NE(ability, nullptr);
7997 sptr<CaptureInput> input = cameraManager->CreateCameraInput(camDevice);
7998 ASSERT_NE(input, nullptr);
7999 EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _, _));
8000 EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED));
8001 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
8002 std::string cameraSettings = camInput->GetCameraSettings();
8003 camInput->SetCameraSettings(cameraSettings);
8004 uint64_t secureSeqId = 0;
8005 int intResult = camInput->Open(false, &secureSeqId);
8006 EXPECT_EQ(intResult, CAMERA_OK);
8007 EXPECT_NE(secureSeqId, 0);
8008 sptr<CaptureOutput> preview = CreatePreviewOutput();
8009 ASSERT_NE(preview, nullptr);
8010 sptr<CaptureSession> captureSession = cameraManager->CreateCaptureSession(SceneMode::SECURE);
8011 ASSERT_NE(captureSession, nullptr);
8012 sptr<SecureCameraSession> secureSession = nullptr;
8013 secureSession = static_cast<SecureCameraSession *> (captureSession.GetRefPtr());
8014 ASSERT_NE(secureSession, nullptr);
8015
8016 EXPECT_EQ(secureSession->BeginConfig(), 0);
8017 EXPECT_EQ(secureSession->AddInput(input), 0);
8018 EXPECT_EQ(secureSession->AddOutput(preview), 0);
8019 EXPECT_EQ(secureSession->CommitConfig(), 0);
8020 EXPECT_EQ(secureSession->AddSecureOutput(preview), OPERATION_NOT_ALLOWED);
8021 secureSession->Release();
8022 input->Close();
8023 break;
8024 }
8025 }
8026 }
8027
8028 HWTEST_F(CameraFrameworkUnitTest, test_createDeferredPhotoProcessingSession, TestSize.Level0)
8029 {
8030 sptr<DeferredPhotoProcSession> deferredProcSession;
8031 deferredProcSession = cameraManager->CreateDeferredPhotoProcessingSession(g_userId_,
8032 std::make_shared<TestDeferredPhotoProcSessionCallback>());
8033 ASSERT_NE(deferredProcSession, nullptr);
8034 }
8035
8036 /**
8037 * @tc.name : Test IsSlowMotionDetectionSupported API
8038 * @tc.number : IsSlowMotionDetectionSupported_001
8039 * @tc.desc : Test IsSlowMotionDetectionSupported interface, when session is not committed.
8040 * @tc.require : slow motion only support videoStream & previewStrem & 1080p & 240fps
8041 */
8042 HWTEST_F(CameraFrameworkUnitTest, IsSlowMotionDetectionSupported_001, TestSize.Level0)
8043 {
8044 sptr<CaptureSession> session = cameraManager->CreateCaptureSession(SceneMode::SLOW_MOTION);
8045 ASSERT_NE(session, nullptr);
8046 sptr<SlowMotionSession> slowSession = static_cast<SlowMotionSession *> (session.GetRefPtr());
8047 bool result = slowSession->IsSlowMotionDetectionSupported();
8048 EXPECT_EQ(false, result);
8049 }
8050
8051 /**
8052 * @tc.name : Test IsSlowMotionDetectionSupported API
8053 * @tc.number : IsSlowMotionDetectionSupported_002
8054 * @tc.desc : Test IsSlowMotionDetectionSupported interface, when camera device is null.
8055 * @tc.require : slow motion only support videoStream & previewStrem & 1080p & 240fps
8056 */
8057 HWTEST_F(CameraFrameworkUnitTest, IsSlowMotionDetectionSupported_002, TestSize.Level0)
8058 {
8059 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
8060 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
8061 ASSERT_NE(input, nullptr);
8062 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
8063 std::string cameraSettings = camInput->GetCameraSettings();
8064 camInput->SetCameraSettings(cameraSettings);
8065 camInput->GetCameraDevice()->Open();
8066
8067 sptr<CaptureSession> session = cameraManager->CreateCaptureSession(SceneMode::SLOW_MOTION);
8068 ASSERT_NE(session, nullptr);
8069
8070 sptr<Surface> videoSurface = Surface::CreateSurfaceAsConsumer();
8071 CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
8072 Size videoSize;
8073 videoSize.width = 1920;
8074 videoSize.height = 1080;
8075 std::vector<int32_t> videoFramerates = {0, 0};
8076 VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates);
8077 sptr<VideoOutput> videoOutput = cameraManager->CreateVideoOutput(videoProfile, videoSurface);
8078 ASSERT_NE(videoOutput, nullptr);
8079
8080 sptr<Surface> previewSurface = Surface::CreateSurfaceAsConsumer();
8081 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
8082 Size previewSize;
8083 previewSize.width = 1920;
8084 previewSize.height = 1080;
8085 Profile previewProfile = Profile(previewFormat, previewSize);
8086 sptr<CaptureOutput> previewOutput = cameraManager->CreatePreviewOutput(previewProfile, previewSurface);
8087 ASSERT_NE(previewOutput, nullptr);
8088
8089 int32_t intResult = session->BeginConfig();
8090 EXPECT_EQ(intResult, 0);
8091
8092 intResult = session->AddInput(input);
8093 EXPECT_EQ(intResult, 0);
8094
8095 sptr<CaptureOutput> previewOutputCaptureUpper = previewOutput;
8096 intResult = session->AddOutput(previewOutputCaptureUpper);
8097 EXPECT_EQ(intResult, 0);
8098
8099 sptr<CaptureOutput> videoOutputCaptureUpper = videoOutput;
8100 intResult = session->AddOutput(videoOutputCaptureUpper);
8101 EXPECT_EQ(intResult, 0);
8102
8103 intResult = session->CommitConfig();
8104 EXPECT_EQ(intResult, 0);
8105
8106 intResult = input->Release();
8107 EXPECT_EQ(intResult, 0);
8108
8109 sptr<SlowMotionSession> slowSession = nullptr;
8110 slowSession = static_cast<SlowMotionSession *> (session.GetRefPtr());
8111 bool result = slowSession->IsSlowMotionDetectionSupported();
8112 EXPECT_EQ(false, result);
8113 }
8114
8115 /**
8116 * @tc.name : Test IsSlowMotionDetectionSupported API
8117 * @tc.number : IsSlowMotionDetectionSupported_003
8118 * @tc.desc : Test IsSlowMotionDetectionSupported interface, when metadata item not found.
8119 * Test IsSlowMotionDetectionSupported interface, when metadata item data is 0.
8120 * Test IsSlowMotionDetectionSupported interface, when metadata item data is 1.
8121 * @tc.require : slow motion only support videoStream & previewStrem & 1080p & 240fps
8122 */
8123 HWTEST_F(CameraFrameworkUnitTest, IsSlowMotionDetectionSupported_003, TestSize.Level0)
8124 {
8125 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
8126 sptr<CaptureInput> input = cameraManager->CreateCameraInput(cameras[0]);
8127 ASSERT_NE(input, nullptr);
8128 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
8129 std::string cameraSettings = camInput->GetCameraSettings();
8130 camInput->SetCameraSettings(cameraSettings);
8131 camInput->GetCameraDevice()->Open();
8132
8133 sptr<CaptureSession> session = cameraManager->CreateCaptureSession(SceneMode::SLOW_MOTION);
8134 ASSERT_NE(session, nullptr);
8135
8136 sptr<Surface> videoSurface = Surface::CreateSurfaceAsConsumer();
8137 CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP;
8138 Size videoSize;
8139 videoSize.width = 1920;
8140 videoSize.height = 1080;
8141 std::vector<int32_t> videoFramerates = {0, 0};
8142 VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates);
8143 sptr<VideoOutput> videoOutput = cameraManager->CreateVideoOutput(videoProfile, videoSurface);
8144 ASSERT_NE(videoOutput, nullptr);
8145
8146 sptr<Surface> previewSurface = Surface::CreateSurfaceAsConsumer();
8147 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
8148 Size previewSize;
8149 previewSize.width = 1920;
8150 previewSize.height = 1080;
8151 Profile previewProfile = Profile(previewFormat, previewSize);
8152 sptr<CaptureOutput> previewOutput = cameraManager->CreatePreviewOutput(previewProfile, previewSurface);
8153 ASSERT_NE(previewOutput, nullptr);
8154
8155 int32_t intResult = session->BeginConfig();
8156 EXPECT_EQ(intResult, 0);
8157
8158 intResult = session->AddInput(input);
8159 EXPECT_EQ(intResult, 0);
8160
8161 sptr<CaptureOutput> previewOutputCaptureUpper = previewOutput;
8162 intResult = session->AddOutput(previewOutputCaptureUpper);
8163 EXPECT_EQ(intResult, 0);
8164
8165 sptr<CaptureOutput> videoOutputCaptureUpper = videoOutput;
8166 intResult = session->AddOutput(videoOutputCaptureUpper);
8167 EXPECT_EQ(intResult, 0);
8168
8169 intResult = session->CommitConfig();
8170 EXPECT_EQ(intResult, 0);
8171
8172 sptr<SlowMotionSession> slowSession = static_cast<SlowMotionSession *> (session.GetRefPtr());
8173 std::shared_ptr<OHOS::Camera::CameraMetadata> metadata =
8174 slowSession->GetInputDevice()->GetCameraDeviceInfo()->GetMetadata();
8175 uint8_t value_u8 = 0;
8176 bool result = false;
8177 // metadata item not found.
8178 result = slowSession->IsSlowMotionDetectionSupported();
8179 EXPECT_EQ(false, result);
8180 // metadata item data is 0.
8181 metadata->addEntry(OHOS_ABILITY_MOTION_DETECTION_SUPPORT, &value_u8, sizeof(uint8_t));
8182 result = slowSession->IsSlowMotionDetectionSupported();
8183 EXPECT_EQ(false, result);
8184 value_u8 = 1;
8185 // metadata item data is 1.
8186 metadata->updateEntry(OHOS_ABILITY_MOTION_DETECTION_SUPPORT, &value_u8, sizeof(uint8_t));
8187 result = slowSession->IsSlowMotionDetectionSupported();
8188 EXPECT_EQ(true, result);
8189
8190 Rect rect;
8191 rect.topLeftX = 0.1;
8192 rect.topLeftY = 0.1;
8193 rect.width = 0.8;
8194 rect.height = 0.8;
8195 slowSession->SetSlowMotionDetectionArea(rect);
8196
8197 std::shared_ptr<TestSlowMotionStateCallback> callback = std::make_shared<TestSlowMotionStateCallback>();
8198 slowSession->SetCallback(callback);
8199 EXPECT_EQ(slowSession->GetApplicationCallback(), callback);
8200 }
8201
8202 /*
8203 * Feature: Framework
8204 * Function: Test PanoramaSession preview
8205 * SubFunction: NA
8206 * FunctionPoints: NA
8207 * EnvConditions: NA
8208 * CaseDescription: Test PanoramaSession preview
8209 */
8210 HWTEST_F(CameraFrameworkUnitTest, camera_panorama_unittest_001, TestSize.Level0)
8211 {
8212 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
8213 for (sptr<CameraDevice> camDevice : cameras) {
8214 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(camDevice);
8215 if (find(modes.begin(), modes.end(), SceneMode::PANORAMA_PHOTO) != modes.end()) {
8216 sptr<CaptureInput> input = cameraManager->CreateCameraInput(camDevice);
8217 ASSERT_NE(input, nullptr);
8218
8219 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
8220 std::string cameraSettings = camInput->GetCameraSettings();
8221 camInput->SetCameraSettings(cameraSettings);
8222 camInput->GetCameraDevice()->Open();
8223
8224 sptr<CaptureSession> session = cameraManager->CreateCaptureSession(SceneMode::PANORAMA_PHOTO);
8225 sptr<PanoramaSession> panoramaSession = static_cast<PanoramaSession *> (session.GetRefPtr());
8226 ASSERT_NE(panoramaSession, nullptr);
8227
8228 sptr<Surface> previewSurface = Surface::CreateSurfaceAsConsumer();
8229 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
8230 Size previewSize;
8231 previewSize.width = 1920;
8232 previewSize.height = 1080;
8233 Profile previewProfile = Profile(previewFormat, previewSize);
8234 sptr<CaptureOutput> previewOutput = cameraManager->CreatePreviewOutput(previewProfile, previewSurface);
8235 ASSERT_NE(previewOutput, nullptr);
8236
8237 int32_t intResult = panoramaSession->BeginConfig();
8238 EXPECT_EQ(intResult, 0);
8239
8240 intResult = panoramaSession->AddInput(input);
8241 EXPECT_EQ(intResult, 0);
8242
8243 sptr<CaptureOutput> previewOutputCaptureUpper = previewOutput;
8244 intResult = panoramaSession->AddOutput(previewOutputCaptureUpper);
8245 EXPECT_EQ(intResult, 0);
8246
8247 intResult = panoramaSession->CommitConfig();
8248 EXPECT_EQ(intResult, 0);
8249
8250 panoramaSession->Release();
8251 camInput->Close();
8252 }
8253 }
8254 }
8255
8256 /*
8257 * Feature: Framework
8258 * Function: Test PanoramaSession set white balance lock
8259 * SubFunction: NA
8260 * FunctionPoints: NA
8261 * EnvConditions: NA
8262 * CaseDescription: Test PanoramaSession set white balance lock
8263 */
8264 HWTEST_F(CameraFrameworkUnitTest, camera_panorama_unittest_002, TestSize.Level0)
8265 {
8266 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
8267 for (sptr<CameraDevice> camDevice : cameras) {
8268 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(camDevice);
8269 if (find(modes.begin(), modes.end(), SceneMode::PANORAMA_PHOTO) != modes.end()) {
8270 sptr<CaptureInput> input = cameraManager->CreateCameraInput(camDevice);
8271 ASSERT_NE(input, nullptr);
8272
8273 sptr<CameraInput> camInput = (sptr<CameraInput> &)input;
8274 std::string cameraSettings = camInput->GetCameraSettings();
8275 camInput->SetCameraSettings(cameraSettings);
8276 camInput->GetCameraDevice()->Open();
8277
8278 sptr<CaptureSession> session = cameraManager->CreateCaptureSession(SceneMode::PANORAMA_PHOTO);
8279 sptr<PanoramaSession> panoramaSession = static_cast<PanoramaSession *> (session.GetRefPtr());
8280 ASSERT_NE(panoramaSession, nullptr);
8281
8282 sptr<Surface> previewSurface = Surface::CreateSurfaceAsConsumer();
8283 CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP;
8284 Size previewSize;
8285 previewSize.width = 1920;
8286 previewSize.height = 1080;
8287 Profile previewProfile = Profile(previewFormat, previewSize);
8288 sptr<CaptureOutput> previewOutput = cameraManager->CreatePreviewOutput(previewProfile, previewSurface);
8289 ASSERT_NE(previewOutput, nullptr);
8290
8291 int32_t intResult = panoramaSession->BeginConfig();
8292 EXPECT_EQ(intResult, 0);
8293
8294 intResult = panoramaSession->AddInput(input);
8295 EXPECT_EQ(intResult, 0);
8296
8297 sptr<CaptureOutput> previewOutputCaptureUpper = previewOutput;
8298 intResult = panoramaSession->AddOutput(previewOutputCaptureUpper);
8299 EXPECT_EQ(intResult, 0);
8300
8301 intResult = panoramaSession->CommitConfig();
8302 EXPECT_EQ(intResult, 0);
8303
8304 panoramaSession->SetWhiteBalanceMode(AWB_MODE_LOCKED);
8305 WhiteBalanceMode mode;
8306 panoramaSession->GetWhiteBalanceMode(mode);
8307 EXPECT_EQ(AWB_MODE_LOCKED, mode);
8308
8309 panoramaSession->Release();
8310 camInput->Close();
8311 }
8312 }
8313 }
8314
8315 HWTEST_F(CameraFrameworkUnitTest, test_capture_session_callbacks, TestSize.Level0)
8316 {
8317 sptr<CaptureSession> session = cameraManager->CreateCaptureSession(SceneMode::CAPTURE);
8318 ASSERT_NE(session, nullptr);
8319
8320 bool isSessionStarted = session->IsSessionStarted();
8321 EXPECT_EQ(isSessionStarted, false);
8322 std::string deviceClass;
8323 int32_t intResult = session->SetPreviewRotation(deviceClass);
8324 EXPECT_EQ(intResult, 0);
8325
8326 std::shared_ptr<TestExposureCallback> exposureCallback = std::make_shared<TestExposureCallback>();
8327 session->SetExposureCallback(exposureCallback);
8328 EXPECT_EQ(session->GetExposureCallback(), exposureCallback);
8329
8330 std::shared_ptr<TestSmoothZoomCallback> smoothZoomCallback = std::make_shared<TestSmoothZoomCallback>();
8331 session->SetSmoothZoomCallback(smoothZoomCallback);
8332 EXPECT_EQ(session->GetSmoothZoomCallback(), smoothZoomCallback);
8333
8334 std::shared_ptr<TestAbilityCallback> abilityCallback = std::make_shared<TestAbilityCallback>();
8335 session->SetAbilityCallback(abilityCallback);
8336
8337 std::shared_ptr<TestFocusCallback> focusCallback = std::make_shared<TestFocusCallback>();
8338 session->SetFocusCallback(focusCallback);
8339 EXPECT_EQ(session->GetFocusCallback(), focusCallback);
8340
8341 std::shared_ptr<TestARCallback> aRCallback = std::make_shared<TestARCallback>();
8342 session->SetARCallback(aRCallback);
8343 EXPECT_EQ(session->GetARCallback(), aRCallback);
8344 }
8345
8346 HWTEST_F(CameraFrameworkUnitTest, test_CheckFrameRateRangeWithCurrentFps, TestSize.Level0)
8347 {
8348 sptr<CaptureSession> session = cameraManager->CreateCaptureSession(SceneMode::CAPTURE);
8349 ASSERT_NE(session, nullptr);
8350 ASSERT_EQ(session->CheckFrameRateRangeWithCurrentFps(30, 30, 30, 60), false);
8351 ASSERT_EQ(session->CheckFrameRateRangeWithCurrentFps(30, 30, 30, 60), false);
8352 ASSERT_EQ(session->CheckFrameRateRangeWithCurrentFps(20, 40, 20, 40), true);
8353 ASSERT_EQ(session->CheckFrameRateRangeWithCurrentFps(20, 40, 30, 60), false);
8354 }
8355
8356 HWTEST_F(CameraFrameworkUnitTest, test_CanPreconfig, TestSize.Level0)
8357 {
8358 sptr<CaptureSession> session = cameraManager->CreateCaptureSession(SceneMode::CAPTURE);
8359 ASSERT_NE(session, nullptr);
8360 PreconfigType preconfigType = PreconfigType::PRECONFIG_720P;
8361 ProfileSizeRatio preconfigRatio = ProfileSizeRatio::RATIO_16_9;
8362 EXPECT_EQ(session->CanPreconfig(preconfigType, preconfigRatio), true);
8363 int32_t result = session->Preconfig(preconfigType, preconfigRatio);
8364 EXPECT_EQ(result, 0);
8365 }
8366
8367 /*
8368 * Feature: Framework
8369 * Function: Test cameraManager GetSupportedOutputCapability with yuv photo
8370 * SubFunction: NA
8371 * FunctionPoints: NA
8372 * EnvConditions: NA
8373 * CaseDescription: Test cameraManager GetSupportedOutputCapability with yuv photo
8374 */
8375 HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_can_get_yuv_photo_profile, TestSize.Level0)
8376 {
8377 std::vector<sptr<CameraDevice>> cameras = cameraManager->GetSupportedCameras();
8378
8379 SceneMode mode = PORTRAIT;
8380 std::vector<SceneMode> modes = cameraManager->GetSupportedModes(cameras[0]);
8381 ASSERT_TRUE(modes.size() != 0);
8382
8383 sptr<CameraOutputCapability> ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
8384 ASSERT_NE(ability, nullptr);
8385
8386 vector<Profile> photoProfiles = ability->GetPhotoProfiles();
8387 auto it = std::find_if(photoProfiles.begin(), photoProfiles.end(),
__anon779f14c50802(const auto& profile)8388 [](const auto& profile){ return profile.format_ == CAMERA_FORMAT_YUV_420_SP;});
8389
8390
8391 mode = SceneMode::CAPTURE;
8392 ability = cameraManager->GetSupportedOutputCapability(cameras[0], mode);
8393 ASSERT_NE(ability, nullptr);
8394
8395 it = std::find_if(photoProfiles.begin(), photoProfiles.end(),
__anon779f14c50902(const auto& profile)8396 [](const auto& profile){ return profile.format_ == CAMERA_FORMAT_YUV_420_SP;});
8397 }
8398
8399 HWTEST_F(CameraFrameworkUnitTest, test_CreateBurstDisplayName, TestSize.Level0)
8400 {
8401 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
8402 SceneMode opMode = CAPTURE;
8403 sptr<HCaptureSession> session = HCaptureSession::NewInstance(callerToken, opMode);
8404 std::string displayName = session->CreateBurstDisplayName(1, 1);
8405 cout << "displayName: " << displayName <<endl;
8406 ASSERT_NE(displayName, "");
8407 ASSERT_THAT(displayName, testing::EndsWith("_COVER"));
8408 displayName = session->CreateBurstDisplayName(2, 2);
8409 cout << "displayName: " << displayName <<endl;
8410 ASSERT_THAT(displayName, Not(testing::EndsWith("_COVER")));
8411 displayName = session->CreateBurstDisplayName(-1, -1);
8412 cout << "displayName: " << displayName <<endl;
8413 }
8414
8415 /*
8416 * Feature: Framework
8417 * Function: Verify that the method returns the correct list of cameras when the device is not foldable.
8418 * SubFunction: NA
8419 * FunctionPoints: NA
8420 * EnvConditions: NA
8421 * CaseDescription: Verify that the method returns the correct list of cameras when the device is not foldable.
8422 */
8423 HWTEST_F(CameraFrameworkUnitTest, get_supported_cameras_not_foldable, TestSize.Level0)
8424 {
8425 EXPECT_CALL(*mockCameraManager, GetIsFoldable())
8426 .WillRepeatedly(Return(false));
8427 std::vector<sptr<CameraDevice>> expectedCameraList;
8428 auto changedMetadata = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
8429 auto camera0 = new CameraDevice("device0", changedMetadata);
8430 auto camera1 = new CameraDevice("device1", changedMetadata);
8431 auto camera2 = new CameraDevice("device2", changedMetadata);
8432 expectedCameraList.emplace_back(camera0);
8433 expectedCameraList.emplace_back(camera1);
8434 expectedCameraList.emplace_back(camera2);
8435 mockCameraManager->cameraDeviceList_ = expectedCameraList;
8436 auto result = mockCameraManager->GetSupportedCameras();
8437 ASSERT_EQ(result.size(), expectedCameraList.size());
8438 }
8439
8440 /*
8441 * Feature: Framework
8442 * Function: The goal is to verify that the method correctly returns the list of supported cameras when the device is
8443 collapsible and in the "expand" state
8444 * SubFunction: NA
8445 * FunctionPoints: NA
8446 * EnvConditions: NA
8447 * CaseDescription: The goal is to verify that the method correctly returns the list of supported cameras when the
8448 device is collapsible and in the "expand" state
8449 */
8450 HWTEST_F(CameraFrameworkUnitTest, get_supported_cameras_foldable_expand01, TestSize.Level0)
8451 {
8452 EXPECT_CALL(*mockCameraManager, GetIsFoldable())
8453 .WillRepeatedly(Return(true));
8454
8455 EXPECT_CALL(*mockCameraManager, GetFoldStatus())
8456 .WillRepeatedly(Return(FoldStatus::EXPAND));
8457
8458 auto changedMetadata = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
8459 int32_t cameraPosition = CAMERA_POSITION_BACK;
8460 changedMetadata->addEntry(OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
8461 int32_t foldStatus = OHOS_CAMERA_FOLD_STATUS_EXPANDED | OHOS_CAMERA_FOLD_STATUS_FOLDED;
8462 changedMetadata->addEntry(OHOS_ABILITY_CAMERA_FOLD_STATUS, &foldStatus, 1);
8463 auto camera0 = new CameraDevice("device0", changedMetadata);
8464
8465 auto changedMetadata1 = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
8466 cameraPosition = CAMERA_POSITION_FRONT;
8467 changedMetadata1->addEntry(OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
8468 foldStatus = OHOS_CAMERA_FOLD_STATUS_EXPANDED;
8469 changedMetadata1->addEntry(OHOS_ABILITY_CAMERA_FOLD_STATUS, &foldStatus, 1);
8470 auto camera1 = new CameraDevice("device1", changedMetadata1);
8471
8472 std::vector<sptr<CameraDevice>> expectedCameraList;
8473 expectedCameraList.emplace_back(camera0);
8474 expectedCameraList.emplace_back(camera1);
8475 mockCameraManager->cameraDeviceList_ = expectedCameraList;
8476 auto result = mockCameraManager->GetSupportedCameras();
8477
8478 ASSERT_EQ(result.size(), 2);
8479 }
8480
8481 /*
8482 * Feature: Framework
8483 * Function: The goal is to verify that the method correctly returns the list of supported cameras when the device is
8484 collapsible and in the "expand" state
8485 * SubFunction: NA
8486 * FunctionPoints: NA
8487 * EnvConditions: NA
8488 * CaseDescription: The goal is to verify that the method correctly returns the list of supported cameras when the
8489 device is collapsible and in the "expand" state
8490 */
8491 HWTEST_F(CameraFrameworkUnitTest, get_supported_cameras_foldable_expand02, TestSize.Level0)
8492 {
8493 EXPECT_CALL(*mockCameraManager, GetIsFoldable())
8494 .WillRepeatedly(Return(true));
8495
8496 EXPECT_CALL(*mockCameraManager, GetFoldStatus())
8497 .WillRepeatedly(Return(FoldStatus::EXPAND));
8498
8499 auto changedMetadata = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
8500 int32_t cameraPosition = CAMERA_POSITION_BACK;
8501 changedMetadata->addEntry(OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
8502 int32_t foldStatus = OHOS_CAMERA_FOLD_STATUS_EXPANDED | OHOS_CAMERA_FOLD_STATUS_FOLDED;
8503 changedMetadata->addEntry(OHOS_ABILITY_CAMERA_FOLD_STATUS, &foldStatus, 1);
8504 auto camera0 = new CameraDevice("device0", changedMetadata);
8505
8506 auto changedMetadata1 = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
8507 cameraPosition = CAMERA_POSITION_FRONT;
8508 changedMetadata1->addEntry(OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
8509 foldStatus = OHOS_CAMERA_FOLD_STATUS_FOLDED;
8510 changedMetadata1->addEntry(OHOS_ABILITY_CAMERA_FOLD_STATUS, &foldStatus, 1);
8511 auto camera1 = new CameraDevice("device1", changedMetadata1);
8512
8513 std::vector<sptr<CameraDevice>> expectedCameraList;
8514 expectedCameraList.emplace_back(camera0);
8515 expectedCameraList.emplace_back(camera1);
8516 mockCameraManager->cameraDeviceList_ = expectedCameraList;
8517 auto result = mockCameraManager->GetSupportedCameras();
8518
8519 ASSERT_EQ(result.size(), 1);
8520 }
8521
8522 /*
8523 * Feature: Framework
8524 * Function: In the scenario where the device is foldable and in a folded state, the goal is to ensure that the method
8525 correctly returns the list of cameras that support the current folded state.
8526 * SubFunction: NA
8527 * FunctionPoints: NA
8528 * EnvConditions: NA
8529 * CaseDescription: In the scenario where the device is foldable and in a folded state, the goal is to ensure that the
8530 method correctly returns the list of cameras that support the current folded state.
8531 */
8532 HWTEST_F(CameraFrameworkUnitTest, get_supported_cameras_foldable_fold, TestSize.Level0)
8533 {
8534 EXPECT_CALL(*mockCameraManager, GetIsFoldable())
8535 .WillRepeatedly(Return(true));
8536
8537 EXPECT_CALL(*mockCameraManager, GetFoldStatus())
8538 .WillRepeatedly(Return(FoldStatus::FOLDED));
8539
8540 auto changedMetadata = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
8541 int32_t cameraPosition = CAMERA_POSITION_BACK;
8542 changedMetadata->addEntry(OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
8543 int32_t foldStatus = OHOS_CAMERA_FOLD_STATUS_EXPANDED | OHOS_CAMERA_FOLD_STATUS_FOLDED;
8544 changedMetadata->addEntry(OHOS_ABILITY_CAMERA_FOLD_STATUS, &foldStatus, 1);
8545 auto camera0 = new CameraDevice("device0", changedMetadata);
8546
8547 auto changedMetadata1 = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
8548 cameraPosition = CAMERA_POSITION_FRONT;
8549 changedMetadata1->addEntry(OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
8550 foldStatus = OHOS_CAMERA_FOLD_STATUS_FOLDED;
8551 changedMetadata1->addEntry(OHOS_ABILITY_CAMERA_FOLD_STATUS, &foldStatus, 1);
8552 auto camera1 = new CameraDevice("device1", changedMetadata1);
8553
8554 std::vector<sptr<CameraDevice>> expectedCameraList;
8555 expectedCameraList.emplace_back(camera0);
8556 expectedCameraList.emplace_back(camera1);
8557 mockCameraManager->cameraDeviceList_ = expectedCameraList;
8558 auto result = mockCameraManager->GetSupportedCameras();
8559
8560 ASSERT_EQ(result.size(), 2);
8561 }
8562
8563 /*
8564 * Feature: Framework
8565 * Function: The unit test get_supported_cameras_foldable_half_fold checks the behavior of the
8566 CameraManager::GetSupportedCameras method when the device is foldable and in a half-folded state.
8567 * SubFunction: NA
8568 * FunctionPoints: NA
8569 * EnvConditions: NA
8570 * CaseDescription: The unit test get_supported_cameras_foldable_half_fold checks the behavior of the
8571 CameraManager::GetSupportedCameras method when the device is foldable and in a half-folded state.
8572 */
8573 HWTEST_F(CameraFrameworkUnitTest, get_supported_cameras_foldable_half_fold, TestSize.Level0)
8574 {
8575 EXPECT_CALL(*mockCameraManager, GetIsFoldable())
8576 .WillRepeatedly(Return(true));
8577
8578 EXPECT_CALL(*mockCameraManager, GetFoldStatus())
8579 .WillRepeatedly(Return(FoldStatus::HALF_FOLD));
8580
8581 auto changedMetadata = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
8582 int32_t cameraPosition = CAMERA_POSITION_BACK;
8583 changedMetadata->addEntry(OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
8584 int32_t foldStatus = OHOS_CAMERA_FOLD_STATUS_EXPANDED | OHOS_CAMERA_FOLD_STATUS_FOLDED;
8585 changedMetadata->addEntry(OHOS_ABILITY_CAMERA_FOLD_STATUS, &foldStatus, 1);
8586 auto camera0 = new CameraDevice("device0", changedMetadata);
8587
8588 auto changedMetadata1 = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
8589 cameraPosition = CAMERA_POSITION_FRONT;
8590 changedMetadata1->addEntry(OHOS_ABILITY_CAMERA_POSITION, &cameraPosition, 1);
8591 foldStatus = OHOS_CAMERA_FOLD_STATUS_FOLDED;
8592 changedMetadata1->addEntry(OHOS_ABILITY_CAMERA_FOLD_STATUS, &foldStatus, 1);
8593 auto camera1 = new CameraDevice("device1", changedMetadata1);
8594
8595 std::vector<sptr<CameraDevice>> expectedCameraList;
8596 expectedCameraList.emplace_back(camera0);
8597 expectedCameraList.emplace_back(camera1);
8598 mockCameraManager->cameraDeviceList_ = expectedCameraList;
8599 auto result = mockCameraManager->GetSupportedCameras();
8600 ASSERT_EQ(result.size(), 1);
8601 }
8602 } // CameraStandard
8603 } // OHOS
8604