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