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 expected 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 "preview_test.h"
16
SetUpTestCase(void)17 void UtestPreviewTest::SetUpTestCase(void){
18 }
TearDownTestCase(void)19 void UtestPreviewTest::TearDownTestCase(void){}
SetUp(void)20 void UtestPreviewTest::SetUp(void)
21 {
22 if (display_ == nullptr)
23 display_ = std::make_shared<TestDisplay>();
24 display_->FBInit();
25 display_->Init();
26 }
TearDown(void)27 void UtestPreviewTest::TearDown(void)
28 {
29 display_->Close();
30 }
31
32 /**
33 * @tc.name: Preview
34 * @tc.desc: Preview stream, expected success.
35 * @tc.level: Level0
36 * @tc.size: MediumTest
37 * @tc.type: Function
38 */
TEST_F(UtestPreviewTest,camera_preview_0001)39 TEST_F(UtestPreviewTest, camera_preview_0001)
40 {
41 std::cout << "==========[test log] Preview stream, expected success." << std::endl;
42 // 获取流管理器
43 display_->AchieveStreamOperator();
44 // 启流
45 display_->intents = {Camera::PREVIEW};
46 display_->StartStream(display_->intents);
47 // 获取预览图
48 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
49 // 释放流
50 display_->captureIds = {display_->captureId_preview};
51 display_->streamIds = {display_->streamId_preview};
52 display_->StopStream(display_->captureIds, display_->streamIds);
53 }
54
55 /**
56 * @tc.name: Preview
57 * @tc.desc: Preview, format error, expected return errorCode.
58 * @tc.level: Level2
59 * @tc.size: MediumTest
60 * @tc.type: Function
61 */
TEST_F(UtestPreviewTest,camera_preview_0003)62 TEST_F(UtestPreviewTest, camera_preview_0003)
63 {
64 std::cout << "==========[test log] Preview, format error, expected return errorCode." << std::endl;
65 // 创建并获取streamOperator信息
66 display_->AchieveStreamOperator();
67 // 创建数据流
68 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
69 producer->SetQueueSize(8); // 8:set bufferQueue size
70 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
71 std::cout << "~~~~~~~" << std::endl;
72 }
73 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
74 display_->BufferCallback(b, display_->preview_mode);
75 return;
76 };
77 producer->SetCallback(callback);
78 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
79 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
80 streamInfo->streamId_ = 1001;
81 streamInfo->width_ = 640; // 640:picture width
82 streamInfo->height_ = 480; // 480:picture height
83 streamInfo->format_ = -1;
84 streamInfo->datasapce_ = 10; // 10:picture datasapce
85 streamInfo->intent_ = Camera::PREVIEW;
86 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
87 streamInfo->bufferQueue_ = producer;
88 streamInfos.push_back(streamInfo);
89 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
90 EXPECT_EQ(true, display_->rc != Camera::NO_ERROR);
91 if (display_->rc == Camera::NO_ERROR) {
92 std::cout << "==========[test log] CreateStreams success." << std::endl;
93 } else {
94 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
95 }
96 }
97
98 /**
99 * @tc.name: Preview
100 * @tc.desc: GetStreamOperator success.
101 * @tc.level: Level1
102 * @tc.size: MediumTest
103 * @tc.type: Function
104 */
TEST_F(UtestPreviewTest,camera_preview_0010)105 TEST_F(UtestPreviewTest, camera_preview_0010)
106 {
107 std::cout << "==========[test log] GetStreamOperator success." << std::endl;
108 // 获取配置的cameraId
109 display_->cameraHost->GetCameraIds(display_->cameraIds);
110 std::cout << "cameraIds.front() = " << display_->cameraIds.front() << std::endl;
111 // 打开camera设备并获取到device
112 const std::shared_ptr<OHOS::Camera::ICameraDeviceCallback> callback =
113 std::make_shared<OHOS::Camera::ICameraDeviceCallback>();
114 display_->rc = display_->cameraHost->OpenCamera(display_->cameraIds.front(), callback, display_->cameraDevice);
115 std::cout << "OpenCamera's RetCode = " << display_->rc << std::endl;
116 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
117 display_->AchieveStreamOperator();
118 }
119
120 /**
121 * @tc.name: Preview
122 * @tc.desc: GetStreamOperator, input nullptr.
123 * @tc.level: Level2
124 * @tc.size: MediumTest
125 * @tc.type: Function
126 */
TEST_F(UtestPreviewTest,camera_preview_0011)127 TEST_F(UtestPreviewTest, camera_preview_0011)
128 {
129 std::cout << "==========[test log] GetStreamOperator, input nullptr." << std::endl;
130 // 获取配置的cameraId
131 display_->cameraHost->GetCameraIds(display_->cameraIds);
132 std::cout << "cameraIds.front() = " << display_->cameraIds.front() << std::endl;
133 // 打开camera设备并获取到device
134 const std::shared_ptr<OHOS::Camera::ICameraDeviceCallback> callback =
135 std::make_shared<OHOS::Camera::ICameraDeviceCallback>();
136 display_->rc = display_->cameraHost->OpenCamera(display_->cameraIds.front(), callback, display_->cameraDevice);
137 std::cout << "OpenCamera's RetCode = " << display_->rc << std::endl;
138 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
139 // 创建并获取streamOperator信息
140 std::shared_ptr<OHOS::Camera::IStreamOperatorCallback> streamOperatorCallback = nullptr;
141 display_->rc = display_->cameraDevice->GetStreamOperator(streamOperatorCallback, display_->streamOperator);
142 std::cout << "GetStreamOperator's RetCode = " << display_->rc << std::endl;
143 EXPECT_EQ(Camera::CamRetCode::INVALID_ARGUMENT, display_->rc);
144 }
145
146 /**
147 * @tc.name: Preview
148 * @tc.desc: CreateStreams, success.
149 * @tc.level: Level1
150 * @tc.size: MediumTest
151 * @tc.type: Function
152 */
TEST_F(UtestPreviewTest,camera_preview_0020)153 TEST_F(UtestPreviewTest, camera_preview_0020)
154 {
155 std::cout << "==========[test log] CreateStreams, success." << std::endl;
156 // 创建并获取streamOperator信息
157 display_->AchieveStreamOperator();
158 // 创建数据流
159 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
160 producer->SetQueueSize(8); // 8:set bufferQueue size
161 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
162 std::cout << "~~~~~~~" << std::endl;
163 }
164 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
165 display_->BufferCallback(b, display_->preview_mode);
166 return;
167 };
168 producer->SetCallback(callback);
169 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
170 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
171 streamInfo->streamId_ = 1001;
172 streamInfo->width_ = 640; // 640:picture width
173 streamInfo->height_ = 480; // 480:picture height
174 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
175 streamInfo->datasapce_ = 8; // 8:picture datasapce
176 streamInfo->intent_ = Camera::PREVIEW;
177 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
178 streamInfo->bufferQueue_ = producer;
179 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
180 streamInfos.push_back(streamInfo);
181 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
182 std::cout << "CreateStreams's RetCode = " << display_->rc << std::endl;
183 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
184 std::cout << "==========[test log] CreateStreams, success." << std::endl;
185 // 提交流信息
186 display_->rc = display_->streamOperator->CommitStreams(NORMAL, nullptr);
187 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
188 if (display_->rc == Camera::NO_ERROR) {
189 std::cout << "==========[test log] CommitStreams success." << std::endl;
190 } else {
191 std::cout << "==========[test log] CommitStreams fail, rc = " << display_->rc << std::endl;
192 }
193 // 捕获
194 display_->StartCapture(1001, display_->captureId_preview, false, true);
195 // 释放流
196 display_->captureIds = {display_->captureId_preview};
197 display_->streamIds = {1001};
198 display_->StopStream(display_->captureIds, display_->streamIds);
199 }
200
201 /**
202 * @tc.name: Preview
203 * @tc.desc: CreateStreams, StreamInfo->streamId = -1, return error.
204 * @tc.level: Level2
205 * @tc.size: MediumTest
206 * @tc.type: Function
207 */
TEST_F(UtestPreviewTest,camera_preview_0021)208 TEST_F(UtestPreviewTest, camera_preview_0021)
209 {
210 std::cout << "==========[test log] CreateStreams, success." << std::endl;
211 // 创建并获取streamOperator信息
212 display_->AchieveStreamOperator();
213 // 创建数据流
214 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
215 producer->SetQueueSize(8); // 8:set bufferQueue size
216 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
217 std::cout << "~~~~~~~" << std::endl;
218 }
219 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
220 display_->BufferCallback(b, display_->preview_mode);
221 return;
222 };
223 producer->SetCallback(callback);
224 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
225 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
226 streamInfo->streamId_ = -1;
227 streamInfo->width_ = 640; // 640:picture width
228 streamInfo->height_ = 480; // 480:picture height
229 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
230 streamInfo->datasapce_ = 8; // 8:picture datasapce
231 streamInfo->intent_ = Camera::PREVIEW;
232 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
233 streamInfo->bufferQueue_ = producer;
234 streamInfos.push_back(streamInfo);
235 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
236 std::cout << "CreateStreams's RetCode = " << display_->rc << std::endl;
237 EXPECT_EQ(false, display_->rc == Camera::NO_ERROR);
238 if (display_->rc == Camera::NO_ERROR) {
239 std::cout << "==========[test log] CreateStreams success." << std::endl;
240 } else {
241 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
242 }
243 }
244
245 /**
246 * @tc.name: Preview
247 * @tc.desc: CreateStreams, StreamInfo->streamId = 2147483647, return success.
248 * @tc.level: Level2
249 * @tc.size: MediumTest
250 * @tc.type: Function
251 */
TEST_F(UtestPreviewTest,camera_preview_0022)252 TEST_F(UtestPreviewTest, camera_preview_0022)
253 {
254 std::cout << "==========[test log] CreateStreams, StreamInfo->streamId = 2147483647,";
255 std::cout << "return success." << std::endl;
256 display_->AchieveStreamOperator();
257 // 创建数据流
258 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
259 producer->SetQueueSize(8); // 8:set bufferQueue size
260 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
261 std::cout << "~~~~~~~" << std::endl;
262 }
263 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
264 display_->BufferCallback(b, display_->preview_mode);
265 return;
266 };
267 producer->SetCallback(callback);
268 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
269 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
270 streamInfo->streamId_ = 2147483647;
271 streamInfo->width_ = 640; // 640:picture width
272 streamInfo->height_ = 480; // 480:picture height
273 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
274 streamInfo->datasapce_ = 8; // 8:picture datasapce
275 streamInfo->intent_ = Camera::PREVIEW;
276 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
277 streamInfo->bufferQueue_ = producer;
278 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
279 streamInfos.push_back(streamInfo);
280 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
281 std::cout << "streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
282 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
283 if (display_->rc == Camera::NO_ERROR) {
284 std::cout << "==========[test log] CreateStreams success." << std::endl;
285 } else {
286 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
287 }
288 // 提交流信息
289 display_->rc = display_->streamOperator->CommitStreams(NORMAL, nullptr);
290 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
291 std::cout << "==========[test log] CommitStreams success." << std::endl;
292 // 捕获
293 display_->StartCapture(2147483647, display_->captureId_preview, false, true);
294 // 释放流
295 display_->captureIds = {display_->captureId_preview};
296 display_->streamIds = {2147483647};
297 display_->StopStream(display_->captureIds, display_->streamIds);
298 }
299
300 /**
301 * @tc.name: Preview
302 * @tc.desc: CreateStreams, StreamInfo->width = -1, return error.
303 * @tc.level: Level2
304 * @tc.size: MediumTest
305 * @tc.type: Function
306 */
TEST_F(UtestPreviewTest,camera_preview_0023)307 TEST_F(UtestPreviewTest, camera_preview_0023)
308 {
309 std::cout << "==========[test log] CreateStreams, StreamInfo->width = -1, return error." << std::endl;
310 // 创建并获取streamOperator信息
311 display_->AchieveStreamOperator();
312 // 创建数据流
313 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
314 producer->SetQueueSize(8); // 8:set bufferQueue size
315 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
316 std::cout << "~~~~~~~" << std::endl;
317 }
318 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
319 display_->BufferCallback(b, display_->preview_mode);
320 return;
321 };
322 producer->SetCallback(callback);
323 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
324 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
325 streamInfo->streamId_ = 1001;
326 streamInfo->width_ = -1;
327 streamInfo->height_ = 480; // 480:picture height
328 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
329 streamInfo->datasapce_ = 8; // 8:picture datasapce
330 streamInfo->intent_ = Camera::PREVIEW;
331 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
332 streamInfo->bufferQueue_ = producer;
333 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
334 streamInfos.push_back(streamInfo);
335 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
336 std::cout << "streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
337 EXPECT_EQ(true, display_->rc == Camera::INVALID_ARGUMENT);
338 if (display_->rc == Camera::NO_ERROR) {
339 std::cout << "==========[test log] CreateStreams success." << std::endl;
340 } else {
341 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
342 }
343 }
344
345 /**
346 * @tc.name: Preview
347 * @tc.desc: CreateStreams, StreamInfo->width = 2147483647, success.
348 * @tc.level: Level2
349 * @tc.size: MediumTest
350 * @tc.type: Function
351 */
TEST_F(UtestPreviewTest,camera_preview_0024)352 TEST_F(UtestPreviewTest, camera_preview_0024)
353 {
354 std::cout << "==========[test log] CreateStreams, StreamInfo->width = 2147483647, success." << std::endl;
355 // 创建并获取streamOperator信息
356 display_->AchieveStreamOperator();
357 // 创建数据流
358 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
359 producer->SetQueueSize(8); // 8:set bufferQueue size
360 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
361 std::cout << "~~~~~~~" << std::endl;
362 }
363 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
364 display_->BufferCallback(b, display_->preview_mode);
365 return;
366 };
367 producer->SetCallback(callback);
368 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
369 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
370 streamInfo->streamId_ = 1001;
371 streamInfo->width_ = 2147483647;
372 streamInfo->height_ = 480; // 480:picture height
373 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
374 streamInfo->datasapce_ = 8; // 8:picture datasapce
375 streamInfo->intent_ = Camera::PREVIEW;
376 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
377 streamInfo->bufferQueue_ = producer;
378 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
379 streamInfos.push_back(streamInfo);
380 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
381 std::cout << "streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
382 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
383 // 提交流信息
384 display_->rc = display_->streamOperator->CommitStreams(NORMAL, nullptr);
385 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
386 // 捕获
387 int captureId = 2001;
388 display_->captureInfo = std::make_shared<OHOS::Camera::CaptureInfo>();
389 display_->captureInfo->streamIds_ = {1001};
390 display_->captureInfo->enableShutterCallback_ = false;
391 display_->rc = display_->streamOperator->Capture(captureId, display_->captureInfo, true);
392 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
393 sleep(3);
394 // 释放流
395 std::vector<int> streamIds;
396 streamIds.push_back(streamInfo->streamId_);
397 display_->rc = display_->streamOperator->ReleaseStreams(streamIds);
398 std::cout << "streamOperator->ReleaseStreams's RetCode = " << display_->rc << std::endl;
399 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
400 std::cout << "==========[test log] ReleaseStreams, success." << std::endl;
401 }
402
403 /**
404 * @tc.name: Preview
405 * @tc.desc: CreateStreams, StreamInfo->height = -1, return error.
406 * @tc.level: Level2
407 * @tc.size: MediumTest
408 * @tc.type: Function
409 */
TEST_F(UtestPreviewTest,camera_preview_0025)410 TEST_F(UtestPreviewTest, camera_preview_0025)
411 {
412 std::cout << "==========[test log] CreateStreams, StreamInfo->height = -1, return error." << std::endl;
413 // 创建并获取streamOperator信息
414 display_->AchieveStreamOperator();
415 // 创建数据流
416 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
417 producer->SetQueueSize(8); // 8:set bufferQueue size
418 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
419 std::cout << "~~~~~~~" << std::endl;
420 }
421 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
422 display_->BufferCallback(b, display_->preview_mode);
423 return;
424 };
425 producer->SetCallback(callback);
426 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
427 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
428 streamInfo->streamId_ = 1001;
429 streamInfo->width_ = 640; // 640:picture width
430 streamInfo->height_ = -1;
431 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
432 streamInfo->datasapce_ = 8; // 8:picture datasapce
433 streamInfo->intent_ = Camera::PREVIEW;
434 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
435 streamInfo->bufferQueue_ = producer;
436 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
437 streamInfos.push_back(streamInfo);
438 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
439 std::cout << "streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
440 EXPECT_EQ(Camera::CamRetCode::INVALID_ARGUMENT, display_->rc);
441 if (display_->rc == Camera::NO_ERROR) {
442 std::cout << "==========[test log] CreateStreams success." << std::endl;
443 } else {
444 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
445 }
446 }
447
448 /**
449 * @tc.name: Preview
450 * @tc.desc: CreateStreams, StreamInfo->height = 2147483647, success.
451 * @tc.level: Level2
452 * @tc.size: MediumTest
453 * @tc.type: Function
454 */
TEST_F(UtestPreviewTest,camera_preview_0026)455 TEST_F(UtestPreviewTest, camera_preview_0026)
456 {
457 std::cout << "==========[test log] CreateStreams, StreamInfo->height = 2147483647, success." << std::endl;
458 // 创建并获取streamOperator信息
459 display_->AchieveStreamOperator();
460 // 创建数据流
461 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
462 producer->SetQueueSize(8); // 8:set bufferQueue size
463 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
464 std::cout << "~~~~~~~" << std::endl;
465 }
466 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
467 display_->BufferCallback(b, display_->preview_mode);
468 return;
469 };
470 producer->SetCallback(callback);
471 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
472 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
473 streamInfo->streamId_ = 1001;
474 streamInfo->width_ = 640; // 640:picture width
475 streamInfo->height_ = 2147483647;
476 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
477 streamInfo->datasapce_ = 8; // 8:picture datasapce
478 streamInfo->intent_ = Camera::PREVIEW;
479 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
480 streamInfo->bufferQueue_ = producer;
481 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
482 streamInfos.push_back(streamInfo);
483 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
484 std::cout << "streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
485 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
486 // 提交流信息
487 display_->rc = display_->streamOperator->CommitStreams(NORMAL, nullptr);
488 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
489 // 捕获
490 int captureId = 2001;
491 display_->captureInfo = std::make_shared<OHOS::Camera::CaptureInfo>();
492 display_->captureInfo->streamIds_ = {1001};
493 display_->captureInfo->enableShutterCallback_ = false;
494 display_->rc = display_->streamOperator->Capture(captureId, display_->captureInfo, true);
495 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
496 sleep(3);
497 // 释放流
498 std::vector<int> streamIds;
499 streamIds.push_back(streamInfo->streamId_);
500 display_->rc = display_->streamOperator->ReleaseStreams(streamIds);
501 std::cout << "ReleaseStreams's RetCode = " << display_->rc << std::endl;
502 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
503 std::cout << "==========[test log] ReleaseStreams, success." << std::endl;
504 }
505
506 /**
507 * @tc.name: Preview
508 * @tc.desc: CreateStreams, StreamInfo->format = -1, return error.
509 * @tc.level: Level2
510 * @tc.size: MediumTest
511 * @tc.type: Function
512 */
TEST_F(UtestPreviewTest,camera_preview_0027)513 TEST_F(UtestPreviewTest, camera_preview_0027)
514 {
515 std::cout << "==========[test log] CreateStreams, StreamInfo->format = -1, return error." << std::endl;
516 display_->AchieveStreamOperator();
517 // 创建数据流
518 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
519 producer->SetQueueSize(8); // 8:set bufferQueue size
520 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
521 std::cout << "~~~~~~~" << std::endl;
522 }
523 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
524 display_->BufferCallback(b, display_->preview_mode);
525 return;
526 };
527 producer->SetCallback(callback);
528 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
529 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
530 streamInfo->streamId_ = 1001;
531 streamInfo->width_ = 640; // 640:picture width
532 streamInfo->height_ = 480; // 480:picture height
533 streamInfo->format_ = -1;
534 streamInfo->datasapce_ = 8; // 8:picture datasapce
535 streamInfo->intent_ = Camera::PREVIEW;
536 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
537 streamInfo->bufferQueue_ = producer;
538 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
539 streamInfos.push_back(streamInfo);
540 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
541 std::cout << "streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
542 EXPECT_EQ(Camera::CamRetCode::INVALID_ARGUMENT, display_->rc);
543 if (display_->rc == Camera::NO_ERROR) {
544 std::cout << "==========[test log] CreateStreams success." << std::endl;
545 } else {
546 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
547 }
548 }
549
550 /**
551 * @tc.name: Preview
552 * @tc.desc: CreateStreams, StreamInfo->format = 2147483647, success.
553 * @tc.level: Level2
554 * @tc.size: MediumTest
555 * @tc.type: Function
556 */
TEST_F(UtestPreviewTest,camera_preview_0028)557 TEST_F(UtestPreviewTest, camera_preview_0028)
558 {
559 std::cout << "==========[test log] CreateStreams, StreamInfo->format = 2147483647, success." << std::endl;
560 // 创建并获取streamOperator信息
561 display_->AchieveStreamOperator();
562 // 创建数据流
563 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
564 producer->SetQueueSize(8); // 8:set bufferQueue size
565 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
566 std::cout << "~~~~~~~" << std::endl;
567 }
568 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
569 display_->BufferCallback(b, display_->preview_mode);
570 return;
571 };
572 producer->SetCallback(callback);
573 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
574 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
575 streamInfo->streamId_ = 1001;
576 streamInfo->width_ = 640; // 640:picture width
577 streamInfo->height_ = 480; // 480:picture height
578 streamInfo->format_ = 2147483647;
579 streamInfo->datasapce_ = 8; // 8:picture datasapce
580 streamInfo->intent_ = Camera::PREVIEW;
581 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
582 streamInfo->bufferQueue_ = producer;
583 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
584 streamInfos.push_back(streamInfo);
585 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
586 if (display_->rc == Camera::NO_ERROR) {
587 std::cout << "==========[test log] CreateStreams success." << std::endl;
588 } else {
589 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
590 }
591 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
592 std::cout << "==========[test log] CreateStreams, success." << std::endl;
593 // 提交流信息
594 display_->rc = display_->streamOperator->CommitStreams(NORMAL, nullptr);
595 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
596 if (display_->rc == Camera::NO_ERROR) {
597 std::cout << "==========[test log] CommitStreams success." << std::endl;
598 } else {
599 std::cout << "==========[test log] CommitStreams fail, rc = " << display_->rc << std::endl;
600 }
601 // 捕获
602 display_->StartCapture(1001, display_->captureId_preview, false, true);
603 // 释放流
604 display_->captureIds = {display_->captureId_preview};
605 display_->streamIds = {1001};
606 display_->StopStream(display_->captureIds, display_->streamIds);
607 }
608
609 /**
610 * @tc.name: Preview
611 * @tc.desc: CreateStreams, StreamInfo->datasapce = -1, return error.
612 * @tc.level: Level2
613 * @tc.size: MediumTest
614 * @tc.type: Function
615 */
TEST_F(UtestPreviewTest,camera_preview_0029)616 TEST_F(UtestPreviewTest, camera_preview_0029)
617 {
618 std::cout << "==========[test log] CreateStreams, StreamInfo->datasapce = -1, return error." << std::endl;
619 display_->AchieveStreamOperator();
620 // 创建数据流
621 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
622 producer->SetQueueSize(8); // 8:set bufferQueue size
623 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
624 std::cout << "~~~~~~~" << std::endl;
625 }
626 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
627 display_->BufferCallback(b, display_->preview_mode);
628 return;
629 };
630 producer->SetCallback(callback);
631 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
632 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
633 streamInfo->streamId_ = 1001;
634 streamInfo->width_ = 640; // 640:picture width
635 streamInfo->height_ = 480; // 480:picture height
636 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
637 streamInfo->datasapce_ = -1;
638 streamInfo->intent_ = Camera::PREVIEW;
639 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
640 streamInfo->bufferQueue_ = producer;
641 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
642 streamInfos.push_back(streamInfo);
643 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
644 std::cout << "streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
645 EXPECT_EQ(Camera::CamRetCode::INVALID_ARGUMENT, display_->rc);
646 if (display_->rc == Camera::NO_ERROR) {
647 std::cout << "==========[test log] CreateStreams success." << std::endl;
648 } else {
649 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
650 }
651 }
652
653 /**
654 * @tc.name: Preview
655 * @tc.desc: CreateStreams, StreamInfo->datasapce = 2147483647, success.
656 * @tc.level: Level2
657 * @tc.size: MediumTest
658 * @tc.type: Function
659 */
TEST_F(UtestPreviewTest,camera_preview_0030)660 TEST_F(UtestPreviewTest, camera_preview_0030)
661 {
662 std::cout << "==========[test log] CreateStreams, StreamInfo->datasapce = 2147483647, success." << std::endl;
663 // 创建并获取streamOperator信息
664 display_->AchieveStreamOperator();
665 // 创建数据流
666 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
667 producer->SetQueueSize(8); // 8:set bufferQueue size
668 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
669 std::cout << "~~~~~~~" << std::endl;
670 }
671 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
672 display_->BufferCallback(b, display_->preview_mode);
673 return;
674 };
675 producer->SetCallback(callback);
676 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
677 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
678 streamInfo->streamId_ = 1001;
679 streamInfo->width_ = 640; // 640:picture width
680 streamInfo->height_ = 480; // 480:picture height
681 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
682 streamInfo->datasapce_ = 2147483647;
683 streamInfo->intent_ = Camera::PREVIEW;
684 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
685 streamInfo->bufferQueue_ = producer;
686 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
687 streamInfos.push_back(streamInfo);
688 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
689 std::cout << "streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
690 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
691 if (display_->rc == Camera::NO_ERROR) {
692 std::cout << "==========[test log] CreateStreams success." << std::endl;
693 } else {
694 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
695 }
696 // 提交流信息
697 display_->rc = display_->streamOperator->CommitStreams(NORMAL, nullptr);
698 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
699 std::cout << "==========[test log] CommitStreams success." << std::endl;
700 // 捕获
701 display_->StartCapture(1001, display_->captureId_preview, false, true);
702 // 释放流
703 display_->captureIds = {display_->captureId_preview};
704 display_->streamIds = {1001};
705 display_->StopStream(display_->captureIds, display_->streamIds);
706 }
707
708 /**
709 * @tc.name: Preview
710 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = Camera::PREVIEW, success.
711 * @tc.level: Level2
712 * @tc.size: MediumTest
713 * @tc.type: Function
714 */
TEST_F(UtestPreviewTest,camera_preview_0031)715 TEST_F(UtestPreviewTest, camera_preview_0031)
716 {
717 std::cout << "==========[test log] CreateStreams, StreamInfo->StreamIntent = ";
718 std::cout << "Camera::PREVIEW, success." << std::endl;
719 // 获取流管理器
720 display_->AchieveStreamOperator();
721 // 启流
722 display_->intents = {Camera::PREVIEW};
723 display_->StartStream(display_->intents);
724 // 捕获
725 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
726 // 释放流
727 display_->captureIds = {display_->captureId_preview};
728 display_->streamIds = {display_->streamId_preview};
729 display_->StopStream(display_->captureIds, display_->streamIds);
730 }
731
732 /**
733 * @tc.name: Preview
734 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = Camera::VIDEO, success.
735 * @tc.level: Level2
736 * @tc.size: MediumTest
737 * @tc.type: Function
738 */
TEST_F(UtestPreviewTest,camera_preview_0032)739 TEST_F(UtestPreviewTest, camera_preview_0032)
740 {
741 std::cout << "==========[test log] CreateStreams, StreamInfo->StreamIntent = Camera::VIDEO, success." << std::endl;
742 // 获取流管理器
743 display_->AchieveStreamOperator();
744 // 启流
745 display_->intents = {Camera::PREVIEW, Camera::VIDEO};
746 display_->StartStream(display_->intents);
747 // 获取预览图
748 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
749 display_->StartCapture(display_->streamId_video, display_->captureId_preview, false, true);
750 // 释放流
751 display_->captureIds = {display_->captureId_preview};
752 display_->streamIds = {display_->streamId_preview, display_->streamId_capture};
753 display_->StopStream(display_->captureIds, display_->streamIds);
754 }
755
756 /**
757 * @tc.name: Preview
758 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = Camera::STILL_CAPTURE, success.
759 * @tc.level: Level2
760 * @tc.size: MediumTest
761 * @tc.type: Function
762 */
TEST_F(UtestPreviewTest,camera_preview_0033)763 TEST_F(UtestPreviewTest, camera_preview_0033)
764 {
765 std::cout << "==========[test log] CreateStreams, StreamInfo->StreamIntent = ";
766 std::cout << "Camera::STILL_CAPTURE, success." << std::endl;
767 // 创建并获取streamOperator信息
768 display_->AchieveStreamOperator();
769 // 启流
770 display_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE};
771 display_->StartStream(display_->intents);
772 // 获取预览图
773 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
774 display_->StartCapture(display_->streamId_capture, display_->captureId_preview, false, true);
775 // 释放流
776 display_->captureIds = {display_->captureId_preview};
777 display_->streamIds = {display_->streamId_preview, display_->streamId_capture};
778 display_->StopStream(display_->captureIds, display_->streamIds);
779 }
780
781 /**
782 * @tc.name: Preview
783 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = Camera::POST_VIEW;, success.
784 * @tc.level: Level2
785 * @tc.size: MediumTest
786 * @tc.type: Function
787 */
TEST_F(UtestPreviewTest,camera_preview_0034)788 TEST_F(UtestPreviewTest, camera_preview_0034)
789 {
790 std::cout << "==========[test log] CreateStreams, StreamInfo->StreamIntent = ";
791 std::cout << "Camera::POST_VIEW;, success." << std::endl;
792 // 创建并获取streamOperator信息
793 display_->AchieveStreamOperator();
794 // 创建预览流
795 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
796 producer->SetQueueSize(8); // 8:set bufferQueue size
797 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
798 std::cout << "~~~~~~~" << std::endl;
799 }
800 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
801 display_->BufferCallback(b, display_->preview_mode);
802 return;
803 };
804 producer->SetCallback(callback);
805 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
806 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
807 streamInfo->streamId_ = 1001;
808 streamInfo->width_ = 640; // 640:picture width
809 streamInfo->height_ = 480; // 480:picture height
810 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
811 streamInfo->datasapce_ = 8; // 8:picture datasapce
812 streamInfo->intent_ = Camera::POST_VIEW;
813 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
814 streamInfo->bufferQueue_ = producer;
815 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
816 streamInfos.push_back(streamInfo);
817 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
818 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
819 if (display_->rc == Camera::NO_ERROR) {
820 std::cout << "==========[test log] CreateStreams success." << std::endl;
821 } else {
822 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
823 }
824 // 释放流
825 std::vector<int> streamIds;
826 streamIds.push_back(streamInfo->streamId_);
827 display_->rc = display_->streamOperator->ReleaseStreams(streamIds);
828 std::cout << "ReleaseStreams's RetCode = " << display_->rc << std::endl;
829 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
830 if (display_->rc == Camera::NO_ERROR) {
831 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
832 } else {
833 std::cout << "==========[test log] ReleaseStreams fail, rc = " << display_->rc << std::endl;
834 }
835 }
836
837 /**
838 * @tc.name: Preview
839 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = Camera::ANALYZE;, success.
840 * @tc.level: Level2
841 * @tc.size: MediumTest
842 * @tc.type: Function
843 */
TEST_F(UtestPreviewTest,camera_preview_0035)844 TEST_F(UtestPreviewTest, camera_preview_0035)
845 {
846 std::cout << "==========[test log] CreateStreams, StreamInfo->StreamIntent = ";
847 std::cout << "Camera::ANALYZE;, success." << std::endl;
848 // 创建并获取streamOperator信息
849 display_->AchieveStreamOperator();
850 // 创建数据流
851 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
852 producer->SetQueueSize(8); // 8:set bufferQueue size
853 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
854 std::cout << "~~~~~~~" << std::endl;
855 }
856 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
857 display_->BufferCallback(b, display_->preview_mode);
858 return;
859 };
860 producer->SetCallback(callback);
861 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
862 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
863 streamInfo->streamId_ = 1001;
864 streamInfo->width_ = 640; // 640:picture width
865 streamInfo->height_ = 480; // 480:picture height
866 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
867 streamInfo->datasapce_ = 8; // 8:picture datasapce
868 streamInfo->intent_ = Camera::ANALYZE;
869 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
870 streamInfo->bufferQueue_ = producer;
871 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
872 streamInfos.push_back(streamInfo);
873 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
874 std::cout << "streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
875 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
876 std::cout << "==========[test log] CreateStreams success." << std::endl;
877 // 释放流
878 std::vector<int> streamIds;
879 streamIds.push_back(streamInfo->streamId_);
880 display_->rc = display_->streamOperator->ReleaseStreams(streamIds);
881 std::cout << "ReleaseStreams RetCode = " << display_->rc << std::endl;
882 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
883 if (display_->rc == Camera::NO_ERROR) {
884 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
885 }
886 else {
887 std::cout << "==========[test log] ReleaseStreams fail, rc = " << display_->rc << std::endl;
888 }
889 }
890
891 /**
892 * @tc.name: Preview
893 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = Camera::CUSTOM, not support.
894 * @tc.level: Level2
895 * @tc.size: MediumTest
896 * @tc.type: Function
897 */
TEST_F(UtestPreviewTest,camera_preview_0036)898 TEST_F(UtestPreviewTest, camera_preview_0036)
899 {
900 std::cout << "==========[test log] CreateStreams, StreamInfo->StreamIntent = ";
901 std::cout << "Camera::CUSTOM, not support." << std::endl;
902 // 创建并获取streamOperator信息
903 display_->AchieveStreamOperator();
904 // 创建数据流
905 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
906 producer->SetQueueSize(8); // 8:set bufferQueue size
907 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
908 std::cout << "~~~~~~~" << std::endl;
909 }
910 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
911 display_->BufferCallback(b, display_->preview_mode);
912 return;
913 };
914 producer->SetCallback(callback);
915 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
916 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
917 streamInfo->streamId_ = 1001;
918 streamInfo->width_ = 640; // 640:picture width
919 streamInfo->height_ = 480; // 480:picture height
920 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
921 streamInfo->datasapce_ = 8; // 8:picture datasapce
922 streamInfo->intent_ = Camera::CUSTOM;
923 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
924 streamInfo->bufferQueue_ = producer;
925 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
926 streamInfos.push_back(streamInfo);
927 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
928 std::cout << "streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
929 EXPECT_EQ(true, display_->rc != Camera::NO_ERROR);
930 if (display_->rc == Camera::NO_ERROR) {
931 std::cout << "==========[test log] CreateStreams success." << std::endl;
932 } else {
933 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
934 }
935 }
936
937 /**
938 * @tc.name: Preview
939 * @tc.desc: CreateStreams, StreamInfo->tunneledMode = false, success.
940 * @tc.level: Level2
941 * @tc.size: MediumTest
942 * @tc.type: Function
943 */
TEST_F(UtestPreviewTest,camera_preview_0037)944 TEST_F(UtestPreviewTest, camera_preview_0037)
945 {
946 std::cout << "==========[test log] CreateStreams, StreamInfo->tunneledMode = false, success." << std::endl;
947 // 创建并获取streamOperator信息
948 display_->AchieveStreamOperator();
949 // 创建数据流
950 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
951 producer->SetQueueSize(8); // 8:set bufferQueue size
952 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
953 std::cout << "~~~~~~~" << std::endl;
954 }
955 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
956 display_->BufferCallback(b, display_->preview_mode);
957 return;
958 };
959 producer->SetCallback(callback);
960 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
961 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
962 streamInfo->streamId_ = 1001;
963 streamInfo->width_ = 640; // 640:picture width
964 streamInfo->height_ = 480; // 480:picture height
965 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
966 streamInfo->datasapce_ = 8; // 8:picture datasapce
967 streamInfo->intent_ = Camera::PREVIEW;
968 streamInfo->tunneledMode_ = false;
969 streamInfo->bufferQueue_ = producer;
970 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
971 streamInfos.push_back(streamInfo);
972 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
973 std::cout << "streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
974 EXPECT_EQ(true, display_->rc == Camera::METHOD_NOT_SUPPORTED);
975 if (display_->rc == Camera::METHOD_NOT_SUPPORTED) {
976 std::cout << "==========[test log] CreateStreams fail." << std::endl;
977 } else {
978 std::cout << "==========[test log] CreateStreams success"<< std::endl;
979 }
980 }
981
982 /**
983 * @tc.name: Preview
984 * @tc.desc: CreateStreams, StreamInfo->minFrameDuration = -1, return error.
985 * @tc.level: Level2
986 * @tc.size: MediumTest
987 * @tc.type: Function
988 */
TEST_F(UtestPreviewTest,camera_preview_0038)989 TEST_F(UtestPreviewTest, camera_preview_0038)
990 {
991 std::cout << "==========[test log] CreateStreams, StreamInfo->minFrameDuration = -1, ";
992 std::cout << "return error." << std::endl;
993 // 创建并获取streamOperator信息
994 display_->AchieveStreamOperator();
995 // 创建数据流
996 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
997 producer->SetQueueSize(8); // 8:set bufferQueue size
998 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
999 std::cout << "~~~~~~~" << std::endl;
1000 }
1001 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
1002 display_->BufferCallback(b, display_->preview_mode);
1003 return;
1004 };
1005 producer->SetCallback(callback);
1006 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
1007 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
1008 streamInfo->streamId_ = 1001;
1009 streamInfo->width_ = 640; // 640:picture width
1010 streamInfo->height_ = 480; // 480:picture height
1011 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
1012 streamInfo->datasapce_ = 8; // 8:picture datasapce
1013 streamInfo->intent_ = Camera::PREVIEW;
1014 streamInfo->tunneledMode_ = 0;
1015 streamInfo->minFrameDuration_ = -1;
1016 streamInfo->bufferQueue_ = producer;
1017 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
1018 streamInfos.push_back(streamInfo);
1019 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
1020 std::cout << "streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
1021 EXPECT_EQ(Camera::CamRetCode::INVALID_ARGUMENT, display_->rc);
1022 std::cout << "==========[test log] CreateStreams, failed." << std::endl;
1023 }
1024
1025 /**
1026 * @tc.name: Preview
1027 * @tc.desc: CreateStreams, StreamInfo->minFrameDuration = 2147483647, success.
1028 * @tc.level: Level2
1029 * @tc.size: MediumTest
1030 * @tc.type: Function
1031 */
TEST_F(UtestPreviewTest,camera_preview_0039)1032 TEST_F(UtestPreviewTest, camera_preview_0039)
1033 {
1034 std::cout << "==========[test log] CreateStreams, StreamInfo->minFrameDuration = 2147483647, ";
1035 std::cout << "success." << std::endl;
1036 // 创建并获取streamOperator信息
1037 display_->AchieveStreamOperator();
1038 // 创建数据流
1039 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
1040 producer->SetQueueSize(8); // 8:set bufferQueue size
1041 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
1042 std::cout << "~~~~~~~" << std::endl;
1043 }
1044 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
1045 display_->BufferCallback(b, display_->preview_mode);
1046 return;
1047 };
1048 producer->SetCallback(callback);
1049 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
1050 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
1051 streamInfo->streamId_ = 1001;
1052 streamInfo->width_ = 640; // 640:picture width
1053 streamInfo->height_ = 480; // 480:picture height
1054 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
1055 streamInfo->datasapce_ = 8; // 8:picture datasapce
1056 streamInfo->intent_ = Camera::PREVIEW;
1057 streamInfo->tunneledMode_ = 0;
1058 streamInfo->minFrameDuration_ = 2147483647;
1059 streamInfo->bufferQueue_ = producer;
1060 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
1061 streamInfos.push_back(streamInfo);
1062 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
1063 std::cout << "streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
1064 EXPECT_EQ(false, display_->rc == Camera::NO_ERROR);
1065 std::cout << "==========[test log] CreateStreams, success." << std::endl;
1066 }
1067
1068 /**
1069 * @tc.name: Preview
1070 * @tc.desc: Preview, CommitStreams Metadata = nullptr.
1071 * @tc.level: Level2
1072 * @tc.size: MediumTest
1073 * @tc.type: Function
1074 */
TEST_F(UtestPreviewTest,camera_preview_0040)1075 TEST_F(UtestPreviewTest, camera_preview_0040)
1076 {
1077 std::cout << "==========[test log] Preview, CommitStreams Metadata = nullptr." << std::endl;
1078 // 创建并获取streamOperator信息
1079 display_->AchieveStreamOperator();
1080 // 配流起流
1081 display_->rc = display_->streamOperator->CommitStreams(Camera::NORMAL, nullptr);
1082 std::cout << "streamOperator->CommitStreams's RetCode = " << display_->rc << std::endl;
1083 EXPECT_EQ(true, display_->rc == Camera::CamRetCode::DEVICE_ERROR);
1084 // 释放流
1085 std::vector<int> streamIds;
1086 streamIds.push_back(-1);
1087 display_->rc = display_->streamOperator->ReleaseStreams(streamIds);
1088 }
1089
1090 /**
1091 * @tc.name: Preview
1092 * @tc.desc: Preview, CommitStreams without CreateStreams, expected fail.
1093 * @tc.level: Level2
1094 * @tc.size: MediumTest
1095 * @tc.type: Function
1096 */
TEST_F(UtestPreviewTest,camera_preview_0050)1097 TEST_F(UtestPreviewTest, camera_preview_0050)
1098 {
1099 std::cout << "==========[test log] Preview, CommitStreams without CreateStreams, expected fail." << std::endl;
1100 // 创建并获取streamOperator信息
1101 display_->AchieveStreamOperator();
1102 // 配流起流
1103 display_->rc = display_->streamOperator->CommitStreams(Camera::NORMAL, nullptr);
1104 std::cout << "streamOperator->CommitStreams's RetCode = " << display_->rc << std::endl;
1105 EXPECT_EQ(true, display_->rc == Camera::CamRetCode::DEVICE_ERROR);
1106 // 释放流
1107 std::vector<int> streamIds;
1108 streamIds.push_back(-1);
1109 display_->rc = display_->streamOperator->ReleaseStreams(streamIds);
1110 }
1111
1112 /**
1113 * @tc.name: Preview
1114 * @tc.desc: Preview and release streams, success.
1115 * @tc.level: Level1
1116 * @tc.size: MediumTest
1117 * @tc.type: Function
1118 */
TEST_F(UtestPreviewTest,camera_preview_0060)1119 TEST_F(UtestPreviewTest, camera_preview_0060)
1120 {
1121 std::cout << "==========[test log] Preview and release streams, success." << std::endl;
1122 // 创建并获取streamOperator信息
1123 display_->AchieveStreamOperator();
1124 // 创建数据流
1125 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
1126 producer->SetQueueSize(8); // 8:set bufferQueue size
1127 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
1128 std::cout << "~~~~~~~" << std::endl;
1129 }
1130 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
1131 display_->BufferCallback(b, display_->preview_mode);
1132 return;
1133 };
1134 producer->SetCallback(callback);
1135 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
1136 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
1137 streamInfo->streamId_ = 1001;
1138 streamInfo->width_ = 640; // 640:picture width
1139 streamInfo->height_ = 480; // 480:picture height
1140 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
1141 streamInfo->datasapce_ = 8; // 8:picture datasapce
1142 streamInfo->intent_ = Camera::PREVIEW;
1143 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
1144 streamInfo->bufferQueue_ = producer;
1145 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
1146 streamInfos.push_back(streamInfo);
1147 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
1148 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1149 // 配流起流
1150 display_->rc = display_->streamOperator->CommitStreams(Camera::NORMAL, nullptr);
1151 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1152 // 获取预览图
1153 int captureId = 2001;
1154 std::shared_ptr<OHOS::Camera::CaptureInfo> captureInfo = std::make_shared<OHOS::Camera::CaptureInfo>();
1155 captureInfo->streamIds_ = {1001};
1156 captureInfo->enableShutterCallback_ = false;
1157 display_->rc = display_->streamOperator->Capture(captureId, captureInfo, true);
1158 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1159 sleep(5);
1160 display_->streamOperator->CancelCapture(captureId);
1161 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1162 // 释放流
1163 display_->rc = display_->streamOperator->ReleaseStreams(captureInfo->streamIds_);
1164 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1165 }
1166
1167 /**
1168 * @tc.name: Preview
1169 * @tc.desc: ReleaseStreams-> streamID = -1, expected success.
1170 * @tc.level: Level2
1171 * @tc.size: MediumTest
1172 * @tc.type: Function
1173 */
TEST_F(UtestPreviewTest,camera_preview_0061)1174 TEST_F(UtestPreviewTest, camera_preview_0061)
1175 {
1176 std::cout << "==========[test log] ReleaseStreams-> streamID = -1, expected success." << std::endl;
1177 // 创建并获取streamOperator信息
1178 display_->AchieveStreamOperator();
1179 // 创建预览流
1180 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
1181 producer->SetQueueSize(8); // 8:set bufferQueue size
1182 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
1183 std::cout << "~~~~~~~" << std::endl;
1184 }
1185 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
1186 display_->BufferCallback(b, display_->preview_mode);
1187 return;
1188 };
1189 producer->SetCallback(callback);
1190 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
1191 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
1192 streamInfo->streamId_ = 1001;
1193 streamInfo->width_ = 640; // 640:picture width
1194 streamInfo->height_ = 480; // 480:picture height
1195 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
1196 streamInfo->datasapce_ = 8; // 8:picture datasapce
1197 streamInfo->intent_ = Camera::PREVIEW;
1198 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
1199 streamInfo->bufferQueue_ = producer;
1200 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
1201 streamInfos.push_back(streamInfo);
1202 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
1203 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1204 // 配流起流
1205 display_->rc = display_->streamOperator->CommitStreams(Camera::NORMAL, nullptr);
1206 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1207 // 获取预览图
1208 int captureId = 2001;
1209 std::shared_ptr<OHOS::Camera::CaptureInfo> captureInfo = std::make_shared<OHOS::Camera::CaptureInfo>();
1210 captureInfo->streamIds_ = {1001};
1211 captureInfo->enableShutterCallback_ = false;
1212 display_->rc = display_->streamOperator->Capture(captureId, captureInfo, true);
1213 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1214 sleep(5);
1215 display_->streamOperator->CancelCapture(captureId);
1216 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1217 // 释放流
1218 display_->rc = display_->streamOperator->ReleaseStreams({-1});
1219 std::cout << "streamOperator->ReleaseStreams's rc = " << display_->rc << std::endl;
1220 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1221 display_->rc = display_->streamOperator->ReleaseStreams({1001});
1222 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1223 std::cout << "streamOperator->ReleaseStreams's RetCode = " << display_->rc << std::endl;
1224 }
1225
1226 /**
1227 * @tc.name: Preview
1228 * @tc.desc: ReleaseStreams no exist streamID, expect success.
1229 * @tc.level: Level2
1230 * @tc.size: MediumTest
1231 * @tc.type: Function
1232 */
TEST_F(UtestPreviewTest,camera_preview_0062)1233 TEST_F(UtestPreviewTest, camera_preview_0062)
1234 {
1235 std::cout << "==========[test log] ReleaseStreams no exist streamID, expect success." << std::endl;
1236 // 创建并获取streamOperator信息
1237 display_->AchieveStreamOperator();
1238 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
1239 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
1240 display_->rc = display_->streamOperator->ReleaseStreams({9999});
1241 std::cout << "streamOperator->ReleaseStreams's RetCode = " << display_->rc << std::endl;
1242 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1243 }
1244
1245 /**
1246 * @tc.name: Preview
1247 * @tc.desc: Preview, Capture->captureInfo->streamID = -1 ,return error.
1248 * @tc.level: Level2
1249 * @tc.size: MediumTest
1250 * @tc.type: Function
1251 */
TEST_F(UtestPreviewTest,camera_preview_0070)1252 TEST_F(UtestPreviewTest, camera_preview_0070)
1253 {
1254 std::cout << "==========[test log] Preview, Capture->captureInfo->streamID = -1 ,return error." << std::endl;
1255 // 创建并获取streamOperator信息
1256 display_->AchieveStreamOperator();
1257 // 创建预览流
1258 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
1259 producer->SetQueueSize(8); // 8:set bufferQueue size
1260 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
1261 std::cout << "~~~~~~~" << std::endl;
1262 }
1263 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
1264 display_->BufferCallback(b, display_->preview_mode);
1265 return;
1266 };
1267 producer->SetCallback(callback);
1268 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
1269 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
1270 streamInfo->streamId_ = 1001;
1271 streamInfo->width_ = 640; // 640:picture width
1272 streamInfo->height_ = 480; // 480:picture height
1273 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
1274 streamInfo->datasapce_ = 8; // 8:picture datasapce
1275 streamInfo->intent_ = Camera::PREVIEW;
1276 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
1277 streamInfo->bufferQueue_ = producer;
1278 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
1279 streamInfos.push_back(streamInfo);
1280 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
1281 if (display_->rc != Camera::NO_ERROR)
1282 std::cout << "==============[test log]CreateStreams failed!" << std::endl;
1283 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1284 // 配流起流
1285 display_->rc = display_->streamOperator->CommitStreams(Camera::NORMAL, nullptr);
1286 if (display_->rc != Camera::NO_ERROR)
1287 std::cout << "==============[test log]CommitStreams failed!" << std::endl;
1288 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1289 // 获取预览图
1290 int captureId = 2001;
1291 std::shared_ptr<OHOS::Camera::CaptureInfo> captureInfo = std::make_shared<OHOS::Camera::CaptureInfo>();
1292 captureInfo->streamIds_ = {-1};
1293 captureInfo->enableShutterCallback_ = true;
1294 display_->rc = display_->streamOperator->Capture(captureId, captureInfo, true);
1295 std::cout << "streamOperator->Capture rc = " << display_->rc << std::endl;
1296 if (display_->rc == Camera::INVALID_ARGUMENT)
1297 std::cout << "============[test log]Capture failed " << std::endl;
1298 EXPECT_EQ(Camera::INVALID_ARGUMENT, display_->rc);
1299 }
1300
1301 /**
1302 * @tc.name: Preview
1303 * @tc.desc: Preview, Capture->captureInfo->streamID = 2147483647 ,return success.
1304 * @tc.level: Level2
1305 * @tc.size: MediumTest
1306 * @tc.type: Function
1307 */
TEST_F(UtestPreviewTest,camera_preview_0071)1308 TEST_F(UtestPreviewTest, camera_preview_0071)
1309 {
1310 std::cout << "==========[test log] Preview, Capture->captureInfo->streamID = 2147483647 ,";
1311 std::cout << "return success." << std::endl;
1312 // 创建并获取streamOperator信息
1313 display_->AchieveStreamOperator();
1314 // 创建数据流
1315 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
1316 producer->SetQueueSize(8); // 8:set bufferQueue size
1317 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
1318 std::cout << "~~~~~~~" << std::endl;
1319 }
1320 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
1321 display_->BufferCallback(b, display_->preview_mode);
1322 return;
1323 };
1324 producer->SetCallback(callback);
1325 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
1326 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
1327 streamInfo->streamId_ = 2147483647;
1328 streamInfo->width_ = 640; // 640:picture width
1329 streamInfo->height_ = 480; // 480:picture height
1330 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
1331 streamInfo->datasapce_ = 8; // 8:picture datasapce
1332 streamInfo->intent_ = Camera::PREVIEW;
1333 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
1334 streamInfo->bufferQueue_ = producer;
1335 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
1336 streamInfos.push_back(streamInfo);
1337 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
1338 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1339 // 配流起流
1340 display_->rc = display_->streamOperator->CommitStreams(Camera::NORMAL, nullptr);
1341 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1342 // 获取预览图
1343 int captureId = 2001;
1344 std::shared_ptr<OHOS::Camera::CaptureInfo> captureInfo = std::make_shared<OHOS::Camera::CaptureInfo>();
1345 captureInfo->streamIds_ = {2147483647};
1346 captureInfo->enableShutterCallback_ = true;
1347 bool isStreaming = true;
1348 display_->rc = display_->streamOperator->Capture(captureId, captureInfo, isStreaming);
1349 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1350 sleep(5);
1351 display_->streamOperator->CancelCapture(captureId);
1352 // 释放流
1353 display_->rc = display_->streamOperator->ReleaseStreams(captureInfo->streamIds_);
1354 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1355 }
1356
1357 /**
1358 * @tc.name: Preview
1359 * @tc.desc: Preview, Capture->captureInfo->enableShutterCallback = false ,return success.
1360 * @tc.level: Level2
1361 * @tc.size: MediumTest
1362 * @tc.type: Function
1363 */
TEST_F(UtestPreviewTest,camera_preview_0072)1364 TEST_F(UtestPreviewTest, camera_preview_0072)
1365 {
1366 std::cout << "==========[test log] Preview, Capture->captureInfo->enableShutterCallback = false ,";
1367 std::cout << "return success." << std::endl;
1368 // 创建并获取streamOperator信息
1369 display_->AchieveStreamOperator();
1370 // 创建数据流
1371 display_->intents = {Camera::PREVIEW};
1372 display_->StartStream(display_->intents);
1373 // 获取预览图
1374 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
1375 // 释放流
1376 display_->captureIds = {display_->captureId_preview};
1377 display_->streamIds = {display_->streamId_preview};
1378 display_->StopStream(display_->captureIds, display_->streamIds);
1379 }
1380
1381 /**
1382 * @tc.name: Preview
1383 * @tc.desc: Preview, Capture->isStreaming = false ,expected success.
1384 * @tc.level: Level2
1385 * @tc.size: MediumTest
1386 * @tc.type: Function
1387 */
TEST_F(UtestPreviewTest,camera_preview_0073)1388 TEST_F(UtestPreviewTest, camera_preview_0073)
1389 {
1390 std::cout << "==========[test log] Preview, Capture->isStreaming = false ,expected success." << std::endl;
1391 // 创建并获取streamOperator信息
1392 display_->AchieveStreamOperator();
1393 // 创建数据流
1394 display_->intents = {Camera::PREVIEW};
1395 display_->StartStream(display_->intents);
1396 // 获取预览图
1397 int captureId = 2001;
1398 std::shared_ptr<OHOS::Camera::CaptureInfo> captureInfo = std::make_shared<OHOS::Camera::CaptureInfo>();
1399 captureInfo->streamIds_ = {display_->streamId_preview};
1400 captureInfo->enableShutterCallback_ = true;
1401 display_->rc = display_->streamOperator->Capture(captureId, captureInfo, false);
1402 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1403 sleep(5);
1404 display_->streamOperator->CancelCapture(captureId);
1405 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1406 // 释放流
1407 display_->rc = display_->streamOperator->ReleaseStreams(captureInfo->streamIds_);
1408 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1409 }
1410
1411 /**
1412 * @tc.name: Preview
1413 * @tc.desc: Preview, Capture->captureId = -1 ,return error.
1414 * @tc.level: Level2
1415 * @tc.size: MediumTest
1416 * @tc.type: Function
1417 */
TEST_F(UtestPreviewTest,camera_preview_0074)1418 TEST_F(UtestPreviewTest, camera_preview_0074)
1419 {
1420 std::cout << "==========[test log] Preview, Capture->captureId = -1 ,return error." << std::endl;
1421 // 创建并获取streamOperator信息
1422 display_->AchieveStreamOperator();
1423 // 创建数据流
1424 display_->intents = {Camera::PREVIEW};
1425 display_->StartStream(display_->intents);
1426 // 获取预览图
1427 int captureId = -1;
1428 std::shared_ptr<OHOS::Camera::CaptureInfo> captureInfo = std::make_shared<OHOS::Camera::CaptureInfo>();
1429 captureInfo->streamIds_ = {display_->streamId_preview};
1430 captureInfo->enableShutterCallback_ = false;
1431 bool isStreaming = true;
1432 display_->rc = display_->streamOperator->Capture(captureId, captureInfo, isStreaming);
1433 EXPECT_EQ(Camera::CamRetCode::INVALID_ARGUMENT, display_->rc);
1434 }
1435
1436 /**
1437 * @tc.name: Preview
1438 * @tc.desc: Preview, Capture->captureInfo->enableShutterCallback = true ,return success.
1439 * @tc.level: Level2
1440 * @tc.size: MediumTest
1441 * @tc.type: Function
1442 */
TEST_F(UtestPreviewTest,camera_preview_0075)1443 TEST_F(UtestPreviewTest, camera_preview_0075)
1444 {
1445 std::cout << "==========[test log] Preview, Capture->captureInfo->enableShutterCallback = true ,";
1446 std::cout << "return success." << std::endl;
1447 // 创建并获取streamOperator信息
1448 display_->AchieveStreamOperator();
1449 // 创建数据流
1450 display_->intents = {Camera::PREVIEW};
1451 display_->StartStream(display_->intents);
1452 // 获取预览图
1453 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, true, true);
1454 // 释放流
1455 display_->captureIds = {display_->captureId_preview};
1456 display_->streamIds = {display_->streamId_preview};
1457 display_->StopStream(display_->captureIds, display_->streamIds);
1458 }
1459
1460 /**
1461 * @tc.name: Preview
1462 * @tc.desc: CancelCapture captureID = -1.
1463 * @tc.level: Level2
1464 * @tc.size: MediumTest
1465 * @tc.type: Function
1466 */
TEST_F(UtestPreviewTest,camera_preview_0080)1467 TEST_F(UtestPreviewTest, camera_preview_0080)
1468 {
1469 std::cout << "==========[test log] CancelCapture captureID = -1, expected fail." << std::endl;
1470 // 创建并获取streamOperator信息
1471 display_->AchieveStreamOperator();
1472 // 创建数据流
1473 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
1474 producer->SetQueueSize(8); // 8:set bufferQueue size
1475 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
1476 std::cout << "~~~~~~~" << std::endl;
1477 }
1478 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
1479 display_->BufferCallback(b, display_->preview_mode);
1480 return;
1481 };
1482 producer->SetCallback(callback);
1483 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>> streamInfos;
1484 std::shared_ptr<OHOS::Camera::StreamInfo> streamInfo = std::make_shared<OHOS::Camera::StreamInfo>();
1485 streamInfo->streamId_ = 1001;
1486 streamInfo->width_ = 640; // 640:picture width
1487 streamInfo->height_ = 480; // 480:picture height
1488 streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
1489 streamInfo->datasapce_ = 8; // 8:picture datasapce
1490 streamInfo->intent_ = Camera::PREVIEW;
1491 streamInfo->tunneledMode_ = 5; // 5:tunnel mode
1492 streamInfo->bufferQueue_ = producer;
1493 std::vector<std::shared_ptr<OHOS::Camera::StreamInfo>>().swap(streamInfos);
1494 streamInfos.push_back(streamInfo);
1495 display_->rc = display_->streamOperator->CreateStreams(streamInfos);
1496 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1497 // 配流起流
1498 display_->rc = display_->streamOperator->CommitStreams(Camera::NORMAL, nullptr);
1499 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1500 // 获取预览图
1501 int captureId = 100;
1502 std::shared_ptr<OHOS::Camera::CaptureInfo> captureInfo = std::make_shared<OHOS::Camera::CaptureInfo>();
1503 captureInfo->streamIds_ = {1001};
1504 captureInfo->enableShutterCallback_ = false;
1505 bool isStreaming = true;
1506 display_->rc = display_->streamOperator->Capture(captureId, captureInfo, isStreaming);
1507 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1508 sleep(5);
1509 display_->rc = display_->streamOperator->CancelCapture(-1);
1510 EXPECT_EQ(OHOS::Camera::CamRetCode::INVALID_ARGUMENT, display_->rc);
1511 display_->rc = display_->streamOperator->CancelCapture(captureId);
1512 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1513 // 释放流
1514 display_->rc = display_->streamOperator->ReleaseStreams(captureInfo->streamIds_);
1515 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1516 }
1517
1518 /**
1519 * @tc.name: Preview
1520 * @tc.desc: CancelCapture without Create capture.
1521 * @tc.level: Level2
1522 * @tc.size: MediumTest
1523 * @tc.type: Function
1524 */
TEST_F(UtestPreviewTest,camera_preview_0090)1525 TEST_F(UtestPreviewTest, camera_preview_0090)
1526 {
1527 std::cout << "==========[test log] CancelCapture without Create capture ." << std::endl;
1528 // 创建并获取streamOperator信息
1529 display_->AchieveStreamOperator();
1530 // 创建数据流
1531 display_->intents = {Camera::PREVIEW};
1532 display_->StartStream(display_->intents);
1533 // 获取预览图
1534 int captureId = 100;
1535 display_->rc = display_->streamOperator->CancelCapture(captureId);
1536 if (display_->rc == Camera::NO_ERROR) {
1537 std::cout << "==========[test log] CancelCapture success." << std::endl;
1538 }
1539 else {
1540 std::cout << "==========[test log] CancelCapture fail, rc = " << display_->rc << std::endl;
1541 }
1542 }
1543
1544 /**
1545 * @tc.name: Preview
1546 * @tc.desc: Release streams, then createCapture.
1547 * @tc.level: Level2
1548 * @tc.size: MediumTest
1549 * @tc.type: Function
1550 */
TEST_F(UtestPreviewTest,camera_preview_0091)1551 TEST_F(UtestPreviewTest, camera_preview_0091)
1552 {
1553 std::cout << "==========[test log] Create capture, then release streams." << std::endl;
1554 // 创建并获取streamOperator信息
1555 display_->AchieveStreamOperator();
1556 // 启流
1557 display_->intents = {Camera::PREVIEW};
1558 display_->StartStream(display_->intents);
1559 // 获取预览图
1560 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
1561 // 释放流
1562 display_->captureIds = {display_->captureId_preview};
1563 display_->streamIds = {display_->streamId_preview};
1564 display_->StopStream(display_->captureIds, display_->streamIds);
1565 }
1566
1567 /**
1568 * @tc.name: Preview
1569 * @tc.desc: The same CaptureID, Create capture twice, expected fail.
1570 * @tc.level: Level2
1571 * @tc.size: MediumTest
1572 * @tc.type: Function
1573 */
TEST_F(UtestPreviewTest,camera_preview_0092)1574 TEST_F(UtestPreviewTest, camera_preview_0092)
1575 {
1576 std::cout << "==========[test log] The same CaptureID, Create capture twice, expected fail." << std::endl;
1577 // 创建并获取streamOperator信息
1578 display_->AchieveStreamOperator();
1579 // 启流
1580 display_->intents = {Camera::PREVIEW};
1581 display_->StartStream(display_->intents);
1582 // 获取预览图
1583 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
1584 display_->StartCapture(display_->streamId_preview, display_->captureId_preview, false, true);
1585 // 释放流
1586 display_->captureIds = {display_->captureId_preview};
1587 display_->streamIds = {display_->streamId_preview};
1588 display_->StopStream(display_->captureIds, display_->streamIds);
1589 }
1590
1591 /**
1592 * @tc.name: Preview
1593 * @tc.desc: Different captureIDs, Create capture，expected success.
1594 * @tc.level: Level2
1595 * @tc.size: MediumTest
1596 * @tc.type: Function
1597 */
TEST_F(UtestPreviewTest,camera_preview_0093)1598 TEST_F(UtestPreviewTest, camera_preview_0093)
1599 {
1600 std::cout << "==========[test log] Different captureIDs, Create capture，expected success." << std::endl;
1601 // 创建并获取streamOperator信息
1602 display_->AchieveStreamOperator();
1603 // 创建数据流
1604 display_->intents = {Camera::PREVIEW};
1605 display_->StartStream(display_->intents);
1606 // 获取预览图
1607 int captureId = 100;
1608 std::shared_ptr<OHOS::Camera::CaptureInfo> captureInfo = std::make_shared<OHOS::Camera::CaptureInfo>();
1609 captureInfo->streamIds_ = {display_->streamId_preview};
1610 captureInfo->enableShutterCallback_ = false;
1611 bool isStreaming = true;
1612 display_->rc = display_->streamOperator->Capture(captureId, captureInfo, isStreaming);
1613 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1614 display_->rc = display_->streamOperator->Capture(captureId + 1, captureInfo, isStreaming);
1615 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1616 display_->streamOperator->CancelCapture(captureId);
1617 // 释放流
1618 display_->rc = display_->streamOperator->ReleaseStreams(captureInfo->streamIds_);
1619 EXPECT_EQ(true, display_->rc == Camera::NO_ERROR);
1620 }
1621