1 /*
2 * Copyright (c) 2022-2023 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 <gtest/gtest.h>
17 #include "dcameraprovidercase.h"
18 #include "dcameratest.h"
19 #include "dcamera_provider_callback_impl.h"
20 #include "dcamera_provider.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace DistributedHardware {
26 class DCameraProviderTest : public testing::Test {
27 public:
28 static void SetUpTestCase(void);
29 static void TearDownTestCase(void);
30 void SetUp();
31 void TearDown();
32
33 std::shared_ptr<DCameraSourceDev> camDev_;
34 std::shared_ptr<ICameraStateListener> stateListener_;
35 sptr<IDCameraProviderCallback> hdiCallback_;
36 };
37
38 namespace {
39 const std::string testDeviceId = "bb536a637105409e904d4da83790a4a7";
40 const std::string testCameraDh = "camera_0";
41 const std::string testReqId = "0xFFFF";
42 const std::string testParam = R"({"CodecType": ["avenc_mpeg4"],
43 "OutputFormat": {"Photo":[4], "Preview":[2, 3], "Video":[2, 3]},
44 "Position": "BACK",
45 "ProtocolVer": "1.0",
46 "MetaData": "",
47 "Resolution": {
48 "2": ["1920*1080", "1504*720", "1440*1080", "1280*960", "1280*720", "1232*768", "1152*720", "960*720", "960*544",
49 "880*720", "720*720", "720*480", "640*480", "352*288", "320*240"],
50 "3": ["1920*1080", "1504*720", "1440*1080", "1280*960", "1280*720", "1232*768", "1152*720", "960*720", "960*544",
51 "880*720", "720*720", "720*480", "640*480", "352*288", "320*240"],
52 "4": ["3840*2160", "3264*2448", "3264*1840", "2304*1728", "2048*1536", "1920*1440", "1920*1080", "1744*1088",
53 "1280*720", "1232*768", "1152*720", "640*480", "320*240"]}})";
54 const int32_t TEST_WIDTH = 1920;
55 const int32_t TEST_HEIGTH = 1080;
56 const int32_t TEST_STREAMID = 2;
57 }
58
59 std::vector<DCStreamInfo> streamInfos;
60 std::vector<DCStreamInfo> streamInfos1;
61 std::vector<DCStreamInfo> streamInfos2;
62 std::vector<DCStreamInfo> streamInfos3;
63 std::vector<DCStreamInfo> streamInfos4;
64 std::vector<DCCaptureInfo> captureInfos;
65 std::vector<DCCaptureInfo> captureInfos1;
66 std::vector<DCCaptureInfo> captureInfos2;
67 std::vector<DCameraSettings> settings;
68 std::vector<int> streamIds;
69 DCameraSettings result;
70 DCameraSettings result1;
71 DCameraSettings result2;
72 DCameraSettings result3;
73 DCameraSettings result4;
74 DCameraSettings result5;
75 DCameraSettings result6;
76 DCStreamInfo streamInfo2;
77 DCStreamInfo streamInfo3;
78 DCStreamInfo streamInfo4;
79 DCStreamInfo streamInfo5;
80 DCCaptureInfo captureInfo2;
81 DCCaptureInfo captureInfo3;
82 DHBase dhBase;
83 DCameraProvider cameraProvider;
84 DCameraBuffer buffer;
85 DCameraHDFEvent hdiEvent;
86
SetUpTestCase(void)87 void DCameraProviderTest::SetUpTestCase(void)
88 {
89 dhBase.deviceId_ = testDeviceId;
90 dhBase.dhId_ = testCameraDh;
91
92 hdiEvent.type_ = 0;
93 hdiEvent.result_ = 1;
94 hdiEvent.content_ = 9;
95
96 result.type_ = METADATA_RESULT;
97 result.value_ = "SettingValue";
98
99 DCStreamInfo streamInfo1;
100 streamInfo1.streamId_ = 1;
101 streamInfo1.width_ = TEST_WIDTH;
102 streamInfo1.height_ = TEST_HEIGTH;
103 streamInfo1.stride_ = 1;
104 streamInfo1.format_ = 1;
105 streamInfo1.dataspace_ = 1;
106 streamInfo1.encodeType_ = ENCODE_TYPE_JPEG;
107 streamInfo1.type_ = SNAPSHOT_FRAME;
108 streamInfos.push_back(streamInfo1);
109
110 streamIds.push_back(1);
111 streamIds.push_back(TEST_STREAMID);
112
113 DCCaptureInfo captureInfo1;
114 captureInfo1.streamIds_.push_back(1);
115 captureInfo1.width_ = TEST_WIDTH;
116 captureInfo1.height_ = TEST_HEIGTH;
117 captureInfo1.stride_ = 1;
118 captureInfo1.format_ = 1;
119 captureInfo1.dataspace_ = 1;
120 captureInfo1.encodeType_ = ENCODE_TYPE_H265;
121 captureInfo1.type_ = CONTINUOUS_FRAME;
122 captureInfos.push_back(captureInfo1);
123
124 settings.push_back(result);
125 }
126
TearDownTestCase(void)127 void DCameraProviderTest::TearDownTestCase(void) {}
128
SetUp(void)129 void DCameraProviderTest::SetUp(void)
130 {
131 stateListener_ = std::make_shared<HdiDCameraSourceStateListener>();
132 camDev_ = std::make_shared<HdiDCameraSourceDev>(testDeviceId, testCameraDh, stateListener_);
133 hdiCallback_ = new (std::nothrow)DCameraProviderCallbackImpl(testDeviceId, testCameraDh, camDev_);
134 }
135
TearDown(void)136 void DCameraProviderTest::TearDown(void)
137 {
138 hdiCallback_ = nullptr;
139 camDev_ = nullptr;
140 stateListener_ = nullptr;
141 }
142
143 HWTEST_F(DCameraProviderTest, DCameraCase_0010, TestSize.Level1)
144 {
145 int32_t ret = cameraProvider.EnableDCameraDevice(dhBase, testParam, hdiCallback_);
146 EXPECT_EQ(0, ret) << "EnableDCameraDevice fail";
147 }
148
149 HWTEST_F(DCameraProviderTest, DCameraCase_0020, TestSize.Level1)
150 {
151 int32_t ret = cameraProvider.OpenSession(dhBase);
152 EXPECT_NE(0, ret) << "OpenSession fail";
153 }
154
155 HWTEST_F(DCameraProviderTest, DCameraCase_0030, TestSize.Level1)
156 {
157 int32_t ret = cameraProvider.ConfigureStreams(dhBase, streamInfos);
158 EXPECT_NE(0, ret) << "ConfigureStreams fail";
159 }
160
161 HWTEST_F(DCameraProviderTest, DCameraCase_0040, TestSize.Level1)
162 {
163 int32_t ret = cameraProvider.StartCapture(dhBase, captureInfos);
164 EXPECT_NE(0, ret) << "StartCapture fail";
165 }
166
167 HWTEST_F(DCameraProviderTest, DCameraCase_0050, TestSize.Level1)
168 {
169 int32_t ret = cameraProvider.OnSettingsResult(dhBase, result);
170 EXPECT_NE(0, ret) << "OnSettingsResult fail";
171 }
172
173 HWTEST_F(DCameraProviderTest, DCameraCase_0060, TestSize.Level1)
174 {
175 result1.type_ = UPDATE_METADATA;
176 result1.value_ = "SettingValue";
177 int32_t ret = cameraProvider.OnSettingsResult(dhBase, result1);
178 EXPECT_NE(0, ret) << "OnSettingsResult fail";
179 }
180
181 HWTEST_F(DCameraProviderTest, DCameraCase_0070, TestSize.Level1)
182 {
183 result2.type_ = ENABLE_METADATA;
184 result2.value_ = "SettingValue";
185 int32_t ret = cameraProvider.OnSettingsResult(dhBase, result2);
186 EXPECT_NE(0, ret) << "OnSettingsResult fail";
187 }
188
189 HWTEST_F(DCameraProviderTest, DCameraCase_0080, TestSize.Level1)
190 {
191 result3.type_ = DISABLE_METADATA;
192 result3.value_ = "SettingValue";
193 int32_t ret = cameraProvider.OnSettingsResult(dhBase, result3);
194 EXPECT_NE(0, ret) << "OnSettingsResult fail";
195 }
196
197 HWTEST_F(DCameraProviderTest, DCameraCase_0090, TestSize.Level1)
198 {
199 result4.type_ = SET_FLASH_LIGHT;
200 result4.value_ = "SettingValue";
201 int32_t ret = cameraProvider.OnSettingsResult(dhBase, result4);
202 EXPECT_NE(0, ret) << "OnSettingsResult fail";
203 }
204
205 HWTEST_F(DCameraProviderTest, DCameraCase_0100, TestSize.Level1)
206 {
207 result5.type_ = FPS_RANGE;
208 result5.value_ = "SettingValue";
209 int32_t ret = cameraProvider.OnSettingsResult(dhBase, result5);
210 EXPECT_NE(0, ret) << "OnSettingsResult fail";
211 }
212
213 HWTEST_F(DCameraProviderTest, DCameraCase_0110, TestSize.Level1)
214 {
215 result6.type_ = UPDATE_FRAME_METADATA;
216 result6.value_ = "SettingValue";
217 int32_t ret = cameraProvider.OnSettingsResult(dhBase, result6);
218 EXPECT_NE(0, ret) << "OnSettingsResult fail";
219 }
220
221 HWTEST_F(DCameraProviderTest, DCameraCase_0120, TestSize.Level1)
222 {
223 int32_t ret = cameraProvider.UpdateSettings(dhBase, settings);
224 EXPECT_NE(0, ret) << "UpdateSettings fail";
225 }
226
227 HWTEST_F(DCameraProviderTest, DCameraCase_0130, TestSize.Level1)
228 {
229 int32_t ret = cameraProvider.AcquireBuffer(dhBase, TEST_STREAMID, buffer);
230 EXPECT_NE(0, ret) << "AcquireBuffer fail";
231 }
232
233 HWTEST_F(DCameraProviderTest, DCameraCase_0140, TestSize.Level1)
234 {
235 int32_t ret = cameraProvider.Notify(dhBase, hdiEvent);
236 EXPECT_EQ(0, ret) << "Notify fail";
237 }
238
239 HWTEST_F(DCameraProviderTest, DCameraCase_0150, TestSize.Level1)
240 {
241 int32_t ret = cameraProvider.ShutterBuffer(dhBase, TEST_STREAMID, buffer);
242 EXPECT_NE(0, ret) << "ShutterBuffer fail";
243 }
244
245 HWTEST_F(DCameraProviderTest, DCameraCase_0160, TestSize.Level1)
246 {
247 int32_t ret = cameraProvider.StopCapture(dhBase, streamIds);
248 EXPECT_NE(0, ret) << "StopCapture fail";
249 }
250
251 HWTEST_F(DCameraProviderTest, DCameraCase_0170, TestSize.Level1)
252 {
253 int32_t ret = cameraProvider.ReleaseStreams(dhBase, streamIds);
254 EXPECT_NE(0, ret) << "ReleaseStreams fail";
255 }
256
257
258 HWTEST_F(DCameraProviderTest, DCameraCase_0180, TestSize.Level1)
259 {
260 int32_t ret = cameraProvider.CloseSession(dhBase);
261 EXPECT_NE(0, ret) << "CloseSession fail";
262 }
263
264 HWTEST_F(DCameraProviderTest, DCameraCase_0190, TestSize.Level1)
265 {
266 int32_t ret = cameraProvider.DisableDCameraDevice(dhBase);
267 EXPECT_EQ(0, ret) << "DisableDCameraDevice fail";
268 }
269
270 HWTEST_F(DCameraProviderTest, DCameraCase_0200, TestSize.Level1)
271 {
272 int32_t ret = cameraProvider.OpenSession(dhBase);
273 EXPECT_NE(SUCCESS, ret) << "OpenSession fail";
274 }
275
276 HWTEST_F(DCameraProviderTest, DCameraCase_0210, TestSize.Level1)
277 {
278 int32_t ret = cameraProvider.ConfigureStreams(dhBase, streamInfos);
279 EXPECT_NE(CAMERA_BUSY, ret) << "ConfigureStreams fail";
280 }
281
282 HWTEST_F(DCameraProviderTest, DCameraCase_0220, TestSize.Level1)
283 {
284 int32_t ret = cameraProvider.StartCapture(dhBase, captureInfos);
285 EXPECT_EQ(INVALID_ARGUMENT, ret) << "StartCapture fail";
286 }
287
288 HWTEST_F(DCameraProviderTest, DCameraCase_0230, TestSize.Level1)
289 {
290 int32_t ret = cameraProvider.OnSettingsResult(dhBase, result);
291 EXPECT_NE(METHOD_NOT_SUPPORTED, ret) << "OnSettingsResult fail";
292 }
293
294 HWTEST_F(DCameraProviderTest, DCameraCase_0240, TestSize.Level1)
295 {
296 int32_t ret = cameraProvider.UpdateSettings(dhBase, settings);
297 EXPECT_NE(CAMERA_OFFLINE, ret) << "UpdateSettings fail";
298 }
299
300 HWTEST_F(DCameraProviderTest, DCameraCase_0250, TestSize.Level1)
301 {
302 int32_t ret = cameraProvider.AcquireBuffer(dhBase, TEST_STREAMID, buffer);
303 EXPECT_NE(EXCEED_MAX_NUMBER, ret) << "AcquireBuffer fail";
304 }
305
306 HWTEST_F(DCameraProviderTest, DCameraCase_0260, TestSize.Level1)
307 {
308 int32_t ret = cameraProvider.Notify(dhBase, hdiEvent);
309 EXPECT_NE(DEVICE_NOT_INIT, ret) << "Notify fail";
310 }
311
312 HWTEST_F(DCameraProviderTest, DCameraCase_0270, TestSize.Level1)
313 {
314 int32_t ret = cameraProvider.ShutterBuffer(dhBase, TEST_STREAMID, buffer);
315 EXPECT_NE(FAILED, ret) << "ShutterBuffer fail";
316 }
317
318 HWTEST_F(DCameraProviderTest, DCameraCase_0280, TestSize.Level1)
319 {
320 streamInfo2.streamId_ = 1;
321 streamInfo2.width_ = TEST_WIDTH;
322 streamInfo2.height_ = TEST_HEIGTH;
323 streamInfo2.stride_ = 1;
324 streamInfo2.format_ = 1;
325 streamInfo2.dataspace_ = 1;
326 streamInfo2.encodeType_ = ENCODE_TYPE_NULL;
327 streamInfo2.type_ = SNAPSHOT_FRAME;
328 streamInfos1.push_back(streamInfo2);
329 int32_t ret = cameraProvider.ConfigureStreams(dhBase, streamInfos1);
330 EXPECT_NE(0, ret) << "ConfigureStreams fail";
331 }
332
333 HWTEST_F(DCameraProviderTest, DCameraCase_0290, TestSize.Level1)
334 {
335 streamInfo3.streamId_ = 1;
336 streamInfo3.width_ = TEST_WIDTH;
337 streamInfo3.height_ = TEST_HEIGTH;
338 streamInfo3.stride_ = 1;
339 streamInfo3.format_ = 1;
340 streamInfo3.dataspace_ = 1;
341 streamInfo3.encodeType_ = ENCODE_TYPE_H264;
342 streamInfo3.type_ = SNAPSHOT_FRAME;
343 streamInfos2.push_back(streamInfo3);
344 int32_t ret = cameraProvider.ConfigureStreams(dhBase, streamInfos2);
345 EXPECT_NE(0, ret) << "ConfigureStreams fail";
346 }
347
348 HWTEST_F(DCameraProviderTest, DCameraCase_3000, TestSize.Level1)
349 {
350 streamInfo4.streamId_ = 1;
351 streamInfo4.width_ = TEST_WIDTH;
352 streamInfo4.height_ = TEST_HEIGTH;
353 streamInfo4.stride_ = 1;
354 streamInfo4.format_ = 1;
355 streamInfo4.dataspace_ = 1;
356 streamInfo4.encodeType_ = ENCODE_TYPE_H265;
357 streamInfo4.type_ = SNAPSHOT_FRAME;
358 streamInfos3.push_back(streamInfo4);
359 int32_t ret = cameraProvider.ConfigureStreams(dhBase, streamInfos3);
360 EXPECT_NE(0, ret) << "ConfigureStreams fail";
361 }
362
363 HWTEST_F(DCameraProviderTest, DCameraCase_3001, TestSize.Level1)
364 {
365 streamInfo5.streamId_ = 1;
366 streamInfo5.width_ = TEST_WIDTH;
367 streamInfo5.height_ = TEST_HEIGTH;
368 streamInfo5.stride_ = 1;
369 streamInfo5.format_ = 1;
370 streamInfo5.dataspace_ = 1;
371 streamInfo5.encodeType_ = ENCODE_TYPE_JPEG;
372 streamInfo5.type_ = SNAPSHOT_FRAME;
373 streamInfos4.push_back(streamInfo5);
374 int32_t ret = cameraProvider.ConfigureStreams(dhBase, streamInfos4);
375 EXPECT_NE(0, ret) << "ConfigureStreams fail";
376 }
377
378 HWTEST_F(DCameraProviderTest, DCameraCase_3002, TestSize.Level1)
379 {
380 captureInfo2.streamIds_.push_back(1);
381 captureInfo2.width_ = TEST_WIDTH;
382 captureInfo2.height_ = TEST_HEIGTH;
383 captureInfo2.stride_ = 1;
384 captureInfo2.format_ = 1;
385 captureInfo2.dataspace_ = 1;
386 captureInfo2.encodeType_ = ENCODE_TYPE_H265;
387 captureInfo2.type_ = CONTINUOUS_FRAME;
388 captureInfos1.push_back(captureInfo2);
389 int32_t ret = cameraProvider.StartCapture(dhBase, captureInfos1);
390 EXPECT_EQ(INVALID_ARGUMENT, ret) << "StartCapture fail";
391 }
392
393 HWTEST_F(DCameraProviderTest, DCameraCase_3003, TestSize.Level1)
394 {
395 captureInfo3.streamIds_.push_back(1);
396 captureInfo3.width_ = TEST_WIDTH;
397 captureInfo3.height_ = TEST_HEIGTH;
398 captureInfo3.stride_ = 1;
399 captureInfo3.format_ = 1;
400 captureInfo3.dataspace_ = 1;
401 captureInfo3.encodeType_ = ENCODE_TYPE_H265;
402 captureInfo3.type_ = SNAPSHOT_FRAME;
403 captureInfos2.push_back(captureInfo3);
404 int32_t ret = cameraProvider.StartCapture(dhBase, captureInfos2);
405 EXPECT_EQ(INVALID_ARGUMENT, ret) << "StartCapture fail";
406 }
407 }
408 }