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