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