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_device_test.h"
17
18 using namespace OHOS;
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Camera;
22
SetUpTestCase(void)23 void HdiDeviceTest::SetUpTestCase(void) {}
TearDownTestCase(void)24 void HdiDeviceTest::TearDownTestCase(void) {}
SetUp(void)25 void HdiDeviceTest::SetUp(void)
26 {
27 Test_ = std::make_shared<OHOS::Camera::Test>();
28 Test_->Init();
29 }
TearDown(void)30 void HdiDeviceTest::TearDown(void)
31 {
32 Test_->Close();
33 }
34
35 /**
36 * @tc.name: GetStreamOprator
37 * @tc.desc: GetStreamOprator, normal callback input.
38 * @tc.size: MediumTest
39 * @tc.type: Function
40 */
41 HWTEST_F(HdiDeviceTest, Camera_Hdi_0050, TestSize.Level0)
42 {
43 std::cout << "==========[test log]Check hdi_device: GetStreamOprator, normal callback input." << std::endl;
44 Test_->Open();
45 Test_->CreateStreamOperatorCallback();
46 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
47 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
48 }
49
50 /**
51 * @tc.name: GetStreamOprator
52 * @tc.desc: GetStreamOprator, callback is nullptr.
53 * @tc.size: MediumTest
54 * @tc.type: Function
55 */
56 HWTEST_F(HdiDeviceTest, Camera_Hdi_0051, TestSize.Level2)
57 {
58 std::cout << "==========[test log]Check hdi_device: GetStreamOprator, normal callback input." << std::endl;
59 Test_->Open();
60 Test_->streamOperatorCallback = nullptr;
61 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
62 EXPECT_EQ(true, Test_->rc == Camera::INVALID_ARGUMENT);
63 }
64
65 /**
66 * @tc.name: UpdateSettings
67 * @tc.desc: UpdateSettings, OHOS_CONTROL_AE_EXPOSURE_COMPENSATION.
68 * @tc.size: MediumTest
69 * @tc.type: Function
70 */
71 HWTEST_F(HdiDeviceTest, Camera_Hdi_0060, TestSize.Level0)
72 {
73 std::cout << "==========[test log]Check hdi_device: UpdateSettings,";
74 std::cout <<" OHOS_CONTROL_AE_EXPOSURE_COMPENSATION." << std::endl;
75 Test_->Open();
76 // Issue 3A parameters
77 std::shared_ptr<Camera::CameraSetting> meta = std::make_shared<Camera::CameraSetting>(100, 2000);
78 int32_t expo = 0xa0;
79 auto ret = meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
80 EXPECT_EQ(ret, true);
81 Test_->rc = Test_->cameraDevice->UpdateSettings(meta);
82 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
83 std::cout << "cameraDevice->UpdateSettings's rc " << Test_->rc << std::endl;
84 }
85
86 /**
87 * @tc.name: UpdateSettings
88 * @tc.desc: UpdateSettings, OHOS_CONTROL_AWB_MODE:OHOS_CONTROL_AWB_MODE_AUTO.
89 * @tc.size: MediumTest
90 * @tc.type: Function
91 */
92 HWTEST_F(HdiDeviceTest, Camera_Hdi_0061, TestSize.Level2)
93 {
94 std::cout << "==========[test log]Check hdi_device: UpdateSettings, ";
95 std::cout <<"OHOS_CONTROL_AWB_MODE:OHOS_CONTROL_AWB_MODE_AUTO." << std::endl;
96 Test_->Open();
97 // Start stream
98 Test_->intents = {Camera::PREVIEW};
99 Test_->StartStream(Test_->intents);
100 // Get preview
101 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
102 // Issue 3A parameters
103 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_AUTO;
104 std::shared_ptr<Camera::CameraSetting> meta = std::make_shared<Camera::CameraSetting>(100, 2000);
105 auto ret = meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
106 EXPECT_EQ(ret, true);
107 std::cout << "==========[test log]UpdateSettings, awb : OHOS_CONTROL_AWB_MODE_AUTO." << std::endl;
108 Test_->rc = Test_->cameraDevice->UpdateSettings(meta);
109 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
110 sleep(2);
111 // Release stream
112 Test_->streamIds = {Test_->streamId_preview};
113 Test_->captureIds = {Test_->captureId_preview};
114 Test_->StopStream(Test_->captureIds, Test_->streamIds);
115 Test_->StopConsumer(Test_->intents);
116 }
117
118 /**
119 * @tc.name: UpdateSettings
120 * @tc.desc: UpdateSettings, OHOS_CONTROL_AWB_MODE:OHOS_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT.
121 * @tc.size: MediumTest
122 * @tc.type: Function
123 */
124 HWTEST_F(HdiDeviceTest, Camera_Hdi_0062, TestSize.Level2)
125 {
126 std::cout << "==========[test log]Check hdi_device: UpdateSettings, ";
127 std::cout <<"OHOS_CONTROL_AWB_MODE:OHOS_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT." << std::endl;
128 Test_->Open();
129 // Start stream
130 Test_->intents = {Camera::PREVIEW};
131 Test_->StartStream(Test_->intents);
132 // Get preview
133 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
134 // Issue 3A parameters
135 std::shared_ptr<Camera::CameraSetting> meta = std::make_shared<Camera::CameraSetting>(100, 2000);
136 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_CLOUDY_DAYLIGHT;
137 auto ret = meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
138 EXPECT_EQ(ret, true);
139 std::cout << "==========[test log]UpdateSettings, awb : OHOS_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT." << std::endl;
140 Test_->rc = Test_->cameraDevice->UpdateSettings(meta);
141 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
142 sleep(2);
143 // Release stream
144 Test_->captureIds = {Test_->captureId_preview};
145 Test_->streamIds = {Test_->streamId_preview};
146 Test_->StopStream(Test_->captureIds, Test_->streamIds);
147 Test_->StopConsumer(Test_->intents);
148 }
149
150 /**
151 * @tc.name: UpdateSettings
152 * @tc.desc: UpdateSettings, OHOS_CONTROL_AWB_MODE:OHOS_CONTROL_AWB_MODE_TWILIGHT.
153 * @tc.size: MediumTest
154 * @tc.type: Function
155 */
156 HWTEST_F(HdiDeviceTest, Camera_Hdi_0063, TestSize.Level2)
157 {
158 std::cout << "==========[test log]Check hdi_device: UpdateSettings,";
159 std::cout << "OHOS_CONTROL_AWB_MODE:OHOS_CONTROL_AWB_MODE_TWILIGHT." << std::endl;
160 Test_->Open();
161 // Start stream
162 Test_->intents = {Camera::PREVIEW};
163 Test_->StartStream(Test_->intents);
164 // Get preview
165 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
166 // Issue 3A parameters
167 std::shared_ptr<Camera::CameraSetting> meta = std::make_shared<Camera::CameraSetting>(100, 2000);
168 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_TWILIGHT;
169 auto ret = meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
170 EXPECT_EQ(ret, true);
171 std::cout << "==========[test log]UpdateSettings, awb : OHOS_CONTROL_AWB_MODE_TWILIGHT." << std::endl;
172 Test_->rc = Test_->cameraDevice->UpdateSettings(meta);
173 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
174 sleep(2);
175 // Release stream
176 Test_->captureIds = {Test_->captureId_preview};
177 Test_->streamIds = {Test_->streamId_preview};
178 Test_->StopStream(Test_->captureIds, Test_->streamIds);
179 Test_->StopConsumer(Test_->intents);
180 }
181
182 /**
183 * @tc.name: UpdateSettings
184 * @tc.desc: UpdateSettings, OHOS_CONTROL_AWB_MODE:OHOS_CONTROL_AWB_MODE_FLUORESCENT.
185 * @tc.size: MediumTest
186 * @tc.type: Function
187 */
188 HWTEST_F(HdiDeviceTest, Camera_Hdi_0065, TestSize.Level2)
189 {
190 std::cout << "==========[test log]Check hdi_device: UpdateSettings,";
191 std::cout << "OHOS_CONTROL_AWB_MODE:OHOS_CONTROL_AWB_MODE_FLUORESCENT." << std::endl;
192 Test_->Open();
193 // Start stream
194 Test_->intents = {Camera::PREVIEW};
195 Test_->StartStream(Test_->intents);
196 // Get preview
197 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
198 // Issue 3A parameters
199 std::shared_ptr<Camera::CameraSetting> meta = std::make_shared<Camera::CameraSetting>(100, 2000);
200 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_FLUORESCENT;
201 auto ret = meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
202 EXPECT_EQ(ret, true);
203 std::cout << "==========[test log]UpdateSettings, awb : OHOS_CONTROL_AWB_MODE_FLUORESCENT." << std::endl;
204 Test_->rc = Test_->cameraDevice->UpdateSettings(meta);
205 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
206 sleep(2);
207 // Release stream
208 Test_->captureIds = {Test_->captureId_preview};
209 Test_->streamIds = {Test_->streamId_preview};
210 Test_->StopStream(Test_->captureIds, Test_->streamIds);
211 Test_->StopConsumer(Test_->intents);
212 }
213
214 /**
215 * @tc.name: UpdateSettings
216 * @tc.desc: UpdateSettings, OHOS_CONTROL_AWB_MODE:OHOS_CONTROL_AWB_MODE_WARM_FLUORESCENT.
217 * @tc.size: MediumTest
218 * @tc.type: Function
219 */
220 HWTEST_F(HdiDeviceTest, Camera_Hdi_0066, TestSize.Level2)
221 {
222 std::cout << "==========[test log]Check hdi_device: UpdateSettings,";
223 std::cout << "OHOS_CONTROL_AWB_MODE:OHOS_CONTROL_AWB_MODE_WARM_FLUORESCENT." << std::endl;
224 Test_->Open();
225 // Start stream
226 Test_->intents = {Camera::PREVIEW};
227 Test_->StartStream(Test_->intents);
228 // Get preview
229 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
230 // Issue 3A parameters
231 std::shared_ptr<Camera::CameraSetting> meta = std::make_shared<Camera::CameraSetting>(100, 2000);
232 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT;
233 auto ret = meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
234 EXPECT_EQ(ret, true);
235 std::cout << "==========[test log]UpdateSettings, awb : OHOS_CONTROL_AWB_MODE_WARM_FLUORESCENT." << std::endl;
236 Test_->rc = Test_->cameraDevice->UpdateSettings(meta);
237 EXPECT_EQ(Test_->rc, HDI::Camera::V1_0::NO_ERROR);
238 sleep(2);
239 // Release stream
240 Test_->captureIds = {Test_->captureId_preview};
241 Test_->streamIds = {Test_->streamId_preview};
242 Test_->StopStream(Test_->captureIds, Test_->streamIds);
243 Test_->StopConsumer(Test_->intents);
244 }
245
246 /**
247 * @tc.name: UpdateSettings
248 * @tc.desc: UpdateSettings, OHOS_CONTROL_AWB_MODE: illegal value(input AE value).
249 * @tc.size: MediumTest
250 * @tc.type: Function
251 */
252 HWTEST_F(HdiDeviceTest, Camera_Hdi_0067, TestSize.Level2)
253 {
254 std::cout << "==========[test log]Check hdi_device: UpdateSettings,";
255 std::cout <<" OHOS_CONTROL_AWB_MODE: illegal value(input AE value)." << std::endl;
256 Test_->Open();
257 // Start stream
258 Test_->intents = {Camera::PREVIEW};
259 Test_->StartStream(Test_->intents);
260 // Get preview
261 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
262 // Issue 3A parameters
263 std::shared_ptr<Camera::CameraSetting> meta = std::make_shared<Camera::CameraSetting>(100, 2000);
264 uint8_t awbMode = OHOS_CAMERA_AE_MODE_ON_ALWAYS_FLASH;
265 auto ret = meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
266 EXPECT_EQ(ret, true);
267 Test_->rc = Test_->cameraDevice->UpdateSettings(meta);
268 std::cout << "cameraDevice->UpdateSettings's rc " << Test_->rc << std::endl;
269 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
270 sleep(3); // sleep for 3 seconds
271 // Release stream
272 Test_->captureIds = {Test_->captureId_preview};
273 Test_->streamIds = {Test_->streamId_preview};
274 Test_->StopStream(Test_->captureIds, Test_->streamIds);
275 Test_->StopConsumer(Test_->intents);
276 }
277
278 /**
279 * @tc.name: UpdateSettings
280 * @tc.desc: UpdateSettings, OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, illegal value.
281 * @tc.size: MediumTest
282 * @tc.type: Function
283 */
284 HWTEST_F(HdiDeviceTest, Camera_Hdi_0068, TestSize.Level2)
285 {
286 std::cout << "==========[test log]Check hdi_device: UpdateSettings,";
287 std::cout <<" OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, illegal value." << std::endl;
288 Test_->Open();
289 // Start stream
290 Test_->intents = {Camera::PREVIEW};
291 Test_->StartStream(Test_->intents);
292 // Get preview
293 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
294 // Issue 3A parameters
295 std::shared_ptr<Camera::CameraSetting> meta = std::make_shared<Camera::CameraSetting>(100, 2000);
296 int32_t expo = 0xFFFF;
297 auto ret = meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
298 EXPECT_EQ(ret, true);
299 Test_->rc = Test_->cameraDevice->UpdateSettings(meta);
300 std::cout << "cameraDevice->UpdateSettings's rc " << Test_->rc << std::endl;
301 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
302 sleep(3); // sleep for 3 seconds
303 // Release stream
304 Test_->captureIds = {Test_->captureId_preview};
305 Test_->streamIds = {Test_->streamId_preview};
306 Test_->StopStream(Test_->captureIds, Test_->streamIds);
307 Test_->StopConsumer(Test_->intents);
308 }
309
310 /**
311 * @tc.name: SetResultMode
312 * @tc.desc: SetResultMode is PER_FRAME.
313 * @tc.size: MediumTest
314 * @tc.type: Function
315 */
316 HWTEST_F(HdiDeviceTest, Camera_Hdi_0070, TestSize.Level0)
317 {
318 std::cout << "==========[test log]Check hdi_device: SetResultMode is PER_FRAME." << std::endl;
319 Test_->Open();
320 EXPECT_EQ(true, Test_->cameraDevice != nullptr);
321 std::vector<Camera::MetaType> enableTypes;
322 Test_->rc = Test_->cameraDevice->GetEnabledResults(enableTypes);
323 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
324 for (const auto &type : enableTypes) {
325 std::cout << "==========[test log]Check hdi_device: type = " << type << std::endl;
326 }
327 Test_->rc = Test_->cameraDevice->SetResultMode(Camera::PER_FRAME);
328 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
329 }
330
331 /**
332 * @tc.name: SetResultMode
333 * @tc.desc: SetResultMode is ON_CHANGED.
334 * @tc.size: MediumTest
335 * @tc.type: Function
336 */
337 HWTEST_F(HdiDeviceTest, Camera_Hdi_0071, TestSize.Level2)
338 {
339 Test_->Open();
340 EXPECT_EQ(true, Test_->cameraDevice != nullptr);
341 std::cout << "==========[test log]Check hdi_device: SetResultMode is ON_CHANGED." << std::endl;
342 std::vector<Camera::MetaType> enableTypes;
343 Test_->rc = Test_->cameraDevice->GetEnabledResults(enableTypes);
344 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
345 for (const auto &type : enableTypes) {
346 std::cout << "==========[test log] hdi_device: type = " << type << std::endl;
347 }
348 Test_->rc = Test_->cameraDevice->SetResultMode(Camera::ON_CHANGED);
349 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
350 }
351
352 /**
353 * @tc.name: GetEnabledResults
354 * @tc.desc: GetEnabledResults expected success.
355 * @tc.size: MediumTest
356 * @tc.type: Function
357 */
358 HWTEST_F(HdiDeviceTest, Camera_Hdi_0080, TestSize.Level0)
359 {
360 std::cout << "==========[test log]Check hdi_device: GetEnabledResults expected success." << std::endl;
361 Test_->Open();
362 std::vector<Camera::MetaType> results;
363 Test_->rc = Test_->cameraDevice->GetEnabledResults(results);
364 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
365 std::cout << "GetEnabledResults is :" << std::endl;
366 for (int i=0; i<results.size(); ++i) {
367 std::cout << results.at(i) << std::endl;
368 }
369 }
370
371 /**
372 * @tc.name: EnableResult
373 * @tc.desc: EnableResult one tag, without preview, success.
374 * @tc.size: MediumTest
375 * @tc.type: Function
376 */
377 HWTEST_F(HdiDeviceTest, Camera_Hdi_0090, TestSize.Level0)
378 {
379 std::cout << "==========[test log]Check hdi_device: EnableResult one tag, without preview, success." << std::endl;
380 Test_->Open();
381 std::cout << "==========[test log]Check hdi_device: 1. Get the tags..." << std::endl;
382 std::vector<Camera::MetaType> enable_tag;
383 enable_tag.push_back(OHOS_SENSOR_EXPOSURE_TIME);
384 std::cout << "==========[test log]Check hdi_device: 2. Enable the tag: " << enable_tag[0] << std::endl;
385 Test_->rc = Test_->cameraDevice->EnableResult(enable_tag);
386 // add this tag
387 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
388 std::vector<Camera::MetaType> results_original;
389 Test_->rc = Test_->cameraDevice->GetEnabledResults(results_original);
390 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
391 }
392
393 /**
394 * @tc.name: EnableResult
395 * @tc.desc: EnableResult multiple tags, success.
396 * @tc.size: MediumTest
397 * @tc.type: Function
398 */
399 HWTEST_F(HdiDeviceTest, Camera_Hdi_0091, TestSize.Level2)
400 {
401 std::cout << "==========[test log]Check hdi_device: EnableResult multiple tags, success." << std::endl;
402 Test_->Open();
403 std::vector<Camera::MetaType> results;
404 results.push_back(OHOS_SENSOR_EXPOSURE_TIME);
405 results.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
406 Test_->rc = Test_->cameraDevice->EnableResult(results);
407 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
408 std::vector<Camera::MetaType> results_original;
409 Test_->rc = Test_->cameraDevice->GetEnabledResults(results_original);
410 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
411
412 // 2、Disable all tags
413 std::cout << "then, disable the tag..." << std::endl;
414 Test_->rc = Test_->cameraDevice->DisableResult(results_original);
415 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
416
417 // 3、Get the parameter tag currently supported by the device again
418 Test_->rc = Test_->cameraDevice->GetEnabledResults(results);
419 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
420
421 // Add multiple tags
422 std::cout << "then, enable the tag..." << std::endl;
423 Test_->rc = Test_->cameraDevice->EnableResult(results_original);
424 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
425
426 // Get the parameter tag currently supported by the device again
427 Test_->rc = Test_->cameraDevice->GetEnabledResults(results);
428 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
429 }
430
431 /**
432 * @tc.name: EnableResult
433 * @tc.desc: EnableResult error tag, expected success.
434 * @tc.size: MediumTest
435 * @tc.type: Function
436 */
437 HWTEST_F(HdiDeviceTest, Camera_Hdi_0092, TestSize.Level2)
438 {
439 std::cout << "==========[test log]Check hdi_device: EnableResult error tag, expected fail." << std::endl;
440 Test_->Open();
441 // Get the parameter tag currently supported by the device
442 std::vector<Camera::MetaType> results_original;
443 Test_->rc = Test_->cameraDevice->GetEnabledResults(results_original);
444 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
445
446 // add a tag
447 std::vector<Camera::MetaType> enable_tag;
448 enable_tag.push_back(0);
449 std::cout << "then, enable the tag..." << std::endl;
450 Test_->rc = Test_->cameraDevice->EnableResult(enable_tag);
451 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
452 }
453
454 /**
455 * @tc.name: DisableResult
456 * @tc.desc: DisableResult one tag, without preview, success.
457 * @tc.size: MediumTest
458 * @tc.type: Function
459 */
460 HWTEST_F(HdiDeviceTest, Camera_Hdi_0100, TestSize.Level0)
461 {
462 std::cout << "==========[test log]Check hdi_device: DisEnabledReuslts, expected success." << std::endl;
463 Test_->Open();
464 std::vector<Camera::MetaType> results;
465 results.push_back(OHOS_SENSOR_EXPOSURE_TIME);
466 results.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
467 Test_->rc = Test_->cameraDevice->EnableResult(results);
468 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
469 std::vector<Camera::MetaType> results_original;
470 Test_->rc = Test_->cameraDevice->GetEnabledResults(results_original);
471 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
472 std::cout << "==========[test log]GetEnabledResults, size = " << results_original.size() << std::endl;
473
474 // Disable a tag
475 std::vector<Camera::MetaType> disable_tag;
476 disable_tag.push_back(results_original[1]);
477 Test_->rc = Test_->cameraDevice->DisableResult(disable_tag);
478 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
479 std::cout << "==========[test log]Check hdi_device: DisableResult the tag:" << results_original[0] << std::endl;
480
481 // Get the parameter tag currently supported by the device again
482 Test_->rc = Test_->cameraDevice->GetEnabledResults(results);
483 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
484 }
485
486 /**
487 * @tc.name: DisableResult
488 * @tc.desc: DisableResult all tag, success.
489 * @tc.size: MediumTest
490 * @tc.type: Function
491 */
492 HWTEST_F(HdiDeviceTest, Camera_Hdi_0101, TestSize.Level2)
493 {
494 std::cout << "==========[test log]Check hdi_device: DisableResult all tag, success." << std::endl;
495 Test_->Open();
496 std::vector<Camera::MetaType> results;
497 results.push_back(OHOS_SENSOR_EXPOSURE_TIME);
498 results.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
499 Test_->rc = Test_->cameraDevice->EnableResult(results);
500 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
501 std::vector<Camera::MetaType> results_original;
502 Test_->rc = Test_->cameraDevice->GetEnabledResults(results_original);
503 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
504
505 // Disable all tags
506 std::cout << "then, disable the tag..." << std::endl;
507 Test_->rc = Test_->cameraDevice->DisableResult(results_original);
508 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
509
510 // Get the parameter tag currently supported by the device again
511 Test_->rc = Test_->cameraDevice->GetEnabledResults(results);
512 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
513 }
514
515 /**
516 * @tc.name: DisableResult
517 * @tc.desc: DisableResult error tag, expected success.
518 * @tc.size: MediumTest
519 * @tc.type: Function
520 */
521 HWTEST_F(HdiDeviceTest, Camera_Hdi_0102, TestSize.Level2)
522 {
523 std::cout << "==========[test log]Check hdi_device: DisableResult error tag, expected success." << std::endl;
524 Test_->Open();
525 std::vector<Camera::MetaType> results;
526 results.push_back(OHOS_SENSOR_EXPOSURE_TIME);
527 results.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
528 Test_->rc = Test_->cameraDevice->EnableResult(results);
529 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
530 std::vector<Camera::MetaType> results_original;
531 Test_->rc = Test_->cameraDevice->GetEnabledResults(results_original);
532 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
533
534 // Disable a tag
535 std::vector<Camera::MetaType> disable_tag;
536 disable_tag.push_back(0);
537 std::cout << "then, disenable the tag..." << std::endl;
538 Test_->rc = Test_->cameraDevice->DisableResult(disable_tag);
539 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
540
541 // Get the parameter tag currently supported by the device again
542 Test_->rc = Test_->cameraDevice->GetEnabledResults(results);
543 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
544 }
545
546 /**
547 * @tc.name: Close
548 * @tc.desc: Close the device.
549 * @tc.size: MediumTest
550 * @tc.type: Function
551 */
552 HWTEST_F(HdiDeviceTest, Camera_Hdi_0110, TestSize.Level0)
553 {
554 std::cout << "==========[test log]Check hdi_device: Close the device." << std::endl;
555 Test_->Open();
556 EXPECT_EQ(false, Test_->cameraDevice == nullptr);
557 if (Test_->cameraDevice != nullptr) {
558 Test_->cameraDevice->Close();
559 std::cout << "==========[test log]Check hdi_device: Test_->cameraDevice->Close()." << std::endl;
560 Test_->cameraDevice = nullptr;
561 }
562 }