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