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_stream_test.h" 17 18using namespace OHOS; 19using namespace std; 20using namespace testing::ext; 21using namespace OHOS::Camera; 22 23void HdiStreamTest::SetUpTestCase(void) {} 24void HdiStreamTest::TearDownTestCase(void) {} 25void HdiStreamTest::SetUp(void) 26{ 27 Test_ = std::make_shared<OHOS::Camera::Test>(); 28 Test_->Init(); 29} 30void HdiStreamTest::TearDown(void) 31{ 32 Test_->Close(); 33} 34 35/** 36 * @tc.name: IsStreamsSupported 37 * @tc.desc: IsStreamsSupported, normal cameraId. 38 * @tc.size: MediumTest 39 * @tc.type: Function 40 */ 41HWTEST_F(HdiStreamTest, Camera_Hdi_0120, TestSize.Level0) 42{ 43 std::cout << "==========[test log]Check hdi: IsStreamsSupported, normal cameraId." << std::endl; 44 // Turn on the camera 45 Test_->Open(); 46 EXPECT_EQ(false, Test_->cameraDevice == nullptr); 47 // Get streamOperator 48 Test_->CreateStreamOperatorCallback(); 49 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 50 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 51 // Configure mode and modeSetting 52 Camera::OperationMode mode = Camera::NORMAL; 53 std::shared_ptr<CameraMetadata> modeSetting = 54 std::make_shared<CameraMetadata>(2, 128); 55 int64_t expoTime = 0; 56 modeSetting->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &expoTime, 1); 57 int64_t colorGains[4] = {0}; 58 modeSetting->addEntry(OHOS_SENSOR_COLOR_CORRECTION_GAINS, &colorGains, 4); 59 // Configure stream information 60 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 61 Test_->streamInfo->streamId_ = 1001; // 1001:streamId 62 Test_->StreamInfoFormat(); 63 Test_->streamInfo->height_ = 480; // 480:height of stream 64 Test_->streamInfo->width_ = 640; // 640:width of stream 65 Test_->streamInfo->dataspace_ = 8; 66 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 67 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 68#ifdef CAMERA_BUILT_ON_OHOS_LITE 69 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 70 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 71 }); 72#else 73 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 74 Test_->SaveYUV("preview", addr, size); 75 }); 76#endif 77 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 78 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 79 Test_->streamInfo->intent_ = Camera::PREVIEW; 80 Test_->streamInfo->tunneledMode_ = 5; 81 Camera::StreamSupportType pType; 82 std::vector<std::shared_ptr<Camera::StreamInfo>> stre; 83 stre.push_back(Test_->streamInfo); 84 Test_->rc = Test_->streamOperator->IsStreamsSupported(NORMAL, modeSetting, stre, pType); 85 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 86 EXPECT_NE(pType, Camera::NOT_SUPPORTED); 87 if (Test_->rc == Camera::NO_ERROR) { 88 std::cout << "==========[test log]Check hdi: IsStreamsSupported success, pType = " << pType << std::endl; 89 } else { 90 std::cout << "==========[test log]Check hdi: IsStreamsSupported fail, rc = " << Test_->rc << std::endl; 91 } 92 consumer->StopConsumer(); 93} 94 95/** 96 * @tc.name: IsStreamsSupported 97 * @tc.desc: IsStreamsSupported, input modeSetting nullptr. 98 * @tc.size: MediumTest 99 * @tc.type: Function 100 */ 101HWTEST_F(HdiStreamTest, Camera_Hdi_0121, TestSize.Level2) 102{ 103 std::cout << "==========[test log]Check hdi: IsStreamsSupported, input modeSetting nullptr." << std::endl; 104 // Turn on the camera 105 Test_->Open(); 106 EXPECT_EQ(false, Test_->cameraDevice == nullptr); 107 // Get streamOperator 108 Test_->CreateStreamOperatorCallback(); 109 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 110 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 111 // Configure stream information 112 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 113 Test_->streamInfo->streamId_ = 1001; // 1001:streamId 114 Test_->streamInfo->width_ = 640; // 640:width of stream 115 Test_->streamInfo->height_ = 480; // 480:height of stream 116 Test_->streamInfo->tunneledMode_ = 5; 117 Test_->StreamInfoFormat(); 118 Test_->streamInfo->dataspace_ = 8; 119 Test_->streamInfo->intent_ = Camera::PREVIEW; 120 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 121 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 122#ifdef CAMERA_BUILT_ON_OHOS_LITE 123 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 124 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 125 }); 126#else 127 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 128 Test_->SaveYUV("preview", addr, size); 129 }); 130#endif 131 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 132 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 133 134 Camera::StreamSupportType pType; 135 std::vector<std::shared_ptr<Camera::StreamInfo>> stre; 136 stre.push_back(Test_->streamInfo); 137 Test_->rc = Test_->streamOperator->IsStreamsSupported(NORMAL, nullptr, stre, pType); 138 EXPECT_EQ(true, Test_->rc == Camera::INVALID_ARGUMENT); 139 if (Test_->rc == Camera::NO_ERROR) { 140 std::cout << "==========[test log]Check hdi: IsStreamsSupported success." << std::endl; 141 } else { 142 std::cout << "==========[test log]Check hdi: IsStreamsSupported fail, rc = " << Test_->rc << std::endl; 143 } 144 consumer->StopConsumer(); 145} 146 147/** 148 * @tc.name: IsStreamsSupported 149 * @tc.desc: IsStreamsSupported, input streamInfo nullptr. 150 * @tc.size: MediumTest 151 * @tc.type: Function 152 */ 153HWTEST_F(HdiStreamTest, Camera_Hdi_0122, TestSize.Level2) 154{ 155 std::cout << "==========[test log]Check hdi: IsStreamsSupported, input mode abnormal." << std::endl; 156 // Turn on the camera 157 Test_->Open(); 158 EXPECT_EQ(false, Test_->cameraDevice == nullptr); 159 // Get streamOperator 160 Test_->CreateStreamOperatorCallback(); 161 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 162 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 163 Camera::StreamSupportType pType; 164 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> infos = {}; 165 Test_->rc = Test_->streamOperator->IsStreamsSupported(NORMAL, Test_->ability, infos, pType); 166 EXPECT_EQ(Test_->rc, Camera::INVALID_ARGUMENT); 167 if (Test_->rc == Camera::NO_ERROR) { 168 std::cout << "==========[test log]Check hdi: IsStreamsSupported success." << std::endl; 169 } else { 170 std::cout << "==========[test log]Check hdi: IsStreamsSupported fail, rc = " << Test_->rc << std::endl; 171 } 172} 173 174/** 175 * @tc.name: IsStreamsSupported 176 * @tc.desc: IsStreamsSupported, normal cameraId, excepted not supported. 177 * @tc.size: MediumTest 178 * @tc.type: Function 179 */ 180HWTEST_F(HdiStreamTest, Camera_Hdi_0123, TestSize.Level1) 181{ 182 std::cout << "==========[test log] CAMERA_FORMAT_YVYU_422_PKG format is not supported." << std::endl; 183 // Turn on the camera 184 Test_->Open(); 185 EXPECT_EQ(false, Test_->cameraDevice == nullptr); 186 // Get streamOperator 187 Test_->CreateStreamOperatorCallback(); 188 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 189 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 190 if (Test_->rc == Camera::NO_ERROR) { 191 std::cout << "==========[test log]Check hdi: GetStreamOperator success." << std::endl; 192 } else { 193 std::cout << "==========[test log]Check hdi: GetStreamOperator fail, rc = " << Test_->rc << std::endl; 194 } 195 // Configure mode and modeSetting 196 Camera::OperationMode mode = Camera::NORMAL; 197 std::shared_ptr<CameraMetadata> modeSetting = 198 std::make_shared<CameraMetadata>(2, 128); 199 // Configure stream information 200 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 201 Test_->streamInfo->width_ = 640; // 640:width of stream 202 Test_->streamInfo->height_ = 480; // 480:height of stream 203 Test_->streamInfo->streamId_ = 1001; // 1001:streamId 204 Test_->StreamInfoFormat(); 205 Test_->streamInfo->dataspace_ = 8; 206 Test_->streamInfo->intent_ = Camera::PREVIEW; 207 Test_->streamInfo->tunneledMode_ = 5; 208 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 209 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 210#ifdef CAMERA_BUILT_ON_OHOS_LITE 211 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 212 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 213 }); 214#else 215 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 216 Test_->SaveYUV("preview", addr, size); 217 }); 218#endif 219 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 220 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 221 Camera::StreamSupportType pType; 222 std::vector<std::shared_ptr<Camera::StreamInfo>> stre; 223 stre.push_back(Test_->streamInfo); 224 Test_->rc = Test_->streamOperator->IsStreamsSupported(NORMAL, modeSetting, stre, pType); 225 EXPECT_EQ(Test_->rc, Camera::INVALID_ARGUMENT); 226 if (Test_->rc == Camera::NO_ERROR) { 227 std::cout << "==========[test log]Check hdi: IsStreamsSupported success, pType = " << pType << std::endl; 228 } else { 229 std::cout << "==========[test log]Check hdi: IsStreamsSupported fail, rc = " << Test_->rc << std::endl; 230 } 231 consumer->StopConsumer(); 232} 233 234/** 235 * @tc.name: CreateStreams 236 * @tc.desc: CreateStreams, success. 237 * @tc.size: MediumTest 238 * @tc.type: Function 239 */ 240HWTEST_F(HdiStreamTest, Camera_Hdi_0130, TestSize.Level0) 241{ 242 std::cout << "==========[test log]Check hdi: CreateStreams, success." << std::endl; 243 Test_->Open(); 244 // Create and get streamOperator information 245 Test_->CreateStreamOperatorCallback(); 246 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 247 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 248 // Create data stream 249 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 250 Test_->streamInfo->streamId_ = 1001; 251 Test_->streamInfo->width_ = 640; 252 Test_->streamInfo->height_ = 480; 253 Test_->StreamInfoFormat(); 254 Test_->streamInfo->dataspace_ = 8; 255 Test_->streamInfo->intent_ = Camera::PREVIEW; 256 Test_->streamInfo->tunneledMode_ = 5; 257 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 258 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 259#ifdef CAMERA_BUILT_ON_OHOS_LITE 260 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 261 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 262 }); 263#else 264 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 265 Test_->SaveYUV("preview", addr, size); 266 }); 267#endif 268 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 269 Test_->streamInfos.push_back(Test_->streamInfo); 270 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 271 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 272 // release stream 273 std::vector<int> streamIds; 274 streamIds.push_back(Test_->streamInfo->streamId_); 275 Test_->rc = Test_->streamOperator->ReleaseStreams(streamIds); 276 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 277 consumer->StopConsumer(); 278} 279 280/** 281 * @tc.name: CreateStreams 282 * @tc.desc: CreateStreams, StreamInfo->streamId = -1, return error. 283 * @tc.size: MediumTest 284 * @tc.type: Function 285 */ 286HWTEST_F(HdiStreamTest, Camera_Hdi_0131, TestSize.Level2) 287{ 288 std::cout << "==========[test log]Check hdi: CreateStreams, StreamInfo->streamId = -1, error." << std::endl; 289 Test_->Open(); 290 // Create and get streamOperator information 291 Test_->CreateStreamOperatorCallback(); 292 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 293 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 294 // Create data stream 295 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 296 Test_->streamInfo->streamId_ = -1; 297 Test_->streamInfo->width_ = 640; 298 Test_->StreamInfoFormat(); 299 Test_->streamInfo->height_ = 480; 300 Test_->streamInfo->dataspace_ = 8; 301 Test_->streamInfo->intent_ = Camera::PREVIEW; 302 Test_->streamInfo->tunneledMode_ = 5; 303 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 304 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 305#ifdef CAMERA_BUILT_ON_OHOS_LITE 306 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 307 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 308 }); 309#else 310 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 311 Test_->SaveYUV("preview", addr, size); 312 }); 313#endif 314 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 315 Test_->streamInfos.push_back(Test_->streamInfo); 316 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 317 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 318 EXPECT_EQ(INVALID_ARGUMENT, Test_->rc); 319 consumer->StopConsumer(); 320} 321 322/** 323 * @tc.name: CreateStreams 324 * @tc.desc: CreateStreams, StreamInfo->streamId = 2147483647, return error. 325 * @tc.size: MediumTest 326 * @tc.type: Function 327 */ 328HWTEST_F(HdiStreamTest, Camera_Hdi_0132, TestSize.Level2) 329{ 330 std::cout << "==========[test log]Check hdi: CreateStreams, StreamInfo->streamId = 2147483647, error" << std::endl; 331 Test_->Open(); 332 Test_->CreateStreamOperatorCallback(); 333 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 334 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 335 // Create data stream 336 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 337 Test_->streamInfo->streamId_ = 2147483647; 338 Test_->streamInfo->width_ = 640; 339 Test_->streamInfo->height_ = 480; 340 Test_->streamInfo->dataspace_ = 8; 341 Test_->StreamInfoFormat(); 342 Test_->streamInfo->intent_ = Camera::PREVIEW; 343 Test_->streamInfo->tunneledMode_ = 5; 344 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 345 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 346#ifdef CAMERA_BUILT_ON_OHOS_LITE 347 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 348 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 349 }); 350#else 351 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 352 Test_->SaveYUV("preview", addr, size); 353 }); 354#endif 355 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 356 Test_->streamInfos.push_back(Test_->streamInfo); 357 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 358 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 359 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 360 // release stream 361 Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamInfo->streamId_}); 362 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 363 consumer->StopConsumer(); 364} 365 366/** 367 * @tc.name: CreateStreams 368 * @tc.desc: CreateStreams, StreamInfo->width = -1, return error. 369 * @tc.size: MediumTest 370 * @tc.type: Function 371 */ 372HWTEST_F(HdiStreamTest, Camera_Hdi_0133, TestSize.Level2) 373{ 374 std::cout << "==========[test log]Check hdi: CreateStreams, StreamInfo->width = -1, return error." << std::endl; 375 Test_->Open(); 376 Test_->CreateStreamOperatorCallback(); 377 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 378 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 379 // Create data stream 380 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 381 Test_->streamInfo->streamId_ = 1001; 382 Test_->streamInfo->width_ = -1; 383 Test_->streamInfo->height_ = 640; 384 Test_->StreamInfoFormat(); 385 Test_->streamInfo->dataspace_ = 8; 386 Test_->streamInfo->intent_ = Camera::PREVIEW; 387 Test_->streamInfo->tunneledMode_ = 5; 388 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 389 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 390#ifdef CAMERA_BUILT_ON_OHOS_LITE 391 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 392 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 393 }); 394#else 395 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 396 Test_->SaveYUV("preview", addr, size); 397 }); 398#endif 399 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 400 Test_->streamInfos.push_back(Test_->streamInfo); 401 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 402 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 403 EXPECT_EQ(INVALID_ARGUMENT, Test_->rc); 404 consumer->StopConsumer(); 405} 406 407/** 408 * @tc.name: CreateStreams 409 * @tc.desc: CreateStreams, StreamInfo->width = 2147483647, success. 410 * @tc.size: MediumTest 411 * @tc.type: Function 412 */ 413HWTEST_F(HdiStreamTest, Camera_Hdi_0134, TestSize.Level2) 414{ 415 std::cout << "==========[test log]Check hdi: CreateStreams, StreamInfo->width = 2147483647, success." << std::endl; 416 Test_->Open(); 417 Test_->CreateStreamOperatorCallback(); 418 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 419 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 420 // Create data stream 421 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 422 Test_->streamInfo->streamId_ = 1001; 423 Test_->streamInfo->width_ = 2147483647; 424 Test_->streamInfo->height_ = 640; 425 Test_->StreamInfoFormat(); 426 Test_->streamInfo->dataspace_ = 8; 427 Test_->streamInfo->intent_ = Camera::PREVIEW; 428 Test_->streamInfo->tunneledMode_ = 5; 429 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 430 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 431#ifdef CAMERA_BUILT_ON_OHOS_LITE 432 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 433 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 434 }); 435#else 436 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 437 Test_->SaveYUV("preview", addr, size); 438 }); 439#endif 440 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 441 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 442 Test_->streamInfos.push_back(Test_->streamInfo); 443 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 444 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 445 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 446 // release stream 447 Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamInfo->streamId_}); 448 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 449 consumer->StopConsumer(); 450} 451 452/** 453 * @tc.name: CreateStreams 454 * @tc.desc: CreateStreams, StreamInfo->height = -1, return error. 455 * @tc.size: MediumTest 456 * @tc.type: Function 457 */ 458HWTEST_F(HdiStreamTest, Camera_Hdi_0135, TestSize.Level2) 459{ 460 std::cout << "==========[test log]Check hdi: CreateStreams, StreamInfo->height = -1, return error." << std::endl; 461 Test_->Open(); 462 Test_->CreateStreamOperatorCallback(); 463 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 464 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 465 // Create data stream 466 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 467 Test_->streamInfo->streamId_ = 1001; 468 Test_->streamInfo->width_ = 1920; 469 Test_->streamInfo->height_ = -1; 470 Test_->StreamInfoFormat(); 471 Test_->streamInfo->dataspace_ = 8; 472 Test_->streamInfo->intent_ = Camera::PREVIEW; 473 Test_->streamInfo->tunneledMode_ = 5; 474 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 475 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 476#ifdef CAMERA_BUILT_ON_OHOS_LITE 477 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 478 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 479 }); 480#else 481 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 482 Test_->SaveYUV("preview", addr, size); 483 }); 484#endif 485 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 486 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 487 Test_->streamInfos.push_back(Test_->streamInfo); 488 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 489 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 490 EXPECT_EQ(INVALID_ARGUMENT, Test_->rc); 491 consumer->StopConsumer(); 492} 493 494/** 495 * @tc.name: CreateStreams 496 * @tc.desc: CreateStreams, StreamInfo->height = 2147483647, success. 497 * @tc.size: MediumTest 498 * @tc.type: Function 499 */ 500HWTEST_F(HdiStreamTest, Camera_Hdi_0136, TestSize.Level2) 501{ 502 std::cout << "==========[test log]Check hdi: CreateStreams, StreamInfo->height = 2147483647, success" << std::endl; 503 Test_->Open(); 504 Test_->CreateStreamOperatorCallback(); 505 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 506 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 507 // Create data stream 508 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 509 Test_->streamInfo->streamId_ = 1001; 510 Test_->streamInfo->width_ = 1920; 511 Test_->streamInfo->height_ = 2147483647; 512 Test_->StreamInfoFormat(); 513 Test_->streamInfo->dataspace_ = 8; 514 Test_->streamInfo->intent_ = Camera::PREVIEW; 515 Test_->streamInfo->tunneledMode_ = 5; 516 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 517 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 518#ifdef CAMERA_BUILT_ON_OHOS_LITE 519 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 520 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 521 }); 522#else 523 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 524 Test_->SaveYUV("preview", addr, size); 525 }); 526#endif 527 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 528 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 529 Test_->streamInfos.push_back(Test_->streamInfo); 530 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 531 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 532 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 533 // release stream 534 Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamInfo->streamId_}); 535 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 536 consumer->StopConsumer(); 537} 538 539/** 540 * @tc.name: CreateStreams 541 * @tc.desc: CreateStreams, StreamInfo->format = -1, return error. 542 * @tc.size: MediumTest 543 * @tc.type: Function 544 */ 545HWTEST_F(HdiStreamTest, Camera_Hdi_0137, TestSize.Level2) 546{ 547 std::cout << "==========[test log]Check hdi: CreateStreams, StreamInfo->format = -1, return error." << std::endl; 548 Test_->Open(); 549 Test_->CreateStreamOperatorCallback(); 550 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 551 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 552 // Create data stream 553 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 554 Test_->streamInfo->streamId_ = 1001; 555 Test_->streamInfo->width_ = 1920; 556 Test_->streamInfo->height_ = 1080; 557 Test_->streamInfo->format_ = -1; 558 Test_->streamInfo->dataspace_ = 8; 559 Test_->streamInfo->intent_ = Camera::PREVIEW; 560 Test_->streamInfo->tunneledMode_ = 5; 561 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 562 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 563#ifdef CAMERA_BUILT_ON_OHOS_LITE 564 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 565 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 566 }); 567#else 568 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 569 Test_->SaveYUV("preview", addr, size); 570 }); 571#endif 572 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 573 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 574 Test_->streamInfos.push_back(Test_->streamInfo); 575 // Configure mode and modeSetting 576 Camera::OperationMode mode = Camera::NORMAL; 577 std::shared_ptr<CameraMetadata> modeSetting = 578 std::make_shared<CameraMetadata>(2, 128); 579 Camera::StreamSupportType pType; 580 std::vector<std::shared_ptr<Camera::StreamInfo>> stre; 581 stre.push_back(Test_->streamInfo); 582 Test_->rc = Test_->streamOperator->IsStreamsSupported(NORMAL, modeSetting, stre, pType); 583 EXPECT_EQ(Test_->rc, Camera::INVALID_ARGUMENT); 584 if (Test_->rc == Camera::NO_ERROR) { 585 std::cout << "==========[test log]Check hdi: IsStreamsSupported success." << std::endl; 586 } else { 587 std::cout << "==========[test log]Check hdi: IsStreamsSupported fail, rc = " << Test_->rc << std::endl; 588 } 589 590 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 591 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 592 EXPECT_EQ(INVALID_ARGUMENT, Test_->rc); 593 consumer->StopConsumer(); 594} 595 596/** 597 * @tc.name: CreateStreams 598 * @tc.desc: CreateStreams, StreamInfo->format = 2147483647, success. 599 * @tc.size: MediumTest 600 * @tc.type: Function 601 */ 602HWTEST_F(HdiStreamTest, Camera_Hdi_0138, TestSize.Level2) 603{ 604 std::cout << "==========[test log]Check hdi: CreateStreams, StreamInfo->format = 2147483647, success" << std::endl; 605 Test_->Open(); 606 Test_->CreateStreamOperatorCallback(); 607 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 608 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 609 // Create data stream 610 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 611 Test_->streamInfo->streamId_ = 1001; 612 Test_->streamInfo->width_ = 1920; 613 Test_->streamInfo->height_ = 1080; 614 Test_->streamInfo->format_ = 2147483647; 615 Test_->streamInfo->dataspace_ = 8; 616 Test_->streamInfo->intent_ = Camera::PREVIEW; 617 Test_->streamInfo->tunneledMode_ = 5; 618 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 619 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 620#ifdef CAMERA_BUILT_ON_OHOS_LITE 621 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 622 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 623 }); 624#else 625 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 626 Test_->SaveYUV("preview", addr, size); 627 }); 628#endif 629 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 630 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 631 Test_->streamInfos.push_back(Test_->streamInfo); 632 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 633 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 634 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 635 // release stream 636 Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamInfo->streamId_}); 637 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 638 consumer->StopConsumer(); 639} 640 641/** 642 * @tc.name: CreateStreams 643 * @tc.desc: CreateStreams, StreamInfo->dataspace = -1, return error. 644 * @tc.size: MediumTest 645 * @tc.type: Function 646 */ 647HWTEST_F(HdiStreamTest, Camera_Hdi_0139, TestSize.Level2) 648{ 649 std::cout << "==========[test log]Check hdi: CreateStreams, StreamInfo->dataspace = -1, error." << std::endl; 650 Test_->Open(); 651 Test_->CreateStreamOperatorCallback(); 652 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 653 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 654 // Configure mode and modeSetting 655 Camera::OperationMode mode = Camera::NORMAL; 656 std::shared_ptr<CameraMetadata> modeSetting = nullptr; 657 // Configure stream information 658 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 659 Test_->streamInfo->streamId_ = 1001; 660 Test_->streamInfo->dataspace_ = -1; 661 Test_->streamInfo->height_ = 480; 662 Test_->streamInfo->width_ = 640; 663 Test_->StreamInfoFormat(); 664 Test_->streamInfo->intent_ = Camera::PREVIEW; 665 Test_->streamInfo->tunneledMode_ = 5; 666 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 667 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 668#ifdef CAMERA_BUILT_ON_OHOS_LITE 669 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 670 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 671 }); 672#else 673 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 674 Test_->SaveYUV("preview", addr, size); 675 }); 676#endif 677 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 678 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 679 Camera::StreamSupportType pType; 680 std::vector<std::shared_ptr<Camera::StreamInfo>> stre; 681 stre.push_back(Test_->streamInfo); 682 Test_->rc = Test_->streamOperator->IsStreamsSupported(NORMAL, modeSetting, stre, pType); 683 EXPECT_EQ(Test_->rc, INVALID_ARGUMENT); 684 if (Test_->rc == Camera::NO_ERROR) { 685 std::cout << "==========[test log]Check hdi: IsStreamsSupported success." << std::endl; 686 } else { 687 std::cout << "==========[test log]Check hdi: IsStreamsSupported fail, rc = " << Test_->rc << std::endl; 688 } 689 consumer->StopConsumer(); 690} 691 692/** 693 * @tc.name: CreateStreams 694 * @tc.desc: CreateStreams, StreamInfo->dataspace = 2147483647, success. 695 * @tc.size: MediumTest 696 * @tc.type: Function 697 */ 698HWTEST_F(HdiStreamTest, Camera_Hdi_0140, TestSize.Level2) 699{ 700 std::cout << "==========[test log]Check hdi: CreateStreams, dataspace = 2147483647, success" << std::endl; 701 Test_->Open(); 702 Test_->CreateStreamOperatorCallback(); 703 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 704 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 705 // Create data stream 706 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 707 Test_->streamInfo->streamId_ = 1001; 708 Test_->streamInfo->width_ = 1920; 709 Test_->streamInfo->height_ = 1080; 710 Test_->StreamInfoFormat(); 711 Test_->streamInfo->dataspace_ = 2147483647; 712 Test_->streamInfo->intent_ = Camera::PREVIEW; 713 Test_->streamInfo->tunneledMode_ = 5; 714 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 715 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 716#ifdef CAMERA_BUILT_ON_OHOS_LITE 717 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 718 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 719 }); 720#else 721 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 722 Test_->SaveYUV("preview", addr, size); 723 }); 724#endif 725 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 726 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 727 Test_->streamInfos.push_back(Test_->streamInfo); 728 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 729 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 730 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 731 // release stream 732 Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamInfo->streamId_}); 733 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 734 consumer->StopConsumer(); 735} 736 737/** 738 * @tc.name: CreateStreams 739 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = Camera::PREVIEW, success. 740 * @tc.size: MediumTest 741 * @tc.type: Function 742 */ 743HWTEST_F(HdiStreamTest, Camera_Hdi_0141, TestSize.Level2) 744{ 745 std::cout << "==========[test log]Check hdi: CreateStreams, StreamIntent = Camera::PREVIEW, success." << std::endl; 746 Test_->Open(); 747 Test_->CreateStreamOperatorCallback(); 748 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 749 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 750 // Create data stream 751 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 752 Test_->streamInfo->streamId_ = 1001; 753 Test_->streamInfo->width_ = 1920; 754 Test_->streamInfo->height_ = 1080; 755 Test_->StreamInfoFormat(); 756 Test_->streamInfo->dataspace_ = 8; 757 Test_->streamInfo->intent_ = Camera::PREVIEW; 758 Test_->streamInfo->tunneledMode_ = 5; 759 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 760 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 761#ifdef CAMERA_BUILT_ON_OHOS_LITE 762 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 763 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 764 }); 765#else 766 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 767 Test_->SaveYUV("preview", addr, size); 768 }); 769#endif 770 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 771 Test_->streamInfos.push_back(Test_->streamInfo); 772 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 773 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 774 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 775 // release stream 776 Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamInfo->streamId_}); 777 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 778 consumer->StopConsumer(); 779} 780 781/** 782 * @tc.name: CreateStreams 783 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = Camera::VIDEO, success. 784 * @tc.size: MediumTest 785 * @tc.type: Function 786 */ 787HWTEST_F(HdiStreamTest, Camera_Hdi_0142, TestSize.Level2) 788{ 789 std::cout << "==========[test log]Check hdi: CreateStreams, StreamIntent = Camera::VIDEO, success." << std::endl; 790 Test_->Open(); 791 Test_->CreateStreamOperatorCallback(); 792 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 793 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 794 // Create data stream 795 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 796 Test_->streamInfo->streamId_ = 1001; 797 Test_->streamInfo->width_ = 1920; 798 Test_->streamInfo->height_ = 1080; 799 Test_->StreamInfoFormat(); 800 Test_->streamInfo->dataspace_ = 8; 801 Test_->streamInfo->intent_ = Camera::VIDEO; 802 Test_->streamInfo->tunneledMode_ = 5; 803 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 804 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 805#ifdef CAMERA_BUILT_ON_OHOS_LITE 806 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 807 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 808 }); 809#else 810 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 811 Test_->SaveYUV("preview", addr, size); 812 }); 813#endif 814 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 815 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 816 Test_->streamInfos.push_back(Test_->streamInfo); 817 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 818 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 819 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 820 // release stream 821 Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamInfo->streamId_}); 822 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 823 consumer->StopConsumer(); 824} 825 826/** 827 * @tc.name: CreateStreams 828 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = Camera::STILL_CAPTURE, success. 829 * @tc.size: MediumTest 830 * @tc.type: Function 831 */ 832HWTEST_F(HdiStreamTest, Camera_Hdi_0143, TestSize.Level2) 833{ 834 std::cout << "==========[test log]Check hdi: CreateStreams, Camera::STILL_CAPTURE, success." << std::endl; 835 Test_->Open(); 836 Test_->CreateStreamOperatorCallback(); 837 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 838 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 839 // Create data stream 840 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 841 Test_->streamInfo->streamId_ = 1001; 842 Test_->streamInfo->width_ = 1920; 843 Test_->streamInfo->height_ = 1080; 844 Test_->StreamInfoFormat(); 845 Test_->streamInfo->dataspace_ = 8; 846 Test_->streamInfo->intent_ = Camera::STILL_CAPTURE; 847 Test_->streamInfo->tunneledMode_ = 5; 848 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 849 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 850#ifdef CAMERA_BUILT_ON_OHOS_LITE 851 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 852 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 853 }); 854#else 855 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 856 Test_->SaveYUV("preview", addr, size); 857 }); 858#endif 859 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 860 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 861 Test_->streamInfos.push_back(Test_->streamInfo); 862 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 863 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 864 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 865 // release stream 866 Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamInfo->streamId_}); 867 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 868 consumer->StopConsumer(); 869} 870 871/** 872 * @tc.name: CreateStreams 873 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = Camera::POST_VIEW;, success. 874 * @tc.size: MediumTest 875 * @tc.type: Function 876 */ 877HWTEST_F(HdiStreamTest, Camera_Hdi_0144, TestSize.Level2) 878{ 879 std::cout << "==========[test log]Check hdi: CreateStreams, Camera::POST_VIEW;, success." << std::endl; 880 Test_->Open(); 881 Test_->CreateStreamOperatorCallback(); 882 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 883 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 884 // Create data stream 885 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 886 Test_->streamInfo->streamId_ = 1001; 887 Test_->streamInfo->width_ = 1920; 888 Test_->streamInfo->height_ = 1080; 889 Test_->StreamInfoFormat(); 890 Test_->streamInfo->dataspace_ = 8; 891 Test_->streamInfo->intent_ = Camera::POST_VIEW; 892 Test_->streamInfo->tunneledMode_ = 5; 893 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 894 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 895#ifdef CAMERA_BUILT_ON_OHOS_LITE 896 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 897 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 898 }); 899#else 900 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 901 Test_->SaveYUV("preview", addr, size); 902 }); 903#endif 904 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 905 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 906 Test_->streamInfos.push_back(Test_->streamInfo); 907 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 908 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 909 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 910 // release stream 911 Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamInfo->streamId_}); 912 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 913 consumer->StopConsumer(); 914} 915 916/** 917 * @tc.name: CreateStreams 918 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = Camera::ANALYZE;, success. 919 * @tc.size: MediumTest 920 * @tc.type: Function 921 */ 922HWTEST_F(HdiStreamTest, Camera_Hdi_0145, TestSize.Level2) 923{ 924 std::cout << "==========[test log]Check hdi: CreateStreams, Camera::ANALYZE;, success." << std::endl; 925 Test_->Open(); 926 Test_->CreateStreamOperatorCallback(); 927 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 928 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 929 // Create data stream 930 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 931 Test_->streamInfo->streamId_ = 1001; 932 Test_->streamInfo->width_ = 1920; 933 Test_->streamInfo->height_ = 1080; 934 Test_->StreamInfoFormat(); 935 Test_->streamInfo->dataspace_ = 8; 936 Test_->streamInfo->intent_ = Camera::ANALYZE; 937 Test_->streamInfo->tunneledMode_ = 5; 938 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 939 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 940#ifdef CAMERA_BUILT_ON_OHOS_LITE 941 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 942 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 943 }); 944#else 945 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 946 Test_->SaveYUV("preview", addr, size); 947 }); 948#endif 949 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 950 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 951 Test_->streamInfos.push_back(Test_->streamInfo); 952 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 953 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 954 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 955 // release stream 956 Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamInfo->streamId_}); 957 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 958 consumer->StopConsumer(); 959} 960 961/** 962 * @tc.name: CreateStreams 963 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = Camera::CUSTOM;, success. 964 * @tc.size: MediumTest 965 * @tc.type: Function 966 */ 967HWTEST_F(HdiStreamTest, Camera_Hdi_0146, TestSize.Level2) 968{ 969 std::cout << "==========[test log]Check hdi: CreateStreams, Camera::CUSTOM;, success." << std::endl; 970 Test_->Open(); 971 Test_->CreateStreamOperatorCallback(); 972 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 973 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 974 // Create data stream 975 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 976 Test_->streamInfo->streamId_ = 1001; 977 Test_->streamInfo->width_ = 1920; 978 Test_->streamInfo->height_ = 1080; 979 Test_->StreamInfoFormat(); 980 Test_->streamInfo->dataspace_ = 8; 981 Test_->streamInfo->intent_ = Camera::CUSTOM; 982 Test_->streamInfo->tunneledMode_ = 5; 983 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 984 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 985#ifdef CAMERA_BUILT_ON_OHOS_LITE 986 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 987 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 988 }); 989#else 990 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 991 Test_->SaveYUV("preview", addr, size); 992 }); 993#endif 994 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 995 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 996 Test_->streamInfos.push_back(Test_->streamInfo); 997 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 998 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 999 EXPECT_NE(Test_->rc, Camera::NO_ERROR); 1000 consumer->StopConsumer(); 1001} 1002 1003/** 1004 * @tc.name: CreateStreams 1005 * @tc.desc: CreateStreams, StreamInfo->tunneledMode = false, success. 1006 * @tc.size: MediumTest 1007 * @tc.type: Function 1008 */ 1009HWTEST_F(HdiStreamTest, Camera_Hdi_0147, TestSize.Level2) 1010{ 1011 std::cout << "==========[test log]Check hdi: CreateStreams, tunneledMode = false, success." << std::endl; 1012 Test_->Open(); 1013 Test_->CreateStreamOperatorCallback(); 1014 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 1015 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 1016 // Create data stream 1017 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 1018 Test_->streamInfo->streamId_ = 1001; 1019 Test_->streamInfo->width_ = 1920; 1020 Test_->streamInfo->height_ = 1080; 1021 Test_->StreamInfoFormat(); 1022 Test_->streamInfo->dataspace_ = 8; 1023 Test_->streamInfo->intent_ = Camera::CUSTOM; 1024 Test_->streamInfo->tunneledMode_ = 0; 1025 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 1026 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 1027#ifdef CAMERA_BUILT_ON_OHOS_LITE 1028 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 1029 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 1030 }); 1031#else 1032 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 1033 Test_->SaveYUV("preview", addr, size); 1034 }); 1035#endif 1036 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 1037 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 1038 Test_->streamInfos.push_back(Test_->streamInfo); 1039 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 1040 std::cout << "streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 1041 EXPECT_EQ(Test_->rc, Camera::INSUFFICIENT_RESOURCES); 1042 consumer->StopConsumer(); 1043} 1044 1045/** 1046 * @tc.name: CreateStreams 1047 * @tc.desc: CreateStreams, StreamInfo->minFrameDuration = -1, return error. 1048 * @tc.size: MediumTest 1049 * @tc.type: Function 1050 */ 1051HWTEST_F(HdiStreamTest, Camera_Hdi_0148, TestSize.Level2) 1052{ 1053 std::cout << "==========[test log]Check hdi: CreateStreams, minFrameDuration = -1, return error." << std::endl; 1054 Test_->Open(); 1055 Test_->CreateStreamOperatorCallback(); 1056 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 1057 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 1058 // Create data stream 1059 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 1060} 1061 1062/** 1063 * @tc.name: CreateStreams 1064 * @tc.desc: CreateStreams, StreamInfo->minFrameDuration = 2147483647, success. 1065 * @tc.size: MediumTest 1066 * @tc.type: Function 1067 */ 1068HWTEST_F(HdiStreamTest, Camera_Hdi_0149, TestSize.Level2) 1069{ 1070 std::cout << "==========[test log]Check hdi: CreateStreams, minFrameDuration = 2147483647, success." << std::endl; 1071 Test_->Open(); 1072 Test_->CreateStreamOperatorCallback(); 1073 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 1074 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 1075 // Create data stream 1076 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 1077} 1078 1079/** 1080 * @tc.name: ReleaseStreams 1081 * @tc.desc: ReleaseStreams,streamID normal. 1082 * @tc.size: MediumTest 1083 * @tc.type: Function 1084 */ 1085HWTEST_F(HdiStreamTest, Camera_Hdi_0160, TestSize.Level0) 1086{ 1087 std::cout << "==========[test log]Check hdi: ReleaseStreams,streamID normal." << std::endl; 1088 Test_->Open(); 1089 // Create and get streamOperator information 1090 Test_->CreateStreamOperatorCallback(); 1091 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 1092 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 1093 // Create data stream 1094 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 1095 Test_->streamInfo->streamId_ = 1001; 1096 Test_->streamInfo->width_ = 640; 1097 Test_->streamInfo->height_ = 480; 1098 Test_->streamInfo->intent_ = Camera::PREVIEW; 1099 Test_->StreamInfoFormat(); 1100 Test_->streamInfo->dataspace_ = 8; 1101 Test_->streamInfo->tunneledMode_ = 5; 1102 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 1103 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 1104#ifdef CAMERA_BUILT_ON_OHOS_LITE 1105 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 1106 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 1107 }); 1108#else 1109 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 1110 Test_->SaveYUV("preview", addr, size); 1111 }); 1112#endif 1113 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 1114 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 1115 Test_->streamInfos.push_back(Test_->streamInfo); 1116 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 1117 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1118 // release stream 1119 Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamInfo->streamId_}); 1120 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1121 consumer->StopConsumer(); 1122} 1123 1124/** 1125 * @tc.name: ReleaseStreams 1126 * @tc.desc: ReleaseStreams-> streamID = -1, expected success. 1127 * @tc.size: MediumTest 1128 * @tc.type: Function 1129 */ 1130HWTEST_F(HdiStreamTest, Camera_Hdi_0161, TestSize.Level2) 1131{ 1132 std::cout << "==========[test log]Check hdi: ReleaseStreams-> streamID = -1, expected success." << std::endl; 1133 Test_->Open(); 1134 // Start stream 1135 Test_->intents = {Camera::PREVIEW}; 1136 Test_->StartStream(Test_->intents); 1137 // Get preview 1138 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true); 1139 // release capture and stream 1140 Test_->streamOperator->CancelCapture(Test_->captureId_preview); 1141 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1142 Test_->rc = Test_->streamOperator->ReleaseStreams({-1}); 1143 EXPECT_EQ(true, Test_->rc != Camera::NO_ERROR); 1144 std::cout << "streamOperator->ReleaseStreams's rc " << Test_->rc << std::endl; 1145 Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamId_preview}); 1146 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1147 std::cout << "streamOperator->ReleaseStreams's rc " << Test_->rc << std::endl; 1148 Test_->StopConsumer(Test_->intents); 1149} 1150 1151/** 1152 * @tc.name: CommitStreams 1153 * @tc.desc: CommitStreams, input normal. 1154 * @tc.size: MediumTest 1155 * @tc.type: Function 1156 */ 1157HWTEST_F(HdiStreamTest, Camera_Hdi_0170, TestSize.Level0) 1158{ 1159 std::cout << "==========[test log]Check hdi: CommitStreams, input normal." << std::endl; 1160 Test_->Open(); 1161 // Start stream 1162 Test_->intents = {Camera::PREVIEW}; 1163 Test_->StartStream(Test_->intents); 1164 // release stream 1165 Test_->captureIds = {}; 1166 Test_->streamIds = {Test_->streamId_preview}; 1167 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1168 Test_->StopConsumer(Test_->intents); 1169} 1170 1171/** 1172 * @tc.name: CommitStreams 1173 * @tc.desc: CommitStreams, modeSetting is nullptr. 1174 * @tc.size: MediumTest 1175 * @tc.type: Function 1176 */ 1177HWTEST_F(HdiStreamTest, Camera_Hdi_0171, TestSize.Level1) 1178{ 1179 std::cout << "==========[test log]Check hdi: CommitStreams, modeSetting is nullptr." << std::endl; 1180 Test_->Open(); 1181 // Create and get streamOperator information 1182 Test_->CreateStreamOperatorCallback(); 1183 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 1184 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 1185 // Create data stream 1186 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 1187 Test_->streamInfo->streamId_ = Test_->streamId_preview; 1188 Test_->streamInfo->width_ = 640; 1189 Test_->streamInfo->height_ = 480; 1190 Test_->StreamInfoFormat(); 1191 Test_->streamInfo->dataspace_ = 8; 1192 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 1193 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 1194 Test_->streamInfo->intent_ = Camera::PREVIEW; 1195#ifdef CAMERA_BUILT_ON_OHOS_LITE 1196 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 1197 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 1198 }); 1199#else 1200 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 1201 Test_->SaveYUV("preview", addr, size); 1202 }); 1203#endif 1204 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 1205 Test_->streamInfo->tunneledMode_ = 5; 1206 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 1207 Test_->streamInfos.push_back(Test_->streamInfo); 1208 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 1209 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1210 std::shared_ptr<CameraMetadata> modeSetting = nullptr; 1211 // Distribution stream 1212 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, nullptr); 1213 EXPECT_EQ(Test_->rc, INVALID_ARGUMENT); 1214 if (Test_->rc == Camera::NO_ERROR) { 1215 std::cout << "==========[test log]Check hdi: CommitStreams success." << std::endl; 1216 } else { 1217 std::cout << "==========[test log]Check hdi: CommitStreams fail, rc = " << Test_->rc << std::endl; 1218 } 1219 // release stream 1220 Test_->captureIds = {}; 1221 Test_->streamIds = {Test_->streamId_preview}; 1222 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1223 consumer->StopConsumer(); 1224} 1225 1226/** 1227 * @tc.name: GetStreamAttributes 1228 * @tc.desc: GetStreamAttributes, success. 1229 * @tc.size: MediumTest 1230 * @tc.type: Function 1231 */ 1232HWTEST_F(HdiStreamTest, Camera_Hdi_0180, TestSize.Level0) 1233{ 1234 std::cout << "==========[test log]Check hdi: GetStreamAttributes, success." << std::endl; 1235 Test_->Open(); 1236 // Start stream 1237 Test_->intents = {Camera::PREVIEW}; 1238 Test_->StartStream(Test_->intents); 1239 1240 std::vector<std::shared_ptr<Camera::StreamAttribute>> attributes; 1241 Test_->rc = Test_->streamOperator->GetStreamAttributes(attributes); 1242 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1243 if (Test_->rc == Camera::NO_ERROR) { 1244 std::cout << "==========[test log]Check hdi: GetStreamAttributes success." << std::endl; 1245 } else { 1246 std::cout << "==========[test log]Check hdi: GetStreamAttributes fail, rc = " << Test_->rc << std::endl; 1247 } 1248 // release stream 1249 Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamId_preview}); 1250 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1251 std::cout << "streamOperator->ReleaseStreams's rc " << Test_->rc << std::endl; 1252 Test_->StopConsumer(Test_->intents); 1253} 1254 1255/** 1256 * @tc.name: Capture 1257 * @tc.desc: Capture, input normal. 1258 * @tc.size: MediumTest 1259 * @tc.type: Function 1260 */ 1261HWTEST_F(HdiStreamTest, Camera_Hdi_0190, TestSize.Level0) 1262{ 1263 std::cout << "==========[test log]Check hdi: Capture, input normal." << std::endl; 1264 Test_->Open(); 1265 // Start stream 1266 Test_->intents = {Camera::PREVIEW}; 1267 Test_->StartStream(Test_->intents); 1268 // Get preview 1269 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true); 1270 // release stream 1271 Test_->captureIds = {Test_->captureId_preview}; 1272 Test_->streamIds = {Test_->streamId_preview}; 1273 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1274 Test_->StopConsumer(Test_->intents); 1275} 1276 1277/** 1278 * @tc.name: Capture 1279 * @tc.desc: Preview, Capture->captureInfo->streamID = -1 ,return error. 1280 * @tc.size: MediumTest 1281 * @tc.type: Function 1282 */ 1283#if 1 1284HWTEST_F(HdiStreamTest, Camera_Hdi_0191, TestSize.Level2) 1285{ 1286 std::cout << "==========[test log]Check hdi: Preview, captureInfo->streamID = -1 ,return error." << std::endl; 1287 Test_->Open(); 1288 // Start stream 1289 Test_->intents = {Camera::PREVIEW}; 1290 Test_->StartStream(Test_->intents); 1291 // Get preview 1292 int captureId = 2001; 1293 Test_->captureInfo = std::make_shared<Camera::CaptureInfo>(); 1294 Test_->captureInfo->streamIds_ = {-1}; 1295 Test_->captureInfo->captureSetting_ = Test_->ability; 1296 Test_->captureInfo->enableShutterCallback_ = true; 1297 Test_->rc = Test_->streamOperator->Capture(captureId, Test_->captureInfo, true); 1298 EXPECT_EQ(INVALID_ARGUMENT, Test_->rc); 1299 sleep(3); // sleep for 3 seconds 1300 Test_->streamOperator->CancelCapture(captureId); 1301 // release stream 1302 Test_->captureIds = {}; 1303 Test_->streamIds = {Test_->streamId_preview}; 1304 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1305 Test_->StopConsumer(Test_->intents); 1306} 1307#endif 1308 1309/** 1310 * @tc.name: Capture 1311 * @tc.desc: Preview, Capture->captureInfo->streamID = 2147483647 ,return success. 1312 * @tc.size: MediumTest 1313 * @tc.type: Function 1314 */ 1315HWTEST_F(HdiStreamTest, Camera_Hdi_0192, TestSize.Level2) 1316{ 1317 std::cout << "==========[test log]Check hdi: captureInfo->streamID = 2147483647 ,return success." << std::endl; 1318 Test_->Open(); 1319 // Create and get streamOperator information 1320 Test_->CreateStreamOperatorCallback(); 1321 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 1322 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr); 1323 // Create data stream 1324 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 1325 Test_->streamInfo->streamId_ = 2147483647; 1326 Test_->streamInfo->width_ = 640; 1327 Test_->streamInfo->height_ = 480; 1328 Test_->StreamInfoFormat(); 1329 Test_->streamInfo->tunneledMode_ = 5; 1330 Test_->streamInfo->dataspace_ = 8; 1331 Test_->streamInfo->intent_ = Camera::PREVIEW; 1332 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 1333 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 1334#ifdef CAMERA_BUILT_ON_OHOS_LITE 1335 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 1336 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 1337 }); 1338#else 1339 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) { 1340 Test_->SaveYUV("preview", addr, size); 1341 }); 1342#endif 1343 Test_->streamInfo->bufferQueue_->SetQueueSize(8); 1344 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer; 1345 Test_->streamInfos.push_back(Test_->streamInfo); 1346 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 1347 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1348 // Distribution stream 1349 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability); 1350 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1351 // Get preview 1352 int captureId = 2001; 1353 Test_->captureInfo = std::make_shared<Camera::CaptureInfo>(); 1354 Test_->captureInfo->streamIds_ = {2147483647}; 1355 Test_->captureInfo->captureSetting_ = Test_->ability; 1356 Test_->captureInfo->enableShutterCallback_ = true; 1357 bool isStreaming = true; 1358 Test_->rc = Test_->streamOperator->Capture(captureId, Test_->captureInfo, isStreaming); 1359 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1360 sleep(3); // sleep for 3 seconds 1361 Test_->streamOperator->CancelCapture(captureId); 1362 1363 // release stream 1364 Test_->rc = Test_->streamOperator->ReleaseStreams(Test_->captureInfo->streamIds_); 1365 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1366 // Turn off the device 1367 Test_->cameraDevice->Close(); 1368 std::cout << "cameraDevice->Close" << std::endl; 1369 consumer->StopConsumer(); 1370} 1371 1372/** 1373 * @tc.name: Capture 1374 * @tc.desc: Preview, Capture->captureInfo->enableShutterCallback = false ,return success. 1375 * @tc.size: MediumTest 1376 * @tc.type: Function 1377 */ 1378HWTEST_F(HdiStreamTest, Camera_Hdi_0193, TestSize.Level2) 1379{ 1380 std::cout << "==========[test log]Check hdi: captureInfo->enableShutterCallback = false , success." << std::endl; 1381 Test_->Open(); 1382 // Configure two streams of information 1383 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE}; 1384 Test_->StartStream(Test_->intents); 1385 // Capture preview stream 1386 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true); 1387 // Capture the photo stream, single capture 1388 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, false); 1389 // post-processing 1390 Test_->captureIds = {Test_->captureId_preview}; 1391 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture}; 1392 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1393 Test_->StopConsumer(Test_->intents); 1394} 1395 1396/** 1397 * @tc.name: Capture 1398 * @tc.desc: Preview, Capture->isStreaming = false ,expected success. 1399 * @tc.size: MediumTest 1400 * @tc.type: Function 1401 */ 1402HWTEST_F(HdiStreamTest, Camera_Hdi_0194, TestSize.Level2) 1403{ 1404 std::cout << "==========[test log]Check hdi: isStreaming = false ,expected success." << std::endl; 1405 Test_->Open(); 1406 // Configure two streams of information 1407 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE}; 1408 Test_->StartStream(Test_->intents); 1409 // Capture preview stream 1410 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true); 1411 // Capture the photo stream, single capture 1412 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, false); 1413 // post-processing 1414 Test_->captureIds = {Test_->captureId_preview}; 1415 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture}; 1416 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1417 Test_->StopConsumer(Test_->intents); 1418} 1419 1420/** 1421 * @tc.name: Capture 1422 * @tc.desc: Preview, Capture->captureId = -1 ,return error. 1423 * @tc.size: MediumTest 1424 * @tc.type: Function 1425 */ 1426HWTEST_F(HdiStreamTest, Camera_Hdi_0195, TestSize.Level2) 1427{ 1428 std::cout << "==========[test log]Check hdi: Preview, Capture->captureId = -1 ,return error." << std::endl; 1429 Test_->Open(); 1430 // Configure preview stream information 1431 Test_->intents = {Camera::PREVIEW}; 1432 Test_->StartStream(Test_->intents); 1433 // Capture preview stream 1434 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true); 1435 // Get preview 1436 Test_->captureInfo = std::make_shared<Camera::CaptureInfo>(); 1437 Test_->captureInfo->streamIds_ = {Test_->streamId_preview}; 1438 Test_->captureInfo->captureSetting_ = Test_->ability; 1439 Test_->captureInfo->enableShutterCallback_ = false; 1440 bool isStreaming = true; 1441 int captureId = -1; 1442 Test_->rc = Test_->streamOperator->Capture(captureId, Test_->captureInfo, isStreaming); 1443 EXPECT_EQ(INVALID_ARGUMENT, Test_->rc); 1444 sleep(3); // sleep for 3 seconds 1445 // release stream 1446 Test_->rc = Test_->streamOperator->ReleaseStreams({Test_->streamId_preview}); 1447 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1448 Test_->StopConsumer(Test_->intents); 1449} 1450 1451/** 1452 * @tc.name: Capture 1453 * @tc.desc: Preview, Capture->captureInfo->enableShutterCallback = true ,return success. 1454 * @tc.size: MediumTest 1455 * @tc.type: Function 1456 */ 1457HWTEST_F(HdiStreamTest, Camera_Hdi_0196, TestSize.Level2) 1458{ 1459 std::cout << "==========[test log]Check hdi: captureInfo->enableShutterCallback = true , success." << std::endl; 1460 Test_->Open(); 1461 // Configure preview stream information 1462 Test_->intents = {Camera::PREVIEW}; 1463 Test_->StartStream(Test_->intents); 1464 // Capture preview stream 1465 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, true, true); 1466 // post-processing 1467 Test_->captureIds = {Test_->captureId_preview}; 1468 Test_->streamIds = {Test_->streamId_preview}; 1469 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1470 Test_->StopConsumer(Test_->intents); 1471} 1472 1473/** 1474 * @tc.name: CancelCapture 1475 * @tc.desc: CancelCapture, success. 1476 * @tc.size: MediumTest 1477 * @tc.type: Function 1478 */ 1479HWTEST_F(HdiStreamTest, Camera_Hdi_0200, TestSize.Level0) 1480{ 1481 std::cout << "==========[test log]Check hdi: CancelCapture, success." << std::endl; 1482 Test_->Open(); 1483 // Configure preview stream information 1484 Test_->intents = {Camera::PREVIEW}; 1485 Test_->StartStream(Test_->intents); 1486 // Capture preview stream 1487 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, true, true); 1488 // post-processing 1489 Test_->captureIds = {Test_->captureId_preview}; 1490 Test_->streamIds = {Test_->streamId_preview}; 1491 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1492 Test_->StopConsumer(Test_->intents); 1493} 1494 1495/** 1496 * @tc.name: CancelCapture 1497 * @tc.desc: CancelCapture captureID = -1. 1498 * @tc.size: MediumTest 1499 * @tc.type: Function 1500 */ 1501HWTEST_F(HdiStreamTest, Camera_Hdi_0201, TestSize.Level2) 1502{ 1503 std::cout << "==========[test log]Check hdi: CancelCapture captureID = -1, expected fail." << std::endl; 1504 Test_->Open(); 1505 // Configure preview stream information 1506 Test_->intents = {Camera::PREVIEW}; 1507 Test_->StartStream(Test_->intents); 1508 // Capture preview stream 1509 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, true, true); 1510 // Cancel capture 1511 Test_->rc = Test_->streamOperator->CancelCapture(-1); 1512 EXPECT_EQ(INVALID_ARGUMENT, Test_->rc); 1513 std::cout << "==========[test log]Check hdi: CancelCapture captureID = -1, return INVALID_ARGUMENT." << std::endl; 1514 // post-processing 1515 Test_->captureIds = {Test_->captureId_preview}; 1516 Test_->streamIds = {Test_->streamId_preview}; 1517 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1518 Test_->StopConsumer(Test_->intents); 1519} 1520 1521/** 1522 * @tc.name: AttachBufferQueue 1523 * @tc.desc: AttachBufferQueue, normal input. 1524 * @tc.size: MediumTest 1525 * @tc.type: Function 1526 */ 1527HWTEST_F(HdiStreamTest, Camera_Hdi_0210, TestSize.Level0) 1528{ 1529 std::cout << "==========[test log]Check hdi: AttachBufferQueue, normal input." << std::endl; 1530 // Turn on the camera 1531 Test_->Open(); 1532 Test_->CreateStreamOperatorCallback(); 1533 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 1534 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1535 // Create data stream 1536 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 1537 Test_->streamInfo->streamId_ = 1001; 1538 Test_->streamInfo->height_ = 480; 1539 Test_->streamInfo->width_ = 640; 1540 Test_->StreamInfoFormat(); 1541 Test_->streamInfo->dataspace_ = 8; 1542 Test_->streamInfo->intent_ = Camera::PREVIEW; 1543 Test_->streamInfo->tunneledMode_ = 5; 1544 std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos); 1545 Test_->streamInfos.push_back(Test_->streamInfo); 1546 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 1547 std::cout << "==========[test log]Check hdi: streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 1548 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1549 // Distribution stream 1550 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability); 1551 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1552 std::cout << "==========[test log]Check hdi: streamOperator->CommitStreams's rc " << Test_->rc << std::endl; 1553 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 1554 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 1555#ifdef CAMERA_BUILT_ON_OHOS_LITE 1556 std::shared_ptr<OHOS::Surface> producer = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 1557 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 1558 }); 1559#else 1560 OHOS::sptr<OHOS::IBufferProducer> producer = consumer->CreateProducer([this](void* addr, uint32_t size) { 1561 Test_->SaveYUV("preview", addr, size); 1562 }); 1563#endif 1564 Test_->rc = Test_->streamOperator->AttachBufferQueue(Test_->streamInfo->streamId_, producer); 1565 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1566 if (Test_->rc == Camera::NO_ERROR) { 1567 std::cout << "==========[test log]Check hdi: AttachBufferQueue success. " << std::endl; 1568 } else { 1569 std::cout << "==========[test log]Check hdi: AttachBufferQueue fail, rc = " << Test_->rc << std::endl; 1570 } 1571 // release stream 1572 Test_->captureIds = {}; 1573 Test_->streamIds = {1001}; 1574 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1575 consumer->StopConsumer(); 1576} 1577 1578/** 1579 * @tc.name: AttachBufferQueue 1580 * @tc.desc: AttachBufferQueue, streamID is not exist. 1581 * @tc.size: MediumTest 1582 * @tc.type: Function 1583 */ 1584HWTEST_F(HdiStreamTest, Camera_Hdi_0211, TestSize.Level2) 1585{ 1586 std::cout << "==========[test log]Check hdi: AttachBufferQueue, streamID is not exist.." << std::endl; 1587 // Turn on the camera 1588 Test_->Open(); 1589 Test_->CreateStreamOperatorCallback(); 1590 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 1591 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1592 // Create data stream 1593 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 1594 Test_->streamInfo->streamId_ = 1001; 1595 Test_->streamInfo->width_ = 640; 1596 Test_->StreamInfoFormat(); 1597 Test_->streamInfo->height_ = 480; 1598 Test_->streamInfo->dataspace_ = 8; 1599 Test_->streamInfo->intent_ = Camera::PREVIEW; 1600 Test_->streamInfo->tunneledMode_ = 5; 1601 std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos); 1602 Test_->streamInfos.push_back(Test_->streamInfo); 1603 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 1604 std::cout << "==========[test log]Check hdi: streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 1605 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1606 // Distribution stream 1607 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability); 1608 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1609 std::cout << "==========[test log]Check hdi: streamOperator->CommitStreams's rc " << Test_->rc << std::endl; 1610 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 1611 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 1612#ifdef CAMERA_BUILT_ON_OHOS_LITE 1613 std::shared_ptr<OHOS::Surface> producer = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 1614 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 1615 }); 1616#else 1617 OHOS::sptr<OHOS::IBufferProducer> producer = consumer->CreateProducer([this](void* addr, uint32_t size) { 1618 Test_->SaveYUV("preview", addr, size); 1619 }); 1620#endif 1621 Test_->rc = Test_->streamOperator->AttachBufferQueue(0, producer); 1622 EXPECT_EQ(Test_->rc, Camera::INVALID_ARGUMENT); 1623 if (Test_->rc == Camera::NO_ERROR) { 1624 std::cout << "==========[test log]Check hdi: AttachBufferQueue success. " << std::endl; 1625 } else { 1626 std::cout << "==========[test log]Check hdi: AttachBufferQueue fail, rc = " << Test_->rc << std::endl; 1627 } 1628 // release stream 1629 Test_->captureIds = {}; 1630 Test_->streamIds = {1001}; 1631 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1632 consumer->StopConsumer(); 1633} 1634 1635/** 1636 * @tc.name: AttachBufferQueue 1637 * @tc.desc: AttachBufferQueue, producer is nullptr. 1638 * @tc.size: MediumTest 1639 * @tc.type: Function 1640 */ 1641HWTEST_F(HdiStreamTest, Camera_Hdi_0212, TestSize.Level2) 1642{ 1643 std::cout << "==========[test log]Check hdi: AttachBufferQueue, producer is nullptr." << std::endl; 1644 // Turn on the camera 1645 Test_->Open(); 1646 Test_->CreateStreamOperatorCallback(); 1647 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 1648 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1649 // Create data stream 1650 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 1651 Test_->streamInfo->streamId_ = 1001; 1652 Test_->streamInfo->width_ = 640; 1653 Test_->streamInfo->dataspace_ = 8; 1654 Test_->streamInfo->height_ = 480; 1655 Test_->StreamInfoFormat(); 1656 Test_->streamInfo->intent_ = Camera::PREVIEW; 1657 Test_->streamInfo->tunneledMode_ = 5; 1658 std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos); 1659 Test_->streamInfos.push_back(Test_->streamInfo); 1660 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 1661 std::cout << "==========[test log]Check hdi: streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 1662 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1663 // Distribution stream 1664 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability); 1665 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1666 std::cout << "==========[test log]Check hdi: streamOperator->CommitStreams's rc " << Test_->rc << std::endl; 1667 Test_->rc = Test_->streamOperator->AttachBufferQueue(Test_->streamInfo->streamId_, nullptr); 1668 EXPECT_EQ(Test_->rc, Camera::INVALID_ARGUMENT); 1669 if (Test_->rc == Camera::NO_ERROR) { 1670 std::cout << "==========[test log]Check hdi: AttachBufferQueue success. " << std::endl; 1671 } else { 1672 std::cout << "==========[test log]Check hdi: AttachBufferQueue fail, rc = " << Test_->rc << std::endl; 1673 } 1674 // release stream 1675 Test_->captureIds = {}; 1676 Test_->streamIds = {1001}; 1677 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1678} 1679 1680/** 1681 * @tc.name: DetachBufferQueue 1682 * @tc.desc: DetachBufferQueue, normal input. 1683 * @tc.size: MediumTest 1684 * @tc.type: Function 1685 */ 1686HWTEST_F(HdiStreamTest, Camera_Hdi_0220, TestSize.Level0) 1687{ 1688 std::cout << "==========[test log]Check hdi: DetachBufferQueue, normal input." << std::endl; 1689 // Turn on the camera 1690 Test_->Open(); 1691 Test_->CreateStreamOperatorCallback(); 1692 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 1693 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1694 // Create data stream 1695 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 1696 Test_->streamInfo->streamId_ = 1001; 1697 Test_->streamInfo->width_ = 640; 1698 Test_->streamInfo->height_ = 480; 1699 Test_->StreamInfoFormat(); 1700 Test_->streamInfo->intent_ = Camera::PREVIEW; 1701 Test_->streamInfo->dataspace_ = 8; 1702 Test_->streamInfo->tunneledMode_ = 5; 1703 std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos); 1704 Test_->streamInfos.push_back(Test_->streamInfo); 1705 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 1706 std::cout << "==========[test log]Check hdi: streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 1707 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1708 // Distribution stream 1709 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability); 1710 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1711 std::cout << "==========[test log]Check hdi: streamOperator->CommitStreams's rc " << Test_->rc << std::endl; 1712 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 1713 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 1714#ifdef CAMERA_BUILT_ON_OHOS_LITE 1715 std::shared_ptr<OHOS::Surface> producer = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 1716 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 1717 }); 1718#else 1719 OHOS::sptr<OHOS::IBufferProducer> producer = consumer->CreateProducer([this](void* addr, uint32_t size) { 1720 Test_->SaveYUV("preview", addr, size); 1721 }); 1722#endif 1723 Test_->rc = Test_->streamOperator->AttachBufferQueue(Test_->streamInfo->streamId_, producer); 1724 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1725 if (Test_->rc == Camera::NO_ERROR) { 1726 std::cout << "==========[test log]Check hdi: AttachBufferQueue success. " << std::endl; 1727 } else { 1728 std::cout << "==========[test log]Check hdi: AttachBufferQueue fail, rc = " << Test_->rc << std::endl; 1729 } 1730 sleep(3); // sleep for 3 seconds 1731 Test_->rc = Test_->streamOperator->DetachBufferQueue(Test_->streamInfo->streamId_); 1732 std::cout << "==========[test log]Check hdi: streamOperator->DetachBufferQueue's rc " << Test_->rc << std::endl; 1733 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1734 // release stream 1735 Test_->captureIds = {}; 1736 Test_->streamIds = {1001}; 1737 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1738 consumer->StopConsumer(); 1739} 1740 1741/** 1742 * @tc.name: DetachBufferQueue 1743 * @tc.desc: DetachBufferQueue, streamID is not exist. 1744 * @tc.size: MediumTest 1745 * @tc.type: Function 1746 */ 1747HWTEST_F(HdiStreamTest, Camera_Hdi_0221, TestSize.Level2) 1748{ 1749 std::cout << "==========[test log]Check hdi: DetachBufferQueue, streamID is not exist." << std::endl; 1750 // Turn on the camera 1751 Test_->Open(); 1752 Test_->CreateStreamOperatorCallback(); 1753 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator); 1754 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1755 // Create data stream 1756 Test_->streamInfo = std::make_shared<Camera::StreamInfo>(); 1757 Test_->streamInfo->streamId_ = 1001; 1758 Test_->streamInfo->width_ = 640; 1759 Test_->streamInfo->intent_ = Camera::PREVIEW; 1760 Test_->streamInfo->height_ = 480; 1761 Test_->StreamInfoFormat(); 1762 Test_->streamInfo->dataspace_ = 8; 1763 Test_->streamInfo->tunneledMode_ = 5; 1764 std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos); 1765 Test_->streamInfos.push_back(Test_->streamInfo); 1766 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos); 1767 std::cout << "==========[test log]Check hdi: streamOperator->CreateStreams's rc " << Test_->rc << std::endl; 1768 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1769 // Distribution stream 1770 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability); 1771 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1772 std::cout << "==========[test log]Check hdi: streamOperator->CommitStreams's rc " << Test_->rc << std::endl; 1773 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer = 1774 std::make_shared<OHOS::Camera::Test::StreamConsumer>(); 1775#ifdef CAMERA_BUILT_ON_OHOS_LITE 1776 std::shared_ptr<OHOS::Surface> producer = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) { 1777 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize()); 1778 }); 1779#else 1780 OHOS::sptr<OHOS::IBufferProducer> producer = consumer->CreateProducer([this](void* addr, uint32_t size) { 1781 Test_->SaveYUV("preview", addr, size); 1782 }); 1783#endif 1784 Test_->rc = Test_->streamOperator->AttachBufferQueue(Test_->streamInfo->streamId_, producer); 1785 EXPECT_EQ(Test_->rc, Camera::NO_ERROR); 1786 if (Test_->rc == Camera::NO_ERROR) { 1787 std::cout << "==========[test log]Check hdi: AttachBufferQueue success. " << std::endl; 1788 } else { 1789 std::cout << "==========[test log]Check hdi: AttachBufferQueue fail, rc = " << Test_->rc << std::endl; 1790 } 1791 sleep(3); // sleep for 3 seconds 1792 Test_->rc = Test_->streamOperator->DetachBufferQueue(100); 1793 std::cout << "==========[test log]Check hdi: streamOperator->DetachBufferQueue's rc " << Test_->rc << std::endl; 1794 EXPECT_EQ(Test_->rc, Camera::INVALID_ARGUMENT); 1795 // release stream 1796 Test_->captureIds = {}; 1797 Test_->streamIds = {1001}; 1798 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1799 consumer->StopConsumer(); 1800} 1801 1802/** 1803 * @tc.name: ChangeToOfflineStream 1804 * @tc.desc: ChangeToOfflineStream, normal input. 1805 * @tc.size: MediumTest 1806 * @tc.type: Function 1807 */ 1808HWTEST_F(HdiStreamTest, Camera_Hdi_0230, TestSize.Level0) 1809{ 1810 std::cout << "==========[test log]ChangeToOfflineStream, normal input." << std::endl; 1811 Test_->Open(); 1812 // 1. Configure two streams of information 1813 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE}; 1814 Test_->StartStream(Test_->intents); 1815 // 2. Capture the preview stream 1816 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true); 1817 // 3. Capture the camera stream, continuous shooting 1818 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true); 1819 sleep(3); // sleep for 3 seconds 1820 // 4. Convert to offline stream 1821 Test_->CreateOfflineStreamOperatorCallback(); 1822 std::vector<int> offlineIds; 1823 offlineIds.push_back(Test_->streamId_capture); 1824 Test_->rc = Test_->streamOperator->ChangeToOfflineStream( 1825 offlineIds, Test_->offlineStreamOperatorCallback, Test_->offlineStreamOperator); 1826 ASSERT_EQ(Test_->rc, Camera::NO_ERROR); 1827 std::cout << "==========[test log] ChangeToOfflineStream rc = " << Test_->rc << std::endl; 1828 EXPECT_EQ(true, Test_->offlineStreamOperator != nullptr); 1829 if (Test_->rc == Camera::NO_ERROR) { 1830 std::cout << "==========[test log] offline StreamOperator != nullptr" << std::endl; 1831 } else { 1832 std::cout << "==========[test log] offline StreamOperator == nullptr" << std::endl; 1833 } 1834 // 5. Post-processing of the original stream 1835 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture}; 1836 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture}; 1837 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1838 // 6. Post-processing of offline streams 1839 Test_->cameraDevice->Close(); 1840 std::cout << "==========[test log] Pretend to wait 5s for callback..." << std::endl; 1841 sleep(3); // sleep for 3 seconds 1842 Test_->StopOfflineStream(Test_->captureId_capture); 1843 Test_->StopConsumer(Test_->intents); 1844} 1845 1846/** 1847 * @tc.name: ChangeToOfflineStream 1848 * @tc.desc: ChangeToOfflineStream, streamId is not exist. 1849 * @tc.size: MediumTest 1850 * @tc.type: Function 1851 */ 1852HWTEST_F(HdiStreamTest, Camera_Hdi_0231, TestSize.Level2) 1853{ 1854 std::cout << "==========[test log]ChangeToOfflineStream, streamId is not exist." << std::endl; 1855 Test_->Open(); 1856 // Configure two streams of information 1857 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE}; 1858 Test_->StartStream(Test_->intents); 1859 // Capture preview stream 1860 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true); 1861 // Capture the photo stream, single capture 1862 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true); 1863 sleep(3); // sleep for 3 seconds 1864 // Convert to offline stream 1865 Test_->CreateOfflineStreamOperatorCallback(); 1866 Test_->rc = Test_->streamOperator->ChangeToOfflineStream( 1867 {99}, Test_->offlineStreamOperatorCallback, Test_->offlineStreamOperator); 1868 ASSERT_EQ(Test_->rc, Camera::INVALID_ARGUMENT); 1869 std::cout << "==========[test log]Check offline: ChangeToOfflineStream rc = " << Test_->rc << std::endl; 1870 EXPECT_EQ(true, Test_->offlineStreamOperator == nullptr); 1871 if (Test_->rc == Camera::NO_ERROR) { 1872 std::cout << "==========[test log]Check offline stream: offline StreamOperator != nullptr" << std::endl; 1873 } else { 1874 std::cout << "==========[test log]Check offline stream: offline StreamOperator == nullptr" << std::endl; 1875 } 1876 // Post-processing of the original stream 1877 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture}; 1878 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture}; 1879 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1880 Test_->StopConsumer(Test_->intents); 1881} 1882 1883/** 1884 * @tc.name: ChangeToOfflineStream 1885 * @tc.desc: ChangeToOfflineStream, offlineStreamOperatorCallback is nullptr. 1886 * @tc.size: MediumTest 1887 * @tc.type: Function 1888 */ 1889HWTEST_F(HdiStreamTest, Camera_Hdi_0232, TestSize.Level2) 1890{ 1891 std::cout << "==========[test log]ChangeToOfflineStream, offlineStreamOperatorCallback is nullptr." << std::endl; 1892 Test_->Open(); 1893 // Configure two streams of information 1894 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE}; 1895 Test_->StartStream(Test_->intents); 1896 // Capture preview stream 1897 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true); 1898 // Capture the photo stream, single capture 1899 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true); 1900 sleep(3); // sleep for 3 seconds 1901 // Convert to offline stream 1902 Test_->offlineStreamOperatorCallback = nullptr; 1903 Test_->rc = Test_->streamOperator->ChangeToOfflineStream( 1904 {99}, Test_->offlineStreamOperatorCallback, Test_->offlineStreamOperator); 1905 ASSERT_EQ(Test_->rc, Camera::INVALID_ARGUMENT); 1906 std::cout << "==========[test log]Check offline: ChangeToOfflineStream rc = " << Test_->rc << std::endl; 1907 EXPECT_EQ(true, Test_->offlineStreamOperator == nullptr); 1908 if (Test_->rc == Camera::NO_ERROR) { 1909 std::cout << "==========[test log]Check offline stream: offline StreamOperator != nullptr" << std::endl; 1910 } else { 1911 std::cout << "==========[test log]Check offline stream: offline StreamOperator == nullptr" << std::endl; 1912 } 1913 // Post-processing of the original stream 1914 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture}; 1915 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture}; 1916 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1917 Test_->StopConsumer(Test_->intents); 1918} 1919 1920/** 1921 * @tc.name: offlineStreamOperator->CancelCapture 1922 * @tc.desc: offlineStreamOperator->CancelCapture, -1. 1923 * @tc.size: MediumTest 1924 * @tc.type: Function 1925 */ 1926HWTEST_F(HdiStreamTest, Camera_Hdi_0241, TestSize.Level2) 1927{ 1928 std::cout << "==========[test log]ChangeToOfflineStream, normal input." << std::endl; 1929 Test_->Open(); 1930 // 1. Configure two streams of information 1931 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE}; 1932 Test_->StartStream(Test_->intents); 1933 // 2. Capture the preview stream 1934 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true); 1935 // 3. Capture the camera stream, continuous shooting 1936 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true); 1937 sleep(3); // sleep for 3 seconds 1938 // 4. Convert to offline stream 1939 Test_->CreateOfflineStreamOperatorCallback(); 1940 std::vector<int> offlineIds; 1941 offlineIds.push_back(Test_->streamId_capture); 1942 Test_->rc = Test_->streamOperator->ChangeToOfflineStream( 1943 offlineIds, Test_->offlineStreamOperatorCallback, Test_->offlineStreamOperator); 1944 ASSERT_EQ(Test_->rc, Camera::NO_ERROR); 1945 std::cout << "==========[test log] ChangeToOfflineStream rc = " << Test_->rc << std::endl; 1946 EXPECT_EQ(true, Test_->offlineStreamOperator != nullptr); 1947 if (Test_->rc == Camera::NO_ERROR) { 1948 std::cout << "==========[test log] offline StreamOperator != nullptr" << std::endl; 1949 } else { 1950 std::cout << "==========[test log] offline StreamOperator == nullptr" << std::endl; 1951 } 1952 // 5. Post-processing of the original stream 1953 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture}; 1954 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture}; 1955 Test_->StopStream(Test_->captureIds, Test_->streamIds); 1956 // 6. Post-processing of offline streams 1957 Test_->cameraDevice->Close(); 1958 std::cout << "==========[test log] Pretend to wait 5s for callback..." << std::endl; 1959 sleep(3); // sleep for 3 seconds 1960 1961 Test_->rc = Test_->offlineStreamOperator->CancelCapture(-1); 1962 EXPECT_EQ(Test_->rc, Camera::INVALID_ARGUMENT); 1963 std::cout << "==========[test log]check offline: CancelCapture fail, rc = " << Test_->rc; 1964 std::cout << "captureId = -1" << std::endl; 1965 1966 Test_->StopOfflineStream(Test_->captureId_capture); 1967 Test_->StopConsumer(Test_->intents); 1968} 1969