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#include "hdi_iter_test.h" 16 17constexpr int ITEM_CAPACITY_SIZE = 2; 18constexpr int DATA_CAPACITY_SIZE = 128; 19 20void UtestHdiIterTest::SetUpTestCase(void) 21{} 22void UtestHdiIterTest::TearDownTestCase(void) 23{} 24void UtestHdiIterTest::SetUp(void) 25{ 26 if (cameraBase == nullptr) 27 cameraBase = std::make_shared<TestCameraBase>(); 28 cameraBase->FBInit(); 29 cameraBase->Init(); 30} 31void UtestHdiIterTest::TearDown(void) 32{ 33 cameraBase->Close(); 34} 35 36/** 37 * @tc.name: CreateStreams 38 * @tc.desc: CreateStreams, success. 39 * @tc.level: Level1 40 * @tc.size: MediumTest 41 * @tc.type: Function 42 */ 43TEST_F(UtestHdiIterTest, camera_hdi_0130) 44{ 45 std::cout << "==========[test log] CreateStreams, success." << std::endl; 46 // Create and get streamOperator information 47 cameraBase->AchieveStreamOperator(); 48 // Create data stream 49 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 50 producer->SetQueueSize(8); // 8:set bufferQueue size 51 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 52 std::cout << "~~~~~~~" << std::endl; 53 } 54 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 55 cameraBase->BufferCallback(b, cameraBase->preview_mode); 56 return; 57 }; 58 producer->SetCallback(callback); 59 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 60 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 61 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 62 cameraBase->streamInfo->width_ = 640; // 640:picture width 63 cameraBase->streamInfo->height_ = 480; // 480:picture height 64 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 65 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 66 cameraBase->streamInfo->intent_ = PREVIEW; 67 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 68 cameraBase->streamInfo->bufferQueue_ = producer; 69 streamInfos.push_back(cameraBase->streamInfo); 70 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 71 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 72 if (cameraBase->rc == NO_ERROR) { 73 std::cout << "==========[test log] CreateStreams success." << std::endl; 74 } else { 75 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 76 } 77 // release stream 78 std::vector<int> streamIds; 79 streamIds.push_back(cameraBase->streamInfo->streamId_); 80 cameraBase->rc = cameraBase->streamOperator->ReleaseStreams(streamIds); 81 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 82 if (cameraBase->rc == NO_ERROR) { 83 std::cout << "==========[test log] ReleaseStreams success." << std::endl; 84 } else { 85 std::cout << "==========[test log] ReleaseStreams fail, rc = " << cameraBase->rc << std::endl; 86 } 87} 88 89/** 90 * @tc.name: CreateStreams 91 * @tc.desc: CreateStreams, StreamInfo->streamId = -1, return error. 92 * @tc.level: Level2 93 * @tc.size: MediumTest 94 * @tc.type: Function 95 */ 96TEST_F(UtestHdiIterTest, camera_hdi_0131) 97{ 98 std::cout << "==========[test log] CreateStreams, StreamInfo->streamId = -1, return error." << std::endl; 99 // Create and get streamOperator information 100 cameraBase->AchieveStreamOperator(); 101 // Create data stream 102 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 103 producer->SetQueueSize(8); // 8:set bufferQueue size 104 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 105 std::cout << "~~~~~~~" << std::endl; 106 } 107 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 108 cameraBase->BufferCallback(b, cameraBase->preview_mode); 109 return; 110 }; 111 producer->SetCallback(callback); 112 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 113 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 114 cameraBase->streamInfo->streamId_ = -1; 115 cameraBase->streamInfo->width_ = 640; // 640:picture width 116 cameraBase->streamInfo->height_ = 480; // 480:picture height 117 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 118 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 119 cameraBase->streamInfo->intent_ = PREVIEW; 120 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 121 cameraBase->streamInfo->bufferQueue_ = producer; 122 streamInfos.push_back(cameraBase->streamInfo); 123 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 124 if (cameraBase->rc == NO_ERROR) { 125 std::cout << "==========[test log] CreateStreams success." << std::endl; 126 } else { 127 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 128 } 129 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 130 EXPECT_EQ(INVALID_ARGUMENT, cameraBase->rc); 131} 132 133/** 134 * @tc.name: CreateStreams 135 * @tc.desc: CreateStreams, StreamInfo->streamId = 2147483647, return success. 136 * @tc.level: Level2 137 * @tc.size: MediumTest 138 * @tc.type: Function 139 */ 140TEST_F(UtestHdiIterTest, camera_hdi_0132) 141{ 142 std::cout << "==========[test log] CreateStreams,"; 143 std::cout << "StreamInfo->streamId = 2147483647, return success." << std::endl; 144 // Create and get streamOperator information 145 cameraBase->AchieveStreamOperator(); 146 // Create data stream 147 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 148 producer->SetQueueSize(8); // 8:set bufferQueue size 149 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 150 std::cout << "~~~~~~~" << std::endl; 151 } 152 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 153 cameraBase->BufferCallback(b, cameraBase->preview_mode); 154 return; 155 }; 156 producer->SetCallback(callback); 157 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 158 std::shared_ptr<StreamInfo> streamInfo = std::make_shared<StreamInfo>(); 159 streamInfo->streamId_ = INVALID_VALUE_TEST; 160 streamInfo->width_ = 640; // 640:picture width 161 streamInfo->height_ = 480; // 480:picture height 162 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 163 streamInfo->dataspace_ = 8; // 8:picture dataspace 164 streamInfo->intent_ = PREVIEW; 165 streamInfo->tunneledMode_ = 5; // 5:tunnel mode 166 streamInfo->bufferQueue_ = producer; 167 168 std::vector<std::shared_ptr<StreamInfo>>().swap(streamInfos); 169 streamInfos.push_back(streamInfo); 170 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 171 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 172 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 173 if (cameraBase->rc == NO_ERROR) { 174 std::cout << "==========[test log] CreateStreams success." << std::endl; 175 } else { 176 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 177 } 178} 179 180/** 181 * @tc.name: CreateStreams 182 * @tc.desc: CreateStreams, StreamInfo->width = -1, return error. 183 * @tc.level: Level2 184 * @tc.size: MediumTest 185 * @tc.type: Function 186 */ 187TEST_F(UtestHdiIterTest, camera_hdi_0133) 188{ 189 std::cout << "==========[test log] CreateStreams, StreamInfo->width = -1, return error." << std::endl; 190 // Create and get streamOperator information 191 cameraBase->AchieveStreamOperator(); 192 // Create data stream 193 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 194 producer->SetQueueSize(8); // 8:set bufferQueue size 195 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 196 std::cout << "~~~~~~~" << std::endl; 197 } 198 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 199 cameraBase->BufferCallback(b, cameraBase->preview_mode); 200 return; 201 }; 202 producer->SetCallback(callback); 203 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 204 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 205 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 206 cameraBase->streamInfo->width_ = -1; 207 cameraBase->streamInfo->height_ = 640; // 640:picture height 208 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 209 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 210 cameraBase->streamInfo->intent_ = PREVIEW; 211 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 212 cameraBase->streamInfo->bufferQueue_ = producer; 213 streamInfos.push_back(cameraBase->streamInfo); 214 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 215 if (cameraBase->rc == NO_ERROR) { 216 std::cout << "==========[test log] CreateStreams success." << std::endl; 217 } else { 218 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 219 } 220 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 221 EXPECT_EQ(INVALID_ARGUMENT, cameraBase->rc); 222} 223 224/** 225 * @tc.name: CreateStreams 226 * @tc.desc: CreateStreams, StreamInfo->width = 2147483647, success. 227 * @tc.level: Level2 228 * @tc.size: MediumTest 229 * @tc.type: Function 230 */ 231TEST_F(UtestHdiIterTest, camera_hdi_0134) 232{ 233 std::cout << "==========[test log] CreateStreams, StreamInfo->width = 2147483647, success." << std::endl; 234 // Create and get streamOperator information 235 cameraBase->AchieveStreamOperator(); 236 // Create data stream 237 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 238 producer->SetQueueSize(8); // 8:set bufferQueue size 239 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 240 std::cout << "~~~~~~~" << std::endl; 241 } 242 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 243 cameraBase->BufferCallback(b, cameraBase->preview_mode); 244 return; 245 }; 246 producer->SetCallback(callback); 247 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 248 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 249 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 250 cameraBase->streamInfo->width_ = INVALID_VALUE_TEST; 251 cameraBase->streamInfo->height_ = 480; // 480:picture height 252 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 253 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 254 cameraBase->streamInfo->intent_ = PREVIEW; 255 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 256 cameraBase->streamInfo->bufferQueue_ = producer; 257 streamInfos.push_back(cameraBase->streamInfo); 258 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 259 if (cameraBase->rc == NO_ERROR) { 260 std::cout << "==========[test log] CreateStreams success." << std::endl; 261 } else { 262 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 263 } 264 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 265 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 266 // release stream 267 std::vector<int> streamIds; 268 streamIds.push_back(cameraBase->streamInfo->streamId_); 269 cameraBase->rc = cameraBase->streamOperator->ReleaseStreams(streamIds); 270 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 271 if (cameraBase->rc == NO_ERROR) { 272 std::cout << "==========[test log] ReleaseStreams success." << std::endl; 273 } else { 274 std::cout << "==========[test log] ReleaseStreams fail, rc = " << cameraBase->rc << std::endl; 275 } 276} 277 278/** 279 * @tc.name: CreateStreams 280 * @tc.desc: CreateStreams, StreamInfo->height = -1, return error. 281 * @tc.level: Level2 282 * @tc.size: MediumTest 283 * @tc.type: Function 284 */ 285TEST_F(UtestHdiIterTest, camera_hdi_0135) 286{ 287 std::cout << "==========[test log] CreateStreams, StreamInfo->height = -1, return error." << std::endl; 288 // Create and get streamOperator information 289 cameraBase->AchieveStreamOperator(); 290 // Create data stream 291 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 292 producer->SetQueueSize(8); // 8:set bufferQueue size 293 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 294 std::cout << "~~~~~~~" << std::endl; 295 } 296 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 297 cameraBase->BufferCallback(b, cameraBase->preview_mode); 298 return; 299 }; 300 producer->SetCallback(callback); 301 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 302 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 303 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 304 cameraBase->streamInfo->width_ = 640; // 640:picture width 305 cameraBase->streamInfo->height_ = -1; 306 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 307 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 308 cameraBase->streamInfo->intent_ = PREVIEW; 309 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 310 cameraBase->streamInfo->bufferQueue_ = producer; 311 streamInfos.push_back(cameraBase->streamInfo); 312 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 313 if (cameraBase->rc == NO_ERROR) { 314 std::cout << "==========[test log] CreateStreams success." << std::endl; 315 } else { 316 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 317 } 318 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 319 EXPECT_EQ(INVALID_ARGUMENT, cameraBase->rc); 320} 321 322/** 323 * @tc.name: CreateStreams 324 * @tc.desc: CreateStreams, StreamInfo->height = 2147483647, success. 325 * @tc.level: Level2 326 * @tc.size: MediumTest 327 * @tc.type: Function 328 */ 329TEST_F(UtestHdiIterTest, camera_hdi_0136) 330{ 331 std::cout << "==========[test log] CreateStreams, StreamInfo->height = 2147483647, success." << std::endl; 332 // Create and get streamOperator information 333 cameraBase->AchieveStreamOperator(); 334 // Create data stream 335 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 336 producer->SetQueueSize(8); // 8:set bufferQueue size 337 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 338 std::cout << "~~~~~~~" << std::endl; 339 } 340 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 341 cameraBase->BufferCallback(b, cameraBase->preview_mode); 342 return; 343 }; 344 producer->SetCallback(callback); 345 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 346 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 347 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 348 cameraBase->streamInfo->width_ = 640; // 640:picture width 349 cameraBase->streamInfo->height_ = INVALID_VALUE_TEST; 350 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 351 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 352 cameraBase->streamInfo->intent_ = PREVIEW; 353 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 354 cameraBase->streamInfo->bufferQueue_ = producer; 355 streamInfos.push_back(cameraBase->streamInfo); 356 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 357 if (cameraBase->rc == NO_ERROR) { 358 std::cout << "==========[test log] CreateStreams success." << std::endl; 359 } else { 360 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 361 } 362 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 363 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 364} 365 366/** 367 * @tc.name: CreateStreams 368 * @tc.desc: CreateStreams, StreamInfo->format = -1, return error. 369 * @tc.level: Level2 370 * @tc.size: MediumTest 371 * @tc.type: Function 372 */ 373TEST_F(UtestHdiIterTest, camera_hdi_0137) 374{ 375 std::cout << "==========[test log] CreateStreams, StreamInfo->format = -1, return error." << std::endl; 376 // Create and get streamOperator information 377 cameraBase->AchieveStreamOperator(); 378 // Create data stream 379 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 380 producer->SetQueueSize(8); // 8:set bufferQueue size 381 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 382 std::cout << "~~~~~~~" << std::endl; 383 } 384 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 385 cameraBase->BufferCallback(b, cameraBase->preview_mode); 386 return; 387 }; 388 producer->SetCallback(callback); 389 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 390 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 391 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 392 cameraBase->streamInfo->width_ = 640; // 640:picture width 393 cameraBase->streamInfo->height_ = 480; // 480:picture height 394 cameraBase->streamInfo->format_ = -1; 395 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 396 cameraBase->streamInfo->intent_ = PREVIEW; 397 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 398 cameraBase->streamInfo->bufferQueue_ = producer; 399 streamInfos.push_back(cameraBase->streamInfo); 400 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 401 if (cameraBase->rc == NO_ERROR) { 402 std::cout << "==========[test log] CreateStreams success." << std::endl; 403 } else { 404 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 405 } 406 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 407 EXPECT_EQ(INVALID_ARGUMENT, cameraBase->rc); 408} 409 410/** 411 * @tc.name: CreateStreams 412 * @tc.desc: CreateStreams, StreamInfo->format = 2147483647, success. 413 * @tc.level: Level2 414 * @tc.size: MediumTest 415 * @tc.type: Function 416 */ 417TEST_F(UtestHdiIterTest, camera_hdi_0138) 418{ 419 std::cout << "==========[test log] CreateStreams, StreamInfo->format = 2147483647, success." << std::endl; 420 // Create and get streamOperator information 421 cameraBase->AchieveStreamOperator(); 422 // Create data stream 423 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 424 producer->SetQueueSize(8); // 8:set bufferQueue size 425 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 426 std::cout << "~~~~~~~" << std::endl; 427 } 428 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 429 cameraBase->BufferCallback(b, cameraBase->preview_mode); 430 return; 431 }; 432 producer->SetCallback(callback); 433 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 434 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 435 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 436 cameraBase->streamInfo->width_ = 640; // 640:picture width 437 cameraBase->streamInfo->height_ = 480; // 480:picture height 438 cameraBase->streamInfo->format_ = INVALID_VALUE_TEST; 439 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 440 cameraBase->streamInfo->intent_ = PREVIEW; 441 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 442 cameraBase->streamInfo->bufferQueue_ = producer; 443 streamInfos.push_back(cameraBase->streamInfo); 444 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 445 if (cameraBase->rc == NO_ERROR) { 446 std::cout << "==========[test log] CreateStreams success." << std::endl; 447 } else { 448 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 449 } 450 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 451 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 452 // release stream 453 std::vector<int> streamIds; 454 streamIds.push_back(cameraBase->streamInfo->streamId_); 455 cameraBase->rc = cameraBase->streamOperator->ReleaseStreams(streamIds); 456 if (cameraBase->rc == NO_ERROR) { 457 std::cout << "==========[test log] ReleaseStreams success." << std::endl; 458 } else { 459 std::cout << "==========[test log] ReleaseStreams fail, rc = " << cameraBase->rc << std::endl; 460 } 461 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 462} 463 464/** 465 * @tc.name: CreateStreams 466 * @tc.desc: CreateStreams, StreamInfo->dataspace = -1, return error. 467 * @tc.level: Level2 468 * @tc.size: MediumTest 469 * @tc.type: Function 470 */ 471TEST_F(UtestHdiIterTest, camera_hdi_0139) 472{ 473 std::cout << "==========[test log] CreateStreams, StreamInfo->dataspace = -1, return error." << std::endl; 474 // Create and get streamOperator information 475 cameraBase->AchieveStreamOperator(); 476 // Create data stream 477 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 478 producer->SetQueueSize(8); // 8:set bufferQueue size 479 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 480 std::cout << "~~~~~~~" << std::endl; 481 } 482 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 483 cameraBase->BufferCallback(b, cameraBase->preview_mode); 484 return; 485 }; 486 producer->SetCallback(callback); 487 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 488 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 489 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 490 cameraBase->streamInfo->width_ = 640; // 640:picture width 491 cameraBase->streamInfo->height_ = 480; // 480:picture height 492 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 493 cameraBase->streamInfo->dataspace_ = -1; 494 cameraBase->streamInfo->intent_ = PREVIEW; 495 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 496 cameraBase->streamInfo->bufferQueue_ = producer; 497 streamInfos.push_back(cameraBase->streamInfo); 498 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 499 if (cameraBase->rc == NO_ERROR) { 500 std::cout << "==========[test log] CreateStreams success." << std::endl; 501 } else { 502 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 503 } 504 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 505 EXPECT_EQ(INVALID_ARGUMENT, cameraBase->rc); 506} 507 508/** 509 * @tc.name: CreateStreams 510 * @tc.desc: CreateStreams, StreamInfo->dataspace = 2147483647, success. 511 * @tc.level: Level2 512 * @tc.size: MediumTest 513 * @tc.type: Function 514 */ 515TEST_F(UtestHdiIterTest, camera_hdi_0140) 516{ 517 std::cout << "==========[test log] CreateStreams,"; 518 std::cout << "StreamInfo->dataspace = 2147483647, success." << std::endl; 519 // Create and get streamOperator information 520 cameraBase->AchieveStreamOperator(); 521 // Create data stream 522 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 523 producer->SetQueueSize(8); // 8:set bufferQueue size 524 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 525 std::cout << "~~~~~~~" << std::endl; 526 } 527 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 528 cameraBase->BufferCallback(b, cameraBase->preview_mode); 529 return; 530 }; 531 producer->SetCallback(callback); 532 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 533 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 534 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 535 cameraBase->streamInfo->width_ = 640; // 640:picture width 536 cameraBase->streamInfo->height_ = 480; // 480:picture height 537 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 538 cameraBase->streamInfo->dataspace_ = INVALID_VALUE_TEST; 539 cameraBase->streamInfo->intent_ = PREVIEW; 540 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 541 cameraBase->streamInfo->bufferQueue_ = producer; 542 streamInfos.push_back(cameraBase->streamInfo); 543 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 544 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 545 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 546 if (cameraBase->rc == NO_ERROR) { 547 std::cout << "==========[test log] CreateStreams success." << std::endl; 548 } else { 549 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 550 } 551 // release stream 552 std::vector<int> streamIds; 553 streamIds.push_back(cameraBase->streamInfo->streamId_); 554 cameraBase->rc = cameraBase->streamOperator->ReleaseStreams(streamIds); 555 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 556 if (cameraBase->rc == NO_ERROR) { 557 std::cout << "==========[test log] ReleaseStreams success." << std::endl; 558 } else { 559 std::cout << "==========[test log] ReleaseStreams fail, rc = " << cameraBase->rc << std::endl; 560 } 561} 562 563/** 564 * @tc.name: CreateStreams 565 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = PREVIEW, success. 566 * @tc.level: Level2 567 * @tc.size: MediumTest 568 * @tc.type: Function 569 */ 570TEST_F(UtestHdiIterTest, camera_hdi_0141) 571{ 572 std::cout << "==========[test log] CreateStreams,"; 573 std::cout << "StreamInfo->StreamIntent = PREVIEW, success." << std::endl; 574 // Create and get streamOperator information 575 cameraBase->AchieveStreamOperator(); 576 // Create data stream 577 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 578 producer->SetQueueSize(8); // 8:set bufferQueue size 579 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 580 std::cout << "~~~~~~~" << std::endl; 581 } 582 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 583 cameraBase->BufferCallback(b, cameraBase->preview_mode); 584 return; 585 }; 586 producer->SetCallback(callback); 587 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 588 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 589 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 590 cameraBase->streamInfo->width_ = 640; // 640:picture width 591 cameraBase->streamInfo->height_ = 1080; // 1080:picture height 592 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 593 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 594 cameraBase->streamInfo->intent_ = PREVIEW; 595 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 596 cameraBase->streamInfo->bufferQueue_ = producer; 597 streamInfos.push_back(cameraBase->streamInfo); 598 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 599 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 600 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 601 if (cameraBase->rc == NO_ERROR) { 602 std::cout << "==========[test log] CreateStreams success." << std::endl; 603 } else { 604 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 605 } 606 // release stream 607 std::vector<int> streamIds; 608 streamIds.push_back(cameraBase->streamInfo->streamId_); 609 cameraBase->rc = cameraBase->streamOperator->ReleaseStreams(streamIds); 610 if (cameraBase->rc == NO_ERROR) { 611 std::cout << "==========[test log] ReleaseStreams success." << std::endl; 612 } else { 613 std::cout << "==========[test log] ReleaseStreams fail, rc = " << cameraBase->rc << std::endl; 614 } 615 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 616} 617 618/** 619 * @tc.name: CreateStreams 620 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = VIDEO, success. 621 * @tc.level: Level2 622 * @tc.size: MediumTest 623 * @tc.type: Function 624 */ 625TEST_F(UtestHdiIterTest, camera_hdi_0142) 626{ 627 std::cout << "==========[test log] CreateStreams,"; 628 std::cout << "StreamInfo->StreamIntent = VIDEO, success." << std::endl; 629 // Create and get streamOperator information 630 cameraBase->AchieveStreamOperator(); 631 // Create data stream1080 632 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 633 producer->SetQueueSize(8); // 8:set bufferQueue size 634 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 635 std::cout << "~~~~~~~" << std::endl; 636 } 637 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 638 cameraBase->BufferCallback(b, cameraBase->video_mode); 639 return; 640 }; 641 producer->SetCallback(callback); 642 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 643 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 644 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 645 cameraBase->streamInfo->width_ = 640; // 640:picture width 646 cameraBase->streamInfo->height_ = 1080; // 1080:picture height 647 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 648 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 649 cameraBase->streamInfo->intent_ = VIDEO; 650 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 651 cameraBase->streamInfo->bufferQueue_ = producer; 652 streamInfos.push_back(cameraBase->streamInfo); 653 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 654 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 655 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 656 if (cameraBase->rc == NO_ERROR) { 657 std::cout << "==========[test log] CreateStreams success." << std::endl; 658 } else { 659 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 660 } 661 // release stream 662 std::vector<int> streamIds; 663 streamIds.push_back(cameraBase->streamInfo->streamId_); 664 cameraBase->rc = cameraBase->streamOperator->ReleaseStreams(streamIds); 665 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 666 if (cameraBase->rc == NO_ERROR) { 667 std::cout << "==========[test log] ReleaseStreams success." << std::endl; 668 } else { 669 std::cout << "==========[test log] ReleaseStreams fail, rc = " << cameraBase->rc << std::endl; 670 } 671} 672 673/** 674 * @tc.name: CreateStreams 675 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = STILL_CAPTURE, success. 676 * @tc.level: Level2 677 * @tc.size: MediumTest 678 * @tc.type: Function 679 */ 680TEST_F(UtestHdiIterTest, camera_hdi_0143) 681{ 682 std::cout << "==========[test log] CreateStreams,"; 683 std::cout << "StreamInfo->StreamIntent = STILL_CAPTURE, success." << std::endl; 684 // Create and get streamOperator information 685 cameraBase->AchieveStreamOperator(); 686 // Create data stream 687 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 688 producer->SetQueueSize(8); // 8:set bufferQueue size 689 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 690 std::cout << "~~~~~~~" << std::endl; 691 } 692 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 693 cameraBase->BufferCallback(b, cameraBase->capture_mode); 694 return; 695 }; 696 producer->SetCallback(callback); 697 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 698 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 699 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 700 cameraBase->streamInfo->width_ = 640; // 640:picture width 701 cameraBase->streamInfo->height_ = 1080; // 1080:picture height 702 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 703 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 704 cameraBase->streamInfo->intent_ = STILL_CAPTURE; 705 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 706 cameraBase->streamInfo->bufferQueue_ = producer; 707 streamInfos.push_back(cameraBase->streamInfo); 708 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 709 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 710 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 711 if (cameraBase->rc == NO_ERROR) { 712 std::cout << "==========[test log] CreateStreams success." << std::endl; 713 } else { 714 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 715 } 716 // release stream 717 std::vector<int> streamIds; 718 streamIds.push_back(cameraBase->streamInfo->streamId_); 719 cameraBase->rc = cameraBase->streamOperator->ReleaseStreams(streamIds); 720 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 721 if (cameraBase->rc == NO_ERROR) { 722 std::cout << "==========[test log] ReleaseStreams success." << std::endl; 723 } else { 724 std::cout << "==========[test log] ReleaseStreams fail, rc = " << cameraBase->rc << std::endl; 725 } 726} 727 728/** 729 * @tc.name: CreateStreams 730 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = POST_VIEW;, success. 731 * @tc.level: Level2 732 * @tc.size: MediumTest 733 * @tc.type: Function 734 */ 735TEST_F(UtestHdiIterTest, camera_hdi_0144) 736{ 737 std::cout << "==========[test log] CreateStreams,"; 738 std::cout << "StreamInfo->StreamIntent = POST_VIEW;, success." << std::endl; 739 // Create and get streamOperator information 740 cameraBase->AchieveStreamOperator(); 741 // Create data stream 742 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 743 producer->SetQueueSize(8); // 8:set bufferQueue size 744 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 745 std::cout << "~~~~~~~" << std::endl; 746 } 747 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 748 cameraBase->BufferCallback(b, cameraBase->preview_mode); 749 return; 750 }; 751 producer->SetCallback(callback); 752 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 753 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 754 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 755 cameraBase->streamInfo->width_ = 640; // 640:picture width 756 cameraBase->streamInfo->height_ = 1080; // 1080:picture height 757 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 758 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 759 cameraBase->streamInfo->intent_ = POST_VIEW; 760 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 761 cameraBase->streamInfo->bufferQueue_ = producer; 762 streamInfos.push_back(cameraBase->streamInfo); 763 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 764 if (cameraBase->rc == NO_ERROR) { 765 std::cout << "==========[test log] CreateStreams success." << std::endl; 766 } else { 767 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 768 } 769 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 770 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 771 // release stream 772 std::vector<int> streamIds; 773 streamIds.push_back(cameraBase->streamInfo->streamId_); 774 cameraBase->rc = cameraBase->streamOperator->ReleaseStreams(streamIds); 775 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 776 if (cameraBase->rc == NO_ERROR) { 777 std::cout << "==========[test log] ReleaseStreams success." << std::endl; 778 } else { 779 std::cout << "==========[test log] ReleaseStreams fail, rc = " << cameraBase->rc << std::endl; 780 } 781} 782 783/** 784 * @tc.name: CreateStreams 785 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = ANALYZE;, success. 786 * @tc.level: Level2 787 * @tc.size: MediumTest 788 * @tc.type: Function 789 */ 790TEST_F(UtestHdiIterTest, camera_hdi_0145) 791{ 792 std::cout << "==========[test log] CreateStreams,"; 793 std::cout << "StreamInfo->StreamIntent = ANALYZE;, success." << std::endl; 794 // Create and get streamOperator information 795 cameraBase->AchieveStreamOperator(); 796 // Create data stream 797 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 798 producer->SetQueueSize(8); // 8:set bufferQueue size 799 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 800 std::cout << "~~~~~~~" << std::endl; 801 } 802 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 803 cameraBase->BufferCallback(b, cameraBase->preview_mode); 804 return; 805 }; 806 producer->SetCallback(callback); 807 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 808 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 809 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 810 cameraBase->streamInfo->width_ = 640; // 640:picture width 811 cameraBase->streamInfo->height_ = 1080; // 1080:picture height 812 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 813 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 814 cameraBase->streamInfo->intent_ = ANALYZE; 815 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 816 cameraBase->streamInfo->bufferQueue_ = producer; 817 streamInfos.push_back(cameraBase->streamInfo); 818 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 819 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 820 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 821 if (cameraBase->rc == NO_ERROR) { 822 std::cout << "==========[test log] CreateStreams success." << std::endl; 823 } else { 824 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 825 } 826 // release stream 827 std::vector<int> streamIds; 828 streamIds.push_back(cameraBase->streamInfo->streamId_); 829 cameraBase->rc = cameraBase->streamOperator->ReleaseStreams(streamIds); 830 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 831 if (cameraBase->rc == NO_ERROR) { 832 std::cout << "==========[test log] ReleaseStreams success." << std::endl; 833 } else { 834 std::cout << "==========[test log] ReleaseStreams fail, rc = " << cameraBase->rc << std::endl; 835 } 836} 837 838/** 839 * @tc.name: CreateStreams 840 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = Camera::CUSTOM;, not support. 841 * @tc.level: Level2 842 * @tc.size: MediumTest 843 * @tc.type: Function 844 */ 845TEST_F(UtestHdiIterTest, camera_hdi_0146) 846{ 847 std::cout << "==========[test log] CreateStreams,"; 848 std::cout << "StreamInfo->StreamIntent = Camera::CUSTOM;, success." << std::endl; 849 // Create and get streamOperator information 850 cameraBase->AchieveStreamOperator(); 851 // Create data stream 852 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 853 producer->SetQueueSize(8); // 8:set bufferQueue size 854 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 855 std::cout << "~~~~~~~" << std::endl; 856 } 857 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 858 cameraBase->BufferCallback(b, cameraBase->preview_mode); 859 return; 860 }; 861 producer->SetCallback(callback); 862 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 863 std::shared_ptr<StreamInfo> streamInfo = std::make_shared<StreamInfo>(); 864 streamInfo->streamId_ = DEFAULT_STREAM_ID; 865 streamInfo->width_ = 640; // 640:picture width 866 streamInfo->height_ = 480; // 480:picture height 867 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 868 streamInfo->dataspace_ = 8; // 8:picture dataspace 869 streamInfo->intent_ = Camera::CUSTOM; 870 streamInfo->tunneledMode_ = 5; // 5:tunnel mode 871 streamInfo->bufferQueue_ = producer; 872 873 std::vector<std::shared_ptr<StreamInfo>>().swap(streamInfos); 874 streamInfos.push_back(streamInfo); 875 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 876 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 877 EXPECT_EQ(true, cameraBase->rc != NO_ERROR); 878 if (cameraBase->rc == NO_ERROR) { 879 std::cout << "==========[test log] CreateStreams success." << std::endl; 880 } else { 881 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 882 } 883} 884 885/** 886 * @tc.name: CreateStreams 887 * @tc.desc: CreateStreams, StreamInfo->tunneledMode = false, success. 888 * @tc.level: Level2 889 * @tc.size: MediumTest 890 * @tc.type: Function 891 */ 892TEST_F(UtestHdiIterTest, camera_hdi_0147) 893{ 894 std::cout << "==========[test log] CreateStreams,"; 895 std::cout << "StreamInfo->tunneledMode = false, success." << std::endl; 896 // Create and get streamOperator information 897 cameraBase->AchieveStreamOperator(); 898 // Create data stream 899 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 900 producer->SetQueueSize(8); // 8:set bufferQueue size 901 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 902 std::cout << "~~~~~~~" << std::endl; 903 } 904 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 905 cameraBase->BufferCallback(b, cameraBase->preview_mode); 906 return; 907 }; 908 producer->SetCallback(callback); 909 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 910 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 911 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 912 cameraBase->streamInfo->width_ = 640; // 640:picture width 913 cameraBase->streamInfo->height_ = 1080; // 1080:picture height 914 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 915 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 916 cameraBase->streamInfo->intent_ = Camera::CUSTOM; 917 cameraBase->streamInfo->tunneledMode_ = false; 918 cameraBase->streamInfo->bufferQueue_ = producer; 919 streamInfos.push_back(cameraBase->streamInfo); 920 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 921 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 922 EXPECT_EQ(true, cameraBase->rc == Camera::METHOD_NOT_SUPPORTED); 923 if (cameraBase->rc == Camera::METHOD_NOT_SUPPORTED) { 924 std::cout << "==========[test log] CreateStreams fail." << std::endl; 925 } else { 926 std::cout << "==========[test log] CreateStreams success"<< std::endl; 927 } 928} 929 930/** 931 * @tc.name: CreateStreams 932 * @tc.desc: CreateStreams, StreamInfo->minFrameDuration = -1, return error. 933 * @tc.level: Level2 934 * @tc.size: MediumTest 935 * @tc.type: Function 936 */ 937TEST_F(UtestHdiIterTest, camera_hdi_0148) 938{ 939 std::cout << "==========[test log] CreateStreams,"; 940 std::cout << "StreamInfo->minFrameDuration = -1, return error." << std::endl; 941 // Create and get streamOperator information 942 cameraBase->AchieveStreamOperator(); 943 // Create data stream 944 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 945 producer->SetQueueSize(8); // 8:set bufferQueue size 946 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 947 std::cout << "~~~~~~~" << std::endl; 948 } 949 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 950 cameraBase->BufferCallback(b, cameraBase->preview_mode); 951 return; 952 }; 953 producer->SetCallback(callback); 954 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 955 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 956 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 957 cameraBase->streamInfo->width_ = 640; // 640:picture width 958 cameraBase->streamInfo->height_ = 1080; // 1080:picture height 959 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 960 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 961 cameraBase->streamInfo->intent_ = Camera::CUSTOM; 962 cameraBase->streamInfo->tunneledMode_ = 0; 963 cameraBase->streamInfo->minFrameDuration_ = -1; 964 cameraBase->streamInfo->bufferQueue_ = producer; 965 streamInfos.push_back(cameraBase->streamInfo); 966 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 967 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 968 EXPECT_EQ(INVALID_ARGUMENT, cameraBase->rc); 969 if (cameraBase->rc == NO_ERROR) { 970 std::cout << "==========[test log] CreateStreams success." << std::endl; 971 } else { 972 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 973 } 974} 975 976/** 977 * @tc.name: CreateStreams 978 * @tc.desc: CreateStreams, StreamInfo->minFrameDuration = 2147483647, fail. 979 * @tc.level: Level2 980 * @tc.size: MediumTest 981 * @tc.type: Function 982 */ 983TEST_F(UtestHdiIterTest, camera_hdi_0149) 984{ 985 std::cout << "==========[test log] CreateStreams,"; 986 std::cout << "StreamInfo->minFrameDuration = 2147483647, success." << std::endl; 987 // Create and get streamOperator information 988 cameraBase->AchieveStreamOperator(); 989 // Create data stream 990 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 991 producer->SetQueueSize(8); // 8:set bufferQueue size 992 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 993 std::cout << "~~~~~~~" << std::endl; 994 } 995 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 996 cameraBase->BufferCallback(b, cameraBase->preview_mode); 997 return; 998 }; 999 producer->SetCallback(callback); 1000 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 1001 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 1002 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 1003 cameraBase->streamInfo->width_ = 640; // 640:picture width 1004 cameraBase->streamInfo->height_ = 480; // 480:picture height 1005 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 1006 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 1007 cameraBase->streamInfo->intent_ = PREVIEW; 1008 cameraBase->streamInfo->tunneledMode_ = 0; 1009 cameraBase->streamInfo->minFrameDuration_ = INVALID_VALUE_TEST; 1010 cameraBase->streamInfo->bufferQueue_ = producer; 1011 streamInfos.push_back(cameraBase->streamInfo); 1012 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 1013 std::cout << "streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl; 1014 EXPECT_EQ(true, cameraBase->rc == Camera::METHOD_NOT_SUPPORTED); 1015 if (cameraBase->rc == Camera::METHOD_NOT_SUPPORTED) { 1016 std::cout << "==========[test log] CreateStreams fail." << std::endl; 1017 } else { 1018 std::cout << "==========[test log] CreateStreams success, rc = " << cameraBase->rc << std::endl; 1019 } 1020} 1021 1022/** 1023 * @tc.name: ReleaseStreams 1024 * @tc.desc: ReleaseStreams,streamID normal. 1025 * @tc.level: Level1 1026 * @tc.size: MediumTest 1027 * @tc.type: Function 1028 */ 1029TEST_F(UtestHdiIterTest, camera_hdi_0160) 1030{ 1031 std::cout << "==========[test log] ReleaseStreams,streamID normal." << std::endl; 1032 // Create and get streamOperator information 1033 cameraBase->AchieveStreamOperator(); 1034 // Create data stream 1035 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 1036 producer->SetQueueSize(8); // 8:set bufferQueue size 1037 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 1038 std::cout << "~~~~~~~" << std::endl; 1039 } 1040 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 1041 cameraBase->BufferCallback(b, cameraBase->preview_mode); 1042 return; 1043 }; 1044 producer->SetCallback(callback); 1045 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 1046 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 1047 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 1048 cameraBase->streamInfo->width_ = 640; // 640:picture width 1049 cameraBase->streamInfo->height_ = 480; // 480:picture height 1050 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 1051 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 1052 cameraBase->streamInfo->intent_ = PREVIEW; 1053 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 1054 cameraBase->streamInfo->bufferQueue_ = producer; 1055 streamInfos.push_back(cameraBase->streamInfo); 1056 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 1057 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1058 if (cameraBase->rc == NO_ERROR) { 1059 std::cout << "==========[test log] CreateStreams success." << std::endl; 1060 } else { 1061 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 1062 } 1063 // release stream 1064 std::vector<int> streamIds; 1065 streamIds.push_back(cameraBase->streamInfo->streamId_); 1066 cameraBase->rc = cameraBase->streamOperator->ReleaseStreams(streamIds); 1067 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1068 if (cameraBase->rc == NO_ERROR) { 1069 std::cout << "==========[test log] ReleaseStreams success." << std::endl; 1070 } else { 1071 std::cout << "==========[test log] ReleaseStreams fail, rc = " << cameraBase->rc << std::endl; 1072 } 1073} 1074 1075/** 1076 * @tc.name: ReleaseStreams 1077 * @tc.desc: ReleaseStreams-> streamID = -1, expected success. 1078 * @tc.level: Level2 1079 * @tc.size: MediumTest 1080 * @tc.type: Function 1081 */ 1082TEST_F(UtestHdiIterTest, camera_hdi_0161) 1083{ 1084 std::cout << "==========[test log] ReleaseStreams-> streamID = -1, expected success." << std::endl; 1085 // Create and get streamOperator information 1086 cameraBase->AchieveStreamOperator(); 1087 // Create data stream 1088 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 1089 producer->SetQueueSize(8); // 8:set bufferQueue size 1090 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 1091 std::cout << "~~~~~~~" << std::endl; 1092 } 1093 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 1094 cameraBase->BufferCallback(b, cameraBase->preview_mode); 1095 return; 1096 }; 1097 producer->SetCallback(callback); 1098 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 1099 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 1100 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 1101 cameraBase->streamInfo->width_ = 640; // 640:picture width 1102 cameraBase->streamInfo->height_ = 480; // 480:picture height 1103 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 1104 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 1105 cameraBase->streamInfo->intent_ = PREVIEW; 1106 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 1107 cameraBase->streamInfo->bufferQueue_ = producer; 1108 streamInfos.push_back(cameraBase->streamInfo); 1109 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 1110 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1111 if (cameraBase->rc == NO_ERROR) { 1112 std::cout << "==========[test log] CreateStreams success." << std::endl; 1113 } else { 1114 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 1115 } 1116 // Distribution stream 1117 cameraBase->rc = cameraBase->streamOperator->CommitStreams(Camera::NORMAL, nullptr); 1118 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1119 // Get preview 1120 int captureId = 2001; 1121 std::shared_ptr<CaptureInfo> captureInfo = std::make_shared<CaptureInfo>(); 1122 captureInfo->streamIds_ = {DEFAULT_STREAM_ID}; 1123 captureInfo->enableShutterCallback_ = false; 1124 cameraBase->rc = cameraBase->streamOperator->Capture(captureId, captureInfo, true); 1125 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1126 sleep(3); // waiting 3s, prepare for execute function CancelCapture 1127 cameraBase->streamOperator->CancelCapture(captureId); 1128 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1129 1130 // release stream 1131 cameraBase->rc = cameraBase->streamOperator->ReleaseStreams({-1}); 1132 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1133 std::cout << "streamOperator->ReleaseStreams's RetCode = " << cameraBase->rc << std::endl; 1134 if (cameraBase->rc == NO_ERROR) { 1135 std::cout << "==========[test log] ReleaseStreams success." << std::endl; 1136 } else { 1137 std::cout << "==========[test log] ReleaseStreams fail, rc = " << cameraBase->rc << std::endl; 1138 } 1139} 1140 1141/** 1142 * @tc.name: CommitStreams 1143 * @tc.desc: CommitStreams, input normal. 1144 * @tc.level: Level1 1145 * @tc.size: MediumTest 1146 * @tc.type: Function 1147 */ 1148TEST_F(UtestHdiIterTest, camera_hdi_0170) 1149{ 1150 std::cout << "==========[test log] CommitStreams, input normal." << std::endl; 1151 // Create and get streamOperator information 1152 cameraBase->AchieveStreamOperator(); 1153 // Create data stream 1154 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 1155 producer->SetQueueSize(8); // 8:set bufferQueue size 1156 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 1157 std::cout << "~~~~~~~" << std::endl; 1158 } 1159 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 1160 cameraBase->BufferCallback(b, cameraBase->preview_mode); 1161 return; 1162 }; 1163 producer->SetCallback(callback); 1164 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 1165 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 1166 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 1167 cameraBase->streamInfo->width_ = 640; // 640:picture width 1168 cameraBase->streamInfo->height_ = 480; // 480:picture height 1169 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 1170 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 1171 cameraBase->streamInfo->intent_ = PREVIEW; 1172 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 1173 cameraBase->streamInfo->bufferQueue_ = producer; 1174 streamInfos.push_back(cameraBase->streamInfo); 1175 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 1176 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1177 if (cameraBase->rc == NO_ERROR) { 1178 std::cout << "==========[test log] CreateStreams success." << std::endl; 1179 } else { 1180 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 1181 } 1182 1183 std::shared_ptr<CameraMetadata> modeSetting = 1184 std::make_shared<CameraMetadata>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE); 1185 // Distribution stream 1186 cameraBase->rc = cameraBase->streamOperator->CommitStreams(Camera::NORMAL, modeSetting); 1187 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1188 if (cameraBase->rc == NO_ERROR) { 1189 std::cout << "==========[test log] CommitStreams success." << std::endl; 1190 } else { 1191 std::cout << "==========[test log] CommitStreams fail, rc = " << cameraBase->rc << std::endl; 1192 } 1193} 1194 1195/** 1196 * @tc.name: CommitStreams 1197 * @tc.desc: CommitStreams, modeSetting is nullptr. 1198 * @tc.level: Level1 1199 * @tc.size: MediumTest 1200 * @tc.type: Function 1201 */ 1202TEST_F(UtestHdiIterTest, camera_hdi_0171) 1203{ 1204 std::cout << "==========[test log] CommitStreams, input normal." << std::endl; 1205 // Create and get streamOperator information 1206 cameraBase->AchieveStreamOperator(); 1207 // Create data stream 1208 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 1209 producer->SetQueueSize(8); // 8:set bufferQueue size 1210 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 1211 std::cout << "~~~~~~~" << std::endl; 1212 } 1213 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 1214 cameraBase->BufferCallback(b, cameraBase->preview_mode); 1215 return; 1216 }; 1217 producer->SetCallback(callback); 1218 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 1219 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 1220 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 1221 cameraBase->streamInfo->width_ = 640; // 640:picture width 1222 cameraBase->streamInfo->height_ = 480; // 480:picture height 1223 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 1224 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 1225 cameraBase->streamInfo->intent_ = PREVIEW; 1226 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 1227 cameraBase->streamInfo->bufferQueue_ = producer; 1228 streamInfos.push_back(cameraBase->streamInfo); 1229 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 1230 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1231 if (cameraBase->rc == NO_ERROR) { 1232 std::cout << "==========[test log] CreateStreams success." << std::endl; 1233 } else { 1234 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 1235 } 1236 std::shared_ptr<CameraMetadata> modeSetting = nullptr; 1237 1238 // Distribution stream 1239 cameraBase->rc = cameraBase->streamOperator->CommitStreams(Camera::NORMAL, modeSetting); 1240 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1241 if (cameraBase->rc == NO_ERROR) { 1242 std::cout << "==========[test log] CommitStreams success." << std::endl; 1243 } else { 1244 std::cout << "==========[test log] CommitStreams fail, rc = " << cameraBase->rc << std::endl; 1245 } 1246 // Get preview 1247 int captureId = 2001; 1248 std::shared_ptr<CaptureInfo> captureInfo = std::make_shared<CaptureInfo>(); 1249 captureInfo->streamIds_ = {DEFAULT_STREAM_ID}; 1250 captureInfo->enableShutterCallback_ = false; 1251 cameraBase->rc = cameraBase->streamOperator->Capture(captureId, captureInfo, true); 1252 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1253 if (cameraBase->rc == NO_ERROR) { 1254 std::cout << "==========[test log] Capture success." << std::endl; 1255 } else { 1256 std::cout << "==========[test log] Capture fail, rc = " << cameraBase->rc << std::endl; 1257 } 1258 sleep(3); // waiting 3s, prepare for execute function CancelCapture 1259 cameraBase->streamOperator->CancelCapture(captureId); 1260 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1261 if (cameraBase->rc == NO_ERROR) { 1262 std::cout << "==========[test log] CancelCapture success." << std::endl; 1263 } else { 1264 std::cout << "==========[test log] CancelCapture fail, rc = " << cameraBase->rc << std::endl; 1265 } 1266 // release stream 1267 cameraBase->rc = cameraBase->streamOperator->ReleaseStreams(captureInfo->streamIds_); 1268 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1269 if (cameraBase->rc == NO_ERROR) { 1270 std::cout << "==========[test log] ReleaseStreams success." << std::endl; 1271 } else { 1272 std::cout << "==========[test log] ReleaseStreams fail, rc = " << cameraBase->rc << std::endl; 1273 } 1274 // Turn off the device 1275 cameraBase->cameraDevice->Close(); 1276 std::cout << "==========[test log] cameraDevice->Close" << std::endl; 1277} 1278 1279/** 1280 * @tc.name: GetStreamAttributes 1281 * @tc.desc: GetStreamAttributes, success. 1282 * @tc.level: Level1 1283 * @tc.size: MediumTest 1284 * @tc.type: Function 1285 */ 1286TEST_F(UtestHdiIterTest, camera_hdi_0180) 1287{ 1288 std::cout << "==========[test log] GetStreamAttributes, success." << std::endl; 1289 // Create and get streamOperator information 1290 cameraBase->AchieveStreamOperator(); 1291 // Create data stream 1292 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue(); 1293 producer->SetQueueSize(8); // 8:set bufferQueue size 1294 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size 1295 std::cout << "~~~~~~~" << std::endl; 1296 } 1297 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) { 1298 cameraBase->BufferCallback(b, cameraBase->preview_mode); 1299 return; 1300 }; 1301 producer->SetCallback(callback); 1302 std::vector<std::shared_ptr<StreamInfo>> streamInfos; 1303 cameraBase->streamInfo = std::make_shared<StreamInfo>(); 1304 cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID; 1305 cameraBase->streamInfo->width_ = 640; // 640:picture width 1306 cameraBase->streamInfo->height_ = 480; // 480:picture height 1307 cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG; 1308 cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace 1309 cameraBase->streamInfo->intent_ = PREVIEW; 1310 cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode 1311 cameraBase->streamInfo->bufferQueue_ = producer; 1312 streamInfos.push_back(cameraBase->streamInfo); 1313 cameraBase->rc = cameraBase->streamOperator->CreateStreams(streamInfos); 1314 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1315 if (cameraBase->rc == NO_ERROR) { 1316 std::cout << "==========[test log] CreateStreams success." << std::endl; 1317 } else { 1318 std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl; 1319 } 1320 std::shared_ptr<CameraMetadata> modeSetting = nullptr; 1321 1322 // Distribution stream 1323 cameraBase->rc = cameraBase->streamOperator->CommitStreams(Camera::NORMAL, modeSetting); 1324 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1325 if (cameraBase->rc == NO_ERROR) { 1326 std::cout << "==========[test log] CommitStreams success." << std::endl; 1327 } else { 1328 std::cout << "==========[test log] CommitStreams fail, rc = " << cameraBase->rc << std::endl; 1329 } 1330 1331 std::vector<std::shared_ptr<OHOS::Camera::StreamAttribute>> attributes; 1332 cameraBase->rc = cameraBase->streamOperator->GetStreamAttributes(attributes); 1333 EXPECT_EQ(true, cameraBase->rc == NO_ERROR); 1334 std::cout << "==========[test log] GetStreamAttributes, rc = " << cameraBase->rc << std::endl; 1335 if (cameraBase->rc == NO_ERROR) { 1336 std::cout << "==========[test log] GetStreamAttributes success." << std::endl; 1337 } else { 1338 std::cout << "==========[test log] GetStreamAttributes fail, rc = " << cameraBase->rc << std::endl; 1339 } 1340}