1 /*
2 * Copyright (c) 2021 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 "hdi_test.h"
17
18 constexpr int ITEM_CAPACITY_SIZE = 100;
19 constexpr int DATA_CAPACITY_SIZE = 2000;
20
SetUpTestCase(void)21 void UtestHdiTest::SetUpTestCase(void)
22 {}
TearDownTestCase(void)23 void UtestHdiTest::TearDownTestCase(void)
24 {}
SetUp(void)25 void UtestHdiTest::SetUp(void)
26 {
27 if (cameraBase == nullptr)
28 cameraBase = std::make_shared<TestCameraBase>();
29 cameraBase->FBInit();
30 cameraBase->Init();
31 }
TearDown(void)32 void UtestHdiTest::TearDown(void)
33 {
34 cameraBase->Close();
35 }
36
37 /**
38 * @tc.name: GetCameraIds
39 * @tc.desc: CamRetCode GetCameraIds([out] String[] ids);
40 * @tc.level: Level0
41 * @tc.size: MediumTest
42 * @tc.type: Function
43 */
TEST_F(UtestHdiTest,camera_hdi_0010)44 TEST_F(UtestHdiTest, camera_hdi_0010)
45 {
46 std::cout << "==========[test log] GetCameraIds([out] String[] ids)." << std::endl;
47 if (cameraBase->cameraDevice == nullptr) {
48 sleep(3); // waiting 3s, prepare for execute GetCameraIds.
49 cameraBase->rc = cameraBase->cameraHost->GetCameraIds(cameraBase->cameraIds);
50 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
51 EXPECT_LT(0, cameraBase->cameraIds.size());
52 std::cout << "==========[test log] cameraIds.size()= ."<< cameraBase->cameraIds.size() << std::endl;
53 }
54 }
55
56 /**
57 * @tc.name: GetCameraAbility
58 * @tc.desc: GetCameraAbility, normal cameraId.
59 * @tc.level: Level0
60 * @tc.size: MediumTest
61 * @tc.type: Function
62 */
TEST_F(UtestHdiTest,camera_hdi_0020)63 TEST_F(UtestHdiTest, camera_hdi_0020)
64 {
65 std::cout << "==========[test log] GetCameraAbility, normal cameraId." << std::endl;
66 std::shared_ptr<CameraAbility> ability;
67 if (cameraBase->cameraDevice == nullptr) {
68 sleep(3); // waiting 3s, prepare for execute GetCameraIds.
69 cameraBase->rc = cameraBase->cameraHost->GetCameraIds(cameraBase->cameraIds);
70 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
71 for (int i = 0; i < cameraBase->cameraIds.size(); i++) {
72 cameraBase->rc = cameraBase->cameraHost->GetCameraAbility(cameraBase->cameraIds[i], ability);
73 std::cout << "==========[test log] GetCameraAbility, cameraid = ";
74 std::cout << cameraBase->cameraIds[i] << std::endl;
75 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
76 }
77 }
78 }
79
80 /**
81 * @tc.name: GetCameraAbility
82 * @tc.desc: GetCameraAbility, abnormal cameraId = 'abc'.
83 * @tc.level: Level2
84 * @tc.size: MediumTest
85 * @tc.type: Function
86 */
TEST_F(UtestHdiTest,camera_hdi_0021)87 TEST_F(UtestHdiTest, camera_hdi_0021)
88 {
89 std::cout << "==========[test log] GetCameraAbility, abnormal cameraId = 'abc'." << std::endl;
90 std::shared_ptr<CameraAbility> ability;
91 if (cameraBase->cameraDevice == nullptr) {
92 std::string cameraId = "abc";
93 sleep(3); // waiting 3s, prepare for execute GetCameraAbility.
94 cameraBase->rc = cameraBase->cameraHost->GetCameraAbility(cameraId, ability);
95 std::cout << "==========[test log] cameraBase->rc ="<< cameraBase->rc << std::endl;
96 EXPECT_EQ(true, cameraBase->rc == INVALID_ARGUMENT);
97 }
98 }
99
100 /**
101 * @tc.name: GetCameraAbility
102 * @tc.desc: GetCameraAbility, abnormal cameraId = ''
103 * @tc.level: Level2
104 * @tc.size: MediumTest
105 * @tc.type: Function
106 */
TEST_F(UtestHdiTest,camera_hdi_0022)107 TEST_F(UtestHdiTest, camera_hdi_0022)
108 {
109 std::cout << "==========[test log] GetCameraAbility, abnormal cameraId = ''." << std::endl;
110 std::shared_ptr<CameraAbility> ability;
111 if (cameraBase->cameraDevice == nullptr) {
112 std::string cameraId = "";
113 sleep(2); // waiting 2s, prepare for execute GetCameraAbility.
114 cameraBase->rc = cameraBase->cameraHost->GetCameraAbility(cameraId, ability);
115 std::cout << "==========[test log] cameraBase->rc ="<< cameraBase->rc << std::endl;
116 EXPECT_EQ(true, cameraBase->rc == INVALID_ARGUMENT);
117 }
118 }
119
120 /**
121 * @tc.name: OpenCamera
122 * @tc.desc: OpenCamera, normal cameraId.
123 * @tc.level: Level0
124 * @tc.size: MediumTest
125 * @tc.type: Function
126 */
TEST_F(UtestHdiTest,camera_hdi_0030)127 TEST_F(UtestHdiTest, camera_hdi_0030)
128 {
129 std::cout << "==========[test log] OpenCamera, normal cameraId."<< std::endl;
130 if (cameraBase->cameraDevice == nullptr) {
131 sleep(3); // waiting 3s, prepare for execute GetCameraIds.
132 cameraBase->cameraHost->GetCameraIds(cameraBase->cameraIds);
133 const std::shared_ptr<ICameraDeviceCallback> callback =
134 std::make_shared<ICameraDeviceCallback>();
135 cameraBase->rc = cameraBase->cameraHost->OpenCamera(cameraBase->cameraIds.front(),
136 callback, cameraBase->cameraDevice);
137 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
138 if (cameraBase->rc != NO_ERROR || cameraBase->cameraDevice == nullptr) {
139 std::cout << "==========[test log] OpenCamera failed." << std::endl;
140 return;
141 }
142 std::cout << "==========[test log] OpenCamera success." << std::endl;
143 }
144 }
145
146 /**
147 * @tc.name: OpenCamera
148 * @tc.desc: OpenCamera, cameraID is not found.
149 * @tc.level: Level2
150 * @tc.size: MediumTest
151 * @tc.type: Function
152 */
TEST_F(UtestHdiTest,camera_hdi_0031)153 TEST_F(UtestHdiTest, camera_hdi_0031)
154 {
155 std::cout << "==========[test log] OpenCamera, cameraID is not found."<< std::endl;
156 if (cameraBase->cameraDevice == nullptr) {
157 std::string cameraId = "qwerty";
158 const std::shared_ptr<ICameraDeviceCallback> callback =
159 std::make_shared<ICameraDeviceCallback>();
160 sleep(3); // waiting 3s, prepare for execute OpenCamera.
161 cameraBase->rc = cameraBase->cameraHost->OpenCamera(cameraId, callback, cameraBase->cameraDevice);
162 EXPECT_EQ(true, cameraBase->rc == INVALID_ARGUMENT);
163 }
164 }
165
166 /**
167 * @tc.name: OpenCamera
168 * @tc.desc: OpenCamera, cameraID is illegal.
169 * @tc.level: Level2
170 * @tc.size: MediumTest
171 * @tc.type: Function
172 */
TEST_F(UtestHdiTest,camera_hdi_0032)173 TEST_F(UtestHdiTest, camera_hdi_0032)
174 {
175 std::cout << "==========[test log] OpenCamera, cameraID is illegal."<< std::endl;
176 if (cameraBase->cameraDevice == nullptr) {
177 std::string cameraId = "1";
178 const std::shared_ptr<ICameraDeviceCallback> callback =
179 std::make_shared<ICameraDeviceCallback>();
180 sleep(3); // waiting 3s, prepare for execute OpenCamera.
181 cameraBase->rc = cameraBase->cameraHost->OpenCamera(cameraId, callback, cameraBase->cameraDevice);
182 EXPECT_EQ(true, cameraBase->rc == INVALID_ARGUMENT);
183 }
184 }
185
186 /**
187 * @tc.name: OpenCamera
188 * @tc.desc: OpenCamera, cameraID is Empty.
189 * @tc.level: Level2
190 * @tc.size: MediumTest
191 * @tc.type: Function
192 */
TEST_F(UtestHdiTest,camera_hdi_0033)193 TEST_F(UtestHdiTest, camera_hdi_0033)
194 {
195 std::cout << "==========[test log] OpenCamera, cameraID is Empty."<< std::endl;
196 if (cameraBase->cameraDevice == nullptr) {
197 std::string cameraId = "";
198 const std::shared_ptr<ICameraDeviceCallback> callback =
199 std::make_shared<ICameraDeviceCallback>();
200 sleep(3); // waiting 3s, prepare for execute OpenCamera.
201 cameraBase->rc = cameraBase->cameraHost->OpenCamera(cameraId, callback, cameraBase->cameraDevice);
202 EXPECT_EQ(true, cameraBase->rc == INVALID_ARGUMENT);
203 }
204 }
205
206 /**
207 * @tc.name: OpenCamera
208 * @tc.desc: OpenCamera, Callback is Null.
209 * @tc.level: Level2
210 * @tc.size: MediumTest
211 * @tc.type: Function
212 */
TEST_F(UtestHdiTest,camera_hdi_0034)213 TEST_F(UtestHdiTest, camera_hdi_0034)
214 {
215 std::cout << "==========[test log] OpenCamera, Callback is Null."<< std::endl;
216 if (cameraBase->cameraDevice == nullptr) {
217 sleep(3); // waiting 3s, prepare for execute GetCameraIds.
218 cameraBase->cameraHost->GetCameraIds(cameraBase->cameraIds);
219 const std::shared_ptr<ICameraDeviceCallback> callback = nullptr;
220 cameraBase->rc = cameraBase->cameraHost->OpenCamera(cameraBase->cameraIds.front(),
221 callback, cameraBase->cameraDevice);
222 EXPECT_EQ(true, cameraBase->rc == INVALID_ARGUMENT);
223 }
224 }
225
226 /**
227 * @tc.name: OpenCamera
228 * @tc.desc: cameraID is not found, callback is null.
229 * @tc.level: Level1
230 * @tc.size: MediumTest
231 * @tc.type: Function
232 */
TEST_F(UtestHdiTest,camera_hdi_0035)233 TEST_F(UtestHdiTest, camera_hdi_0035)
234 {
235 std::cout << "==========[test log] OpenCamera, cameraID is not found, callback is null."<< std::endl;
236 if (cameraBase->cameraDevice == nullptr) {
237 std::string cameraId = "abc";
238 const std::shared_ptr<ICameraDeviceCallback> callback = nullptr;
239 sleep(3); // waiting 3s, prepare for execute OpenCamera.
240 cameraBase->rc = cameraBase->cameraHost->OpenCamera(cameraId, callback, cameraBase->cameraDevice);
241 EXPECT_EQ(true, cameraBase->rc == INVALID_ARGUMENT);
242 }
243 }
244
245 /**
246 * @tc.name: GetStreamOprator
247 * @tc.desc: GetStreamOprator, normal callback input.
248 * @tc.level: Level0
249 * @tc.size: MediumTest
250 * @tc.type: Function
251 */
TEST_F(UtestHdiTest,camera_hdi_0050)252 TEST_F(UtestHdiTest, camera_hdi_0050)
253 {
254 std::cout << "==========[test log] GetStreamOprator, normal callback input." << std::endl;
255 sleep(3); // waiting 3s, prepare for execute OpenCamera.
256 cameraBase->OpenCamera();
257 cameraBase->streamOperatorCallback = std::make_shared<IStreamOperatorCallback>();
258 cameraBase->rc = cameraBase->cameraDevice->GetStreamOperator(cameraBase->streamOperatorCallback,
259 cameraBase->streamOperator);
260 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
261 }
262
263 /**
264 * @tc.name: GetStreamOprator
265 * @tc.desc: GetStreamOprator, callback is nullptr.
266 * @tc.level: Level2
267 * @tc.size: MediumTest
268 * @tc.type: Function
269 */
TEST_F(UtestHdiTest,camera_hdi_0051)270 TEST_F(UtestHdiTest, camera_hdi_0051)
271 {
272 std::cout << "==========[test log] GetStreamOprator, normal callback input." << std::endl;
273 sleep(3); // waiting 3s, prepare for execute OpenCamera.
274 cameraBase->OpenCamera();
275 cameraBase->streamOperatorCallback = nullptr;
276 cameraBase->rc = cameraBase->cameraDevice->GetStreamOperator(cameraBase->streamOperatorCallback,
277 cameraBase->streamOperator);
278 EXPECT_EQ(true, cameraBase->rc == INVALID_ARGUMENT);
279 }
280
281 /**
282 * @tc.name: UpdateSettings
283 * @tc.desc: UpdateSettings, OHOS_CONTROL_AE_EXPOSURE_COMPENSATION.
284 * @tc.level: Level1
285 * @tc.size: MediumTest
286 * @tc.type: Function
287 */
TEST_F(UtestHdiTest,camera_hdi_0060)288 TEST_F(UtestHdiTest, camera_hdi_0060)
289 {
290 std::cout << "==========[test log] UpdateSettings, OHOS_CONTROL_AE_EXPOSURE_COMPENSATION." << std::endl;
291 sleep(3); // waiting 3s, prepare for execute OpenCamera.
292 cameraBase->OpenCamera();
293 // Issue 3A parameters
294 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
295 int32_t expo = 0xa0;
296 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
297 cameraBase->rc = cameraBase->cameraDevice->UpdateSettings(meta);
298 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
299 }
300
301 /**
302 * @tc.name: UpdateSettings
303 * @tc.desc: UpdateSettings, OHOS_CAMERA_AWB_MODE:OHOS_CAMERA_AWB_MODE_AUTO.
304 * @tc.level: Level1
305 * @tc.size: MediumTest
306 * @tc.type: Function
307 */
TEST_F(UtestHdiTest,camera_hdi_0061)308 TEST_F(UtestHdiTest, camera_hdi_0061)
309 {
310 std::cout << "==========[test log] UpdateSettings, ";
311 std::cout << "OHOS_CAMERA_AWB_MODE:OHOS_CAMERA_AWB_MODE_AUTO." << std::endl;
312 sleep(3); // waiting 3s, prepare for execute OpenCamera.
313 cameraBase->OpenCamera();
314 // Issue 3A parameters
315 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
316 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_AUTO;
317 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
318 cameraBase->rc = cameraBase->cameraDevice->UpdateSettings(meta);
319 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
320 }
321
322 /**
323 * @tc.name: UpdateSettings
324 * @tc.desc: UpdateSettings, OHOS_CAMERA_AWB_MODE:OHOS_CAMERA_AWB_MODE_TWILIGHT.
325 * @tc.level: Level1
326 * @tc.size: MediumTest
327 * @tc.type: Function
328 */
TEST_F(UtestHdiTest,camera_hdi_0063)329 TEST_F(UtestHdiTest, camera_hdi_0063)
330 {
331 std::cout << "==========[test log] UpdateSettings, ";
332 std::cout << "OHOS_CAMERA_AWB_MODE:OHOS_CAMERA_AWB_MODE_TWILIGHT." << std::endl;
333 sleep(3); // waiting 3s, prepare for execute OpenCamera.
334 cameraBase->OpenCamera();
335 // Issue 3A parameters
336 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
337 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_TWILIGHT;
338 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
339 cameraBase->rc = cameraBase->cameraDevice->UpdateSettings(meta);
340 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
341 }
342
343 /**
344 * @tc.name: UpdateSettings
345 * @tc.desc: UpdateSettings, OHOS_CAMERA_AWB_MODE:OHOS_CAMERA_AWB_MODE_FLUORESCENT.
346 * @tc.level: Level1
347 * @tc.size: MediumTest
348 * @tc.type: Function
349 */
TEST_F(UtestHdiTest,camera_hdi_0065)350 TEST_F(UtestHdiTest, camera_hdi_0065)
351 {
352 std::cout << "==========[test log] UpdateSettings, ";
353 std::cout << "OHOS_CAMERA_AWB_MODE:OHOS_CAMERA_AWB_MODE_FLUORESCENT." << std::endl;
354 sleep(3); // waiting 3s, prepare for execute OpenCamera.
355 cameraBase->OpenCamera();
356 // Issue 3A parameters
357 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
358 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_FLUORESCENT;
359 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
360 cameraBase->rc = cameraBase->cameraDevice->UpdateSettings(meta);
361 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
362 }
363
364 /**
365 * @tc.name: UpdateSettings
366 * @tc.desc: UpdateSettings, OHOS_CAMERA_AWB_MODE:OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT.
367 * @tc.level: Level1
368 * @tc.size: MediumTest
369 * @tc.type: Function
370 */
TEST_F(UtestHdiTest,camera_hdi_0066)371 TEST_F(UtestHdiTest, camera_hdi_0066)
372 {
373 std::cout << "==========[test log] UpdateSettings, ";
374 std::cout << "OHOS_CAMERA_AWB_MODE:OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT." << std::endl;
375 sleep(3); // waiting 3s, prepare for execute OpenCamera.
376 cameraBase->OpenCamera();
377 // Issue 3A parameters
378 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
379 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT;
380 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
381 cameraBase->rc = cameraBase->cameraDevice->UpdateSettings(meta);
382 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
383 }
384
385 /**
386 * @tc.name: SetResultMode
387 * @tc.desc: SetResultMode is PER_FRAME.
388 * @tc.level: Level1
389 * @tc.size: MediumTest
390 * @tc.type: Function
391 */
TEST_F(UtestHdiTest,camera_hdi_0070)392 TEST_F(UtestHdiTest, camera_hdi_0070)
393 {
394 std::cout << "==========[test log] SetResultMode is PER_FRAME." << std::endl;
395 EXPECT_EQ(true, cameraBase->cameraDevice != nullptr);
396 std::vector<OHOS::Camera::MetaType> enableTypes;
397 cameraBase->rc = cameraBase->cameraDevice->GetEnabledReuslts(enableTypes);
398 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
399 for (const auto &type : enableTypes) {
400 std::cout << "==========[test log] type = " << type << std::endl;
401 }
402 cameraBase->rc = cameraBase->cameraDevice->SetResultMode(Camera::PER_FRAME);
403 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
404 }
405
406 /**
407 * @tc.name: SetResultMode
408 * @tc.desc: SetResultMode is ON_CHANGED.
409 * @tc.level: Level1
410 * @tc.size: MediumTest
411 * @tc.type: Function
412 */
TEST_F(UtestHdiTest,camera_hdi_0071)413 TEST_F(UtestHdiTest, camera_hdi_0071)
414 {
415 std::cout << "==========[test log] SetResultMode is PER_FRAME." << std::endl;
416 EXPECT_EQ(true, cameraBase->cameraDevice != nullptr);
417 std::vector<OHOS::Camera::MetaType> enableTypes;
418 cameraBase->rc = cameraBase->cameraDevice->GetEnabledReuslts(enableTypes);
419 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
420 for (const auto &type : enableTypes) {
421 std::cout << "==========[test log] type = " << type << std::endl;
422 }
423 cameraBase->rc = cameraBase->cameraDevice->SetResultMode(Camera::ON_CHANGED);
424 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
425 }
426
427 /**
428 * @tc.name: GetEnabledReuslts
429 * @tc.desc: GetEnabledReuslts expected success.
430 * @tc.level: Level1
431 * @tc.size: MediumTest
432 * @tc.type: Function
433 */
TEST_F(UtestHdiTest,camera_hdi_0080)434 TEST_F(UtestHdiTest, camera_hdi_0080)
435 {
436 std::cout << "==========[test log] GetEnabledReuslts expected success." << std::endl;
437 std::vector<OHOS::Camera::MetaType> results;
438 cameraBase->rc = cameraBase->cameraDevice->GetEnabledReuslts(results);
439 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
440 std::cout << "GetEnabledReuslts is :" << std::endl;
441 for (int i = 0; i<results.size(); ++i) {
442 std::cout << results.at(i) << std::endl;
443 }
444 }
445
446 /**
447 * @tc.name: EnableResult
448 * @tc.desc: EnableResult one tag, without preview, success.
449 * @tc.level: Level1
450 * @tc.size: MediumTest
451 * @tc.type: Function
452 */
TEST_F(UtestHdiTest,camera_hdi_0090)453 TEST_F(UtestHdiTest, camera_hdi_0090)
454 {
455 std::cout << "==========[test log] EnableResult one tag, without preview, success." << std::endl;
456 // Get the parameter tag currently supported by the device
457 std::cout << "==========[test log] 1. Get the tags..." << std::endl;
458 std::vector<OHOS::Camera::MetaType> resultsOriginal;
459 cameraBase->rc = cameraBase->cameraDevice->GetEnabledReuslts(resultsOriginal);
460 std::cout << "resultsOriginal.size = " << resultsOriginal.size() << std::endl;
461 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
462 // add this tag
463 std::vector<OHOS::Camera::MetaType> enableTag;
464 std::cout << "==========[test log] 2. Enable the tag: " << resultsOriginal[0] << std::endl;
465 enableTag.push_back(resultsOriginal[1]);
466 cameraBase->rc = cameraBase->cameraDevice->EnableResult(enableTag);
467 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
468 }
469
470 /**
471 * @tc.name: EnableResult
472 * @tc.desc: EnableResult multiple tags, success.
473 * @tc.level: Level1
474 * @tc.size: MediumTest
475 * @tc.type: Function
476 */
TEST_F(UtestHdiTest,camera_hdi_0091)477 TEST_F(UtestHdiTest, camera_hdi_0091)
478 {
479 std::cout << "==========[test log] EnableResult multiple tags, success." << std::endl;
480 // Get the parameter tag currently supported by the device
481 std::vector<OHOS::Camera::MetaType> resultsOriginal;
482 cameraBase->rc = cameraBase->cameraDevice->GetEnabledReuslts(resultsOriginal);
483 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
484
485 // Disable all tags
486 std::cout << "then, disable the tag..." << std::endl;
487 cameraBase->rc = cameraBase->cameraDevice->DisableResult(resultsOriginal);
488 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
489
490 // Get the parameter tag currently supported by the device again
491 std::vector<OHOS::Camera::MetaType> results;
492 cameraBase->rc = cameraBase->cameraDevice->GetEnabledReuslts(results);
493 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
494 EXPECT_GT(results.size(), 0);
495
496 // Add multiple tags
497 std::cout << "then, enable the tag..." << std::endl;
498 cameraBase->rc = cameraBase->cameraDevice->EnableResult(resultsOriginal);
499 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
500
501 // Get the parameter tag currently supported by the device again
502 cameraBase->rc = cameraBase->cameraDevice->GetEnabledReuslts(results);
503 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
504 }
505
506 /**
507 * @tc.name: EnableResult
508 * @tc.desc: EnableResult error tag, expected success .
509 * @tc.level: Level1
510 * @tc.size: MediumTest
511 * @tc.type: Function
512 */
TEST_F(UtestHdiTest,camera_hdi_0092)513 TEST_F(UtestHdiTest, camera_hdi_0092)
514 {
515 std::cout << "==========[test log] EnableResult error tag, expected fail." << std::endl;
516 // Get the parameter tag currently supported by the device
517 std::vector<OHOS::Camera::MetaType> resultsOriginal;
518 cameraBase->rc = cameraBase->cameraDevice->GetEnabledReuslts(resultsOriginal);
519 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
520
521 // add a tag
522 std::vector<OHOS::Camera::MetaType> enableTag;
523 enableTag.push_back(0);
524 std::cout << "then, enable the tag..." << std::endl;
525 cameraBase->rc = cameraBase->cameraDevice->EnableResult(enableTag);
526 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
527 }
528
529 /**
530 * @tc.name: EnableResult
531 * @tc.desc: DisableResult one tag, without preview, success.
532 * @tc.level: Level1
533 * @tc.size: MediumTest
534 * @tc.type: Function
535 */
TEST_F(UtestHdiTest,camera_hdi_0100)536 TEST_F(UtestHdiTest, camera_hdi_0100)
537 {
538 std::cout << "==========[test log] DisEnabledReuslts, expected success." << std::endl;
539 // Get the parameter tag currently supported by the device
540 std::vector<OHOS::Camera::MetaType> resultsOriginal;
541 cameraBase->rc = cameraBase->cameraDevice->GetEnabledReuslts(resultsOriginal);
542 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
543 std::cout << "==========[test log] GetEnabledReuslts, size = " << resultsOriginal.size() << std::endl;
544
545 // disable a tag
546 std::vector<OHOS::Camera::MetaType> disableTag;
547 disableTag.push_back(resultsOriginal[0]);
548 cameraBase->rc = cameraBase->cameraDevice->DisableResult(disableTag);
549 std::cout << "rc = " << cameraBase->rc << std::endl;
550 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
551 std::cout << "==========[test log] DisableResult the tag:" << resultsOriginal[0] << std::endl;
552
553 // Get the parameter tag currently supported by the device again
554 std::vector<OHOS::Camera::MetaType> results;
555 cameraBase->rc = cameraBase->cameraDevice->GetEnabledReuslts(results);
556 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
557 }
558
559 /**
560 * @tc.name: EnableResult
561 * @tc.desc: DisableResult all tag, success.
562 * @tc.level: Level1
563 * @tc.size: MediumTest
564 * @tc.type: Function
565 */
TEST_F(UtestHdiTest,camera_hdi_0101)566 TEST_F(UtestHdiTest, camera_hdi_0101)
567 {
568 std::cout << "==========[test log] DisableResult all tag, success." << std::endl;
569 // Get the parameter tag currently supported by the device
570 std::vector<OHOS::Camera::MetaType> resultsOriginal;
571 cameraBase->rc = cameraBase->cameraDevice->GetEnabledReuslts(resultsOriginal);
572 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
573
574 // Disable all tags
575 std::cout << "then, disable the tag..." << std::endl;
576 cameraBase->rc = cameraBase->cameraDevice->DisableResult(resultsOriginal);
577 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
578
579 // Get the parameter tag currently supported by the device again
580 std::vector<OHOS::Camera::MetaType> results;
581 cameraBase->rc = cameraBase->cameraDevice->GetEnabledReuslts(results);
582 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
583 }
584
585 /**
586 * @tc.name: EnableResult
587 * @tc.desc: DisableResult error tag, expected fail.
588 * @tc.level: Level1
589 * @tc.size: MediumTest
590 * @tc.type: Function
591 */
TEST_F(UtestHdiTest,camera_hdi_0102)592 TEST_F(UtestHdiTest, camera_hdi_0102)
593 {
594 std::cout << "==========[test log] DisableResult error tag, expected fail." << std::endl;
595 // Get the parameter tag currently supported by the device
596 std::vector<OHOS::Camera::MetaType> resultsOriginal;
597 cameraBase->rc = cameraBase->cameraDevice->GetEnabledReuslts(resultsOriginal);
598 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
599
600 // disable a tag
601 std::vector<OHOS::Camera::MetaType> disableTag;
602 disableTag.push_back(0);
603 std::cout << "then, disenable the tag..." << std::endl;
604 cameraBase->rc = cameraBase->cameraDevice->DisableResult(disableTag);
605 std::cout << "==========[test log] rc = " << cameraBase->rc << std::endl;
606 EXPECT_EQ(false, cameraBase->rc == NO_ERROR);
607
608 // Get the parameter tag currently supported by the device again
609 std::vector<OHOS::Camera::MetaType> results;
610 cameraBase->rc = cameraBase->cameraDevice->GetEnabledReuslts(results);
611 EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
612 }
613
614 /**
615 * @tc.name: Close
616 * @tc.desc: Close the device.
617 * @tc.level: Level1
618 * @tc.size: MediumTest
619 * @tc.type: Function
620 */
TEST_F(UtestHdiTest,camera_hdi_0110)621 TEST_F(UtestHdiTest, camera_hdi_0110)
622 {
623 std::cout << "==========[test log] Close the device." << std::endl;
624 EXPECT_EQ(false, cameraBase->cameraDevice == nullptr);
625 if (cameraBase->cameraDevice != nullptr) {
626 cameraBase->cameraDevice->Close();
627 std::cout << "==========[test log] cameraBase->cameraDevice->Close()." << std::endl;
628 cameraBase->cameraDevice = nullptr;
629 }
630 }