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 18using namespace OHOS; 19using namespace std; 20using namespace testing::ext; 21using namespace OHOS::Camera; 22 23void HdiDeviceTest::SetUpTestCase(void) {} 24void HdiDeviceTest::TearDownTestCase(void) {} 25void HdiDeviceTest::SetUp(void) 26{ 27 Test_ = std::make_shared<OHOS::Camera::Test>(); 28 Test_->Init(); 29} 30void 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 */ 41HWTEST_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 */ 56HWTEST_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 */ 71HWTEST_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 */ 91HWTEST_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 */ 121HWTEST_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 */ 151HWTEST_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 */ 181HWTEST_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 */ 211HWTEST_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 */ 241HWTEST_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 */ 272HWTEST_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 */ 303HWTEST_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 */ 324HWTEST_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 */ 345HWTEST_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 */ 364HWTEST_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 */ 386HWTEST_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 */ 424HWTEST_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 */ 447HWTEST_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 */ 479HWTEST_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 */ 508HWTEST_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 */ 539HWTEST_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}