1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "hdi_func_test.h"
16
SetUpTestCase(void)17 void UtestHdiFuncTest::SetUpTestCase(void)
18 {}
TearDownTestCase(void)19 void UtestHdiFuncTest::TearDownTestCase(void)
20 {}
SetUp(void)21 void UtestHdiFuncTest::SetUp(void)
22 {
23 if (display_ == nullptr)
24 display_ = std::make_shared<TestDisplay>();
25 display_->FBInit();
26 display_->Init();
27 }
TearDown(void)28 void UtestHdiFuncTest::TearDown(void)
29 {
30 display_->Close();
31 }
32
33 /**
34 * @tc.name: Capture
35 * @tc.desc: Capture, input normal.
36 * @tc.level: Level1
37 * @tc.size: MediumTest
38 * @tc.type: Function
39 */
TEST_F(UtestHdiFuncTest,camera_hdi_0190)40 TEST_F(UtestHdiFuncTest, camera_hdi_0190)
41 {
42 std::cout << "==========[test log] Capture, input normal." << std::endl;
43 // Create and get streamOperator information
44 display_->AchieveStreamOperator();
45 // Create data stream
46 display_->intents = {PREVIEW};
47 display_->StartStream(display_->intents);
48 // Get preview
49 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
50 // release stream
51 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
52 display_->streamIds = {display_->STREAM_ID_PREVIEW};
53 display_->StopStream(display_->captureIds, display_->streamIds);
54 }
55
56 /**
57 * @tc.name: Capture
58 * @tc.desc: Preview, Capture->captureInfo->streamID = -1 ,return error.
59 * @tc.level: Level2
60 * @tc.size: MediumTest
61 * @tc.type: Function
62 */
TEST_F(UtestHdiFuncTest,camera_hdi_0191)63 TEST_F(UtestHdiFuncTest, camera_hdi_0191)
64 {
65 std::cout << "==========[test log] Preview, Capture->captureInfo->streamID = -1 ,return error." << std::endl;
66 display_->OpenCamera();
67 // Create and get streamOperator information
68 display_->AchieveStreamOperator();
69 // start stream
70 display_->intents = {PREVIEW};
71 display_->StartStream(display_->intents);
72 // Get preview
73 int captureId = 2001;
74 std::shared_ptr<CaptureInfo> captureInfo = std::make_shared<CaptureInfo>();
75 captureInfo->streamIds_ = {-1};
76 captureInfo->enableShutterCallback_ = true;
77 display_->rc = display_->streamOperator->Capture(captureId, captureInfo, true);
78 EXPECT_EQ(INVALID_ARGUMENT, display_->rc);
79 if (display_->rc == INVALID_ARGUMENT) {
80 std::cout << "==========[test log] Capture fail." << std::endl;
81 } else {
82 std::cout << "==========[test log] Capture success." << std::endl;
83 }
84 sleep(3); // waiting resource release for 3s.
85 }
86
87 /**
88 * @tc.name: Capture
89 * @tc.desc: Preview, Capture->captureInfo->streamID = 2147483647 ,return success.
90 * @tc.level: Level2
91 * @tc.size: MediumTest
92 * @tc.type: Function
93 */
TEST_F(UtestHdiFuncTest,camera_hdi_0192)94 TEST_F(UtestHdiFuncTest, camera_hdi_0192)
95 {
96 std::cout << "==========[test log] Preview,";
97 std::cout << "Capture->captureInfo->streamID = 2147483647 ,return success." << std::endl;
98 // Create and get streamOperator information
99 display_->AchieveStreamOperator();
100 // start stream
101 display_->intents = {PREVIEW};
102 display_->StartStream(display_->intents);
103 // Get preview
104 int captureId = 2001;
105 std::shared_ptr<CaptureInfo> captureInfo = std::make_shared<CaptureInfo>();
106 captureInfo->streamIds_ = {2147483647};
107 captureInfo->enableShutterCallback_ = true;
108 bool isStreaming = true;
109 display_->rc = display_->streamOperator->Capture(captureId, captureInfo, isStreaming);
110 EXPECT_EQ(true, display_->rc == NO_ERROR);
111 if (display_->rc == NO_ERROR) {
112 std::cout << "==========[test log] Capture success." << std::endl;
113 } else {
114 std::cout << "==========[test log] Capture fail, rc = " << display_->rc << std::endl;
115 }
116 sleep(5); // waiting function Capture execute for 5s.
117 display_->rc = display_->streamOperator->CancelCapture(captureId);
118 EXPECT_EQ(true, display_->rc == NO_ERROR);
119 if (display_->rc == NO_ERROR) {
120 std::cout << "==========[test log] CancelCapture success." << std::endl;
121 } else {
122 std::cout << "==========[test log] CancelCapture fail, rc = " << display_->rc << std::endl;
123 }
124 display_->cameraDevice->Close();
125 std::cout << "cameraDevice->Close" << std::endl;
126 }
127
128 /**
129 * @tc.name: Capture
130 * @tc.desc: Preview, Capture->captureInfo->enableShutterCallback = false ,return success.
131 * @tc.level: Level2
132 * @tc.size: MediumTest
133 * @tc.type: Function
134 */
TEST_F(UtestHdiFuncTest,camera_hdi_0193)135 TEST_F(UtestHdiFuncTest, camera_hdi_0193)
136 {
137 std::cout << "==========[test log] Preview,";
138 std::cout << "Capture->captureInfo->enableShutterCallback = false ,return success." << std::endl;
139 // Create and get streamOperator information
140 display_->AchieveStreamOperator();
141 // start stream
142 display_->intents = {PREVIEW};
143 display_->StartStream(display_->intents);
144 // Get preview
145 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
146 // release stream
147 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
148 display_->streamIds = {display_->STREAM_ID_PREVIEW};
149 display_->StopStream(display_->captureIds, display_->streamIds);
150 }
151
152 /**
153 * @tc.name: Capture
154 * @tc.desc: Preview, Capture->isStreaming = false ,expected success.
155 * @tc.level: Level2
156 * @tc.size: MediumTest
157 * @tc.type: Function
158 */
TEST_F(UtestHdiFuncTest,camera_hdi_0194)159 TEST_F(UtestHdiFuncTest, camera_hdi_0194)
160 {
161 std::cout << "==========[test log] Preview, Capture->isStreaming = false ,expected success." << std::endl;
162 std::cout << "==========[test log] Preview, Capture->isStreaming = false ,expected success." << std::endl;
163 // Create and get streamOperator information
164 display_->AchieveStreamOperator();
165 // start stream
166 display_->intents = {PREVIEW};
167 display_->StartStream(display_->intents);
168 // Get preview
169 int captureId = 2001;
170 std::shared_ptr<CaptureInfo> captureInfo = std::make_shared<CaptureInfo>();
171 captureInfo->streamIds_ = {display_->STREAM_ID_PREVIEW};
172 captureInfo->enableShutterCallback_ = true;
173 display_->rc = display_->streamOperator->Capture(captureId, captureInfo, false);
174 EXPECT_EQ(true, display_->rc == NO_ERROR);
175 sleep(5); // waiting 5s, prepare for execute function CancelCapture
176 display_->streamOperator->CancelCapture(captureId);
177 EXPECT_EQ(true, display_->rc == NO_ERROR);
178 if (display_->rc == NO_ERROR) {
179 std::cout << "==========[test log] CancelCapture success." << std::endl;
180 } else {
181 std::cout << "==========[test log] CancelCapture fail, rc = " << display_->rc << std::endl;
182 }
183 // release stream
184 display_->rc = display_->streamOperator->ReleaseStreams(captureInfo->streamIds_);
185 EXPECT_EQ(true, display_->rc == NO_ERROR);
186 if (display_->rc == NO_ERROR) {
187 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
188 } else {
189 std::cout << "==========[test log] ReleaseStreams fail, rc = " << display_->rc << std::endl;
190 }
191 }
192
193 /**
194 * @tc.name: Capture
195 * @tc.desc: Preview, Capture->captureId = -1 ,return error.
196 * @tc.level: Level2
197 * @tc.size: MediumTest
198 * @tc.type: Function
199 */
TEST_F(UtestHdiFuncTest,camera_hdi_0195)200 TEST_F(UtestHdiFuncTest, camera_hdi_0195)
201 {
202 std::cout << "==========[test log] Preview, Capture->captureId = -1 ,return error." << std::endl;
203 display_->OpenCamera();
204 // Create and get streamOperator information
205 display_->AchieveStreamOperator();
206 // start stream
207 display_->intents = {PREVIEW};
208 display_->StartStream(display_->intents);
209 // Get preview
210 int captureId = -1;
211 std::shared_ptr<CaptureInfo> captureInfo = std::make_shared<CaptureInfo>();
212 captureInfo->streamIds_ = {display_->STREAM_ID_PREVIEW};
213 captureInfo->enableShutterCallback_ = false;
214 bool isStreaming = true;
215 display_->rc = display_->streamOperator->Capture(captureId, captureInfo, isStreaming);
216 EXPECT_EQ(INVALID_ARGUMENT, display_->rc);
217 if (display_->rc == NO_ERROR) {
218 std::cout << "==========[test log] Capture success." << std::endl;
219 } else {
220 std::cout << "==========[test log] Capture fail, rc = " << display_->rc << std::endl;
221 }
222 sleep(3); // waiting resource release for 3s.
223 }
224
225 /**
226 * @tc.name: Capture
227 * @tc.desc: Preview, Capture->captureInfo->enableShutterCallback = true ,return success.
228 * @tc.level: Level2
229 * @tc.size: MediumTest
230 * @tc.type: Function
231 */
TEST_F(UtestHdiFuncTest,camera_hdi_0196)232 TEST_F(UtestHdiFuncTest, camera_hdi_0196)
233 {
234 std::cout << "==========[test log] Preview,";
235 std::cout << "Capture->captureInfo->enableShutterCallback = true ,return success." << std::endl;
236 // Create and get streamOperator information
237 display_->AchieveStreamOperator();
238 // start stream
239 display_->intents = {PREVIEW};
240 display_->StartStream(display_->intents);
241 // Get preview
242 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, true, true);
243 // release stream
244 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
245 display_->streamIds = {display_->STREAM_ID_PREVIEW};
246 display_->StopStream(display_->captureIds, display_->streamIds);
247 }
248
249 /**
250 * @tc.name: CancelCapture
251 * @tc.desc: CancelCapture, success.
252 * @tc.level: Level2
253 * @tc.size: MediumTest
254 * @tc.type: Function
255 */
TEST_F(UtestHdiFuncTest,camera_hdi_0200)256 TEST_F(UtestHdiFuncTest, camera_hdi_0200)
257 {
258 std::cout << "==========[test log] CancelCapture, success." << std::endl;
259 // Create and get streamOperator information
260 display_->AchieveStreamOperator();
261 // start stream
262 display_->intents = {PREVIEW};
263 display_->StartStream(display_->intents);
264 // Get preview
265 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
266 // release stream
267 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
268 display_->streamIds = {display_->STREAM_ID_PREVIEW};
269 display_->StopStream(display_->captureIds, display_->streamIds);
270 }
271
272 /**
273 * @tc.name: CancelCapture
274 * @tc.desc: CancelCapture captureID = -1.
275 * @tc.level: Level2
276 * @tc.size: MediumTest
277 * @tc.type: Function
278 */
TEST_F(UtestHdiFuncTest,camera_hdi_0201)279 TEST_F(UtestHdiFuncTest, camera_hdi_0201)
280 {
281 std::cout << "==========[test log] CancelCapture captureID = -1, expected fail." << std::endl;
282 // Create and get streamOperator information
283 display_->AchieveStreamOperator();
284 // start stream
285 display_->intents = {PREVIEW};
286 display_->StartStream(display_->intents);
287 // Get preview
288 int captureId = 100;
289 std::shared_ptr<CaptureInfo> captureInfo = std::make_shared<CaptureInfo>();
290 captureInfo->streamIds_ = {display_->STREAM_ID_PREVIEW};
291 captureInfo->enableShutterCallback_ = false;
292 bool isStreaming = true;
293 display_->rc = display_->streamOperator->Capture(captureId, captureInfo, isStreaming);
294 EXPECT_EQ(true, display_->rc == NO_ERROR);
295 sleep(5); // waiting 5s, prepare for execute function CancelCapture
296 display_->rc = display_->streamOperator->CancelCapture(-1);
297 EXPECT_EQ(INVALID_ARGUMENT, display_->rc);
298 display_->rc = display_->streamOperator->CancelCapture(captureId);
299 EXPECT_EQ(true, display_->rc == NO_ERROR);
300 if (display_->rc == NO_ERROR) {
301 std::cout << "==========[test log] CancelCapture success." << std::endl;
302 } else {
303 std::cout << "==========[test log] CancelCapture fail, rc = " << display_->rc << std::endl;
304 }
305 // release stream
306 display_->rc = display_->streamOperator->ReleaseStreams(captureInfo->streamIds_);
307 EXPECT_EQ(true, display_->rc == NO_ERROR);
308 if (display_->rc == NO_ERROR) {
309 std::cout << "==========[test log] ReleaseStreams success." << std::endl;
310 } else {
311 std::cout << "==========[test log] ReleaseStreams fail, rc = " << display_->rc << std::endl;
312 }
313 }
314
315 /**
316 * @tc.name: AttachBufferQueue
317 * @tc.desc: AttachBufferQueue, normal input.
318 * @tc.level: Level1
319 * @tc.size: MediumTest
320 * @tc.type: Function
321 // */
TEST_F(UtestHdiFuncTest,camera_hdi_0210)322 TEST_F(UtestHdiFuncTest, camera_hdi_0210)
323 {
324 std::cout << "==========[test log] AttachBufferQueue, normal input." << std::endl;
325 display_->AchieveStreamOperator();
326 // Create data stream
327 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
328 producer->SetQueueSize(8); // 8:set bufferQueue size
329 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
330 std::cout << "~~~~~~~" << std::endl;
331 }
332 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
333 display_->BufferCallback(b, display_->preview_mode);
334 return;
335 };
336 producer->SetCallback(callback);
337
338 display_->streamInfo = std::make_shared<StreamInfo>();
339 display_->streamInfo->streamId_ = DEFAULT_STREAM_ID;
340 display_->streamInfo->width_ = 640; // 640:picture width
341 display_->streamInfo->height_ = 480; // 480:picture height
342 display_->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
343 display_->streamInfo->dataspace_ = 8; // 8:picture dataspace
344 display_->streamInfo->intent_ = PREVIEW;
345 display_->streamInfo->tunneledMode_ = 5; // 5:tunnel mode
346 display_->streamInfos.push_back(display_->streamInfo);
347 display_->rc = display_->streamOperator->CreateStreams(display_->streamInfos);
348 std::cout << "==========[test log] streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
349 EXPECT_EQ(true, display_->rc == NO_ERROR);
350 if (display_->rc == NO_ERROR) {
351 std::cout << "==========[test log] CreateStreams success." << std::endl;
352 } else {
353 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
354 }
355 display_->rc = display_->streamOperator->AttachBufferQueue(display_->streamInfo->streamId_, producer);
356 EXPECT_EQ(true, display_->rc == NO_ERROR);
357 if (display_->rc == NO_ERROR) {
358 std::cout << "==========[test log] AttachBufferQueue success. " << std::endl;
359 } else {
360 std::cout << "==========[test log] AttachBufferQueue fail, rc = " << display_->rc << std::endl;
361 }
362 sleep(3); // waiting 3s, prepare for release stream.
363 // release stream
364 display_->streamIds = {DEFAULT_STREAM_ID};
365 display_->StopStream(display_->captureIds, display_->streamIds);
366 }
367
368 /**
369 * @tc.name: AttachBufferQueue
370 * @tc.desc: AttachBufferQueue, streamID is not exist.
371 * @tc.level: Level2
372 * @tc.size: MediumTest
373 * @tc.type: Function
374 */
TEST_F(UtestHdiFuncTest,camera_hdi_0211)375 TEST_F(UtestHdiFuncTest, camera_hdi_0211)
376 {
377 std::cout << "==========[test log] AttachBufferQueue, streamID is not exist.." << std::endl;
378 display_->AchieveStreamOperator();
379 // Create data stream
380 display_->streamInfo = std::make_shared<StreamInfo>();
381 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
382 producer->SetQueueSize(8); // 8:set bufferQueue size
383 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
384 std::cout << "~~~~~~~" << std::endl;
385 }
386 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
387 display_->BufferCallback(b, display_->preview_mode);
388 return;
389 };
390 producer->SetCallback(callback);
391 display_->streamInfo->streamId_ = DEFAULT_STREAM_ID;
392 display_->streamInfo->width_ = 640; // 640:picture width
393 display_->streamInfo->height_ = 480; // 480:picture height
394 display_->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
395 display_->streamInfo->dataspace_ = 8; // 8:picture dataspace
396 display_->streamInfo->intent_ = PREVIEW;
397 display_->streamInfo->tunneledMode_ = 5; // 5:tunnel mode
398 display_->streamInfos.push_back(display_->streamInfo);
399 display_->rc = display_->streamOperator->CreateStreams(display_->streamInfos);
400 std::cout << "==========[test log] streamOperator->CreateStreams's RetCode = " << display_->rc << std::endl;
401 EXPECT_EQ(true, display_->rc == NO_ERROR);
402 if (display_->rc == NO_ERROR) {
403 std::cout << "==========[test log] CreateStreams success." << std::endl;
404 } else {
405 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
406 }
407 display_->rc = display_->streamOperator->AttachBufferQueue(0, producer);
408 EXPECT_EQ(true, display_->rc != NO_ERROR);
409 if (display_->rc == NO_ERROR) {
410 std::cout << "==========[test log] AttachBufferQueue success. " << std::endl;
411 } else {
412 std::cout << "==========[test log] AttachBufferQueue fail, rc = " << display_->rc << std::endl;
413 }
414 sleep(3); // waiting 3s, prepare for release stream.
415 // Release the stream
416 display_->streamIds = {DEFAULT_STREAM_ID};
417 display_->StopStream(display_->captureIds, display_->streamIds);
418 }
419
420 /**
421 * @tc.name: AttachBufferQueue
422 * @tc.desc: AttachBufferQueue, producer is nullptr.
423 * @tc.level: Level2
424 * @tc.size: MediumTest
425 * @tc.type: Function
426 */
TEST_F(UtestHdiFuncTest,camera_hdi_0212)427 TEST_F(UtestHdiFuncTest, camera_hdi_0212)
428 {
429 std::cout << "==========[test log] AttachBufferQueue, producer is nullptr." << std::endl;
430 display_->AchieveStreamOperator();
431 if (display_->rc == NO_ERROR) {
432 std::cout << "==========[test log] GetStreamOperator success. " << std::endl;
433 } else {
434 std::cout << "==========[test log] GetStreamOperator fail, rc = " << display_->rc << std::endl;
435 }
436 // Create data stream
437 display_->streamInfo = std::make_shared<StreamInfo>();
438 display_->streamInfo->streamId_ = DEFAULT_STREAM_ID;
439 display_->streamInfo->width_ = 640; // 640:picture width
440 display_->streamInfo->height_ = 480; // 480:picture height
441 display_->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
442 display_->streamInfo->dataspace_ = 8; // 8:picture dataspace
443 display_->streamInfo->intent_ = PREVIEW;
444 display_->streamInfo->tunneledMode_ = 5; // 5:tunnel mode
445 display_->streamInfos.push_back(display_->streamInfo);
446 display_->rc = display_->streamOperator->CreateStreams(display_->streamInfos);
447 std::cout << "==========[test log] streamOperator->CreateStreams's RetCode = ";
448 std::cout << display_->rc << std::endl;
449 EXPECT_EQ(true, display_->rc == NO_ERROR);
450 if (display_->rc == NO_ERROR) {
451 std::cout << "==========[test log] CreateStreams success. " << std::endl;
452 } else {
453 std::cout << "==========[test log] CreateStreams fail, rc = " << display_->rc << std::endl;
454 }
455 display_->rc = display_->streamOperator->AttachBufferQueue(display_->streamInfo->streamId_, nullptr);
456 EXPECT_EQ(true, display_->rc != NO_ERROR);
457 if (display_->rc == NO_ERROR) {
458 std::cout << "==========[test log] AttachBufferQueue success. " << std::endl;
459 } else {
460 std::cout << "==========[test log] AttachBufferQueue fail, rc = " << display_->rc << std::endl;
461 }
462 sleep(3); // waiting 3s, prepare for release stream.
463 // release stream
464 display_->streamIds = {DEFAULT_STREAM_ID};
465 display_->StopStream(display_->captureIds, display_->streamIds);
466 }
467
468 /**
469 * @tc.name: DetachBufferQueue
470 * @tc.desc: DetachBufferQueue, normal input.
471 * @tc.level: Level1
472 * @tc.size: MediumTest
473 * @tc.type: Function
474 */
TEST_F(UtestHdiFuncTest,camera_hdi_0220)475 TEST_F(UtestHdiFuncTest, camera_hdi_0220)
476 {
477 std::cout << "==========[test log] DetachBufferQueue, normal input." << std::endl;
478 display_->AchieveStreamOperator();
479 // Create data stream
480 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
481 producer->SetQueueSize(8); // 8:set bufferQueue size
482 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
483 std::cout << "~~~~~~~" << std::endl;
484 }
485 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
486 display_->BufferCallback(b, display_->preview_mode);
487 return;
488 };
489 producer->SetCallback(callback);
490 display_->streamInfo = std::make_shared<StreamInfo>();
491 display_->streamInfo->streamId_ = DEFAULT_STREAM_ID;
492 display_->streamInfo->width_ = 640; // 640:picture width
493 display_->streamInfo->height_ = 480; // 480:picture height
494 display_->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
495 display_->streamInfo->dataspace_ = 8; // 8:picture dataspace
496 display_->streamInfo->intent_ = PREVIEW;
497 display_->streamInfo->tunneledMode_ = 5; // 5:tunnel mode
498 display_->streamInfos.push_back(display_->streamInfo);
499 display_->rc = display_->streamOperator->CreateStreams(display_->streamInfos);
500 std::cout << "==========[test log] streamOperator->CreateStreams's RetCode = ";
501 std::cout << display_->rc << std::endl;
502 EXPECT_EQ(true, display_->rc == NO_ERROR);
503 std::cout << "==========[test log] CreateStreams success. " << std::endl;
504 display_->rc = display_->streamOperator->AttachBufferQueue(display_->streamInfo->streamId_, producer);
505 std::cout << "==========[test log] streamOperator->AttachBufferQueue's RetCode = ";
506 std::cout << display_->rc << std::endl;
507 EXPECT_EQ(true, display_->rc == NO_ERROR);
508 sleep(3); // waiting 3s, prepare for attach bufferQueue.
509 std::cout << "==========[test log] AttachBufferQueue success. " << std::endl;
510 display_->rc = display_->streamOperator->DetachBufferQueue(display_->streamInfo->streamId_);
511 std::cout << "==========[test log] streamOperator->DetachBufferQueue's RetCode = ";
512 std::cout << display_->rc << std::endl;
513 EXPECT_EQ(true, display_->rc == NO_ERROR);
514 if (display_->rc == NO_ERROR) {
515 std::cout << "==========[test log] DetachBufferQueue success. " << std::endl;
516 } else {
517 std::cout << "==========[test log] DetachBufferQueue fail, rc = " << display_->rc << std::endl;
518 }
519 // release stream
520 display_->streamIds = {DEFAULT_STREAM_ID};
521 display_->StopStream(display_->captureIds, display_->streamIds);
522 }
523
524 /**
525 * @tc.name: DetachBufferQueue
526 * @tc.desc: DetachBufferQueue, streamID is not exist.
527 * @tc.level: Level2
528 * @tc.size: MediumTest
529 * @tc.type: Function
530 */
TEST_F(UtestHdiFuncTest,camera_hdi_0221)531 TEST_F(UtestHdiFuncTest, camera_hdi_0221)
532 {
533 std::cout << "==========[test log] DetachBufferQueue, streamID is not exist." << std::endl;
534 display_->AchieveStreamOperator();
535 // Create data stream
536 std::shared_ptr<IBufferProducer> producer = IBufferProducer::CreateBufferQueue();
537 producer->SetQueueSize(8); // 8:set bufferQueue size
538 if (producer->GetQueueSize() != 8) { // 8:get bufferQueue size
539 std::cout << "~~~~~~~" << std::endl;
540 }
541 auto callback = [this](std::shared_ptr<SurfaceBuffer> b) {
542 display_->BufferCallback(b, display_->preview_mode);
543 return;
544 };
545 producer->SetCallback(callback);
546 display_->streamInfo = std::make_shared<StreamInfo>();
547 display_->streamInfo->streamId_ = DEFAULT_STREAM_ID;
548 display_->streamInfo->width_ = 640; // 640:picture width
549 display_->streamInfo->height_ = 480; // 480:picture height
550 display_->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
551 display_->streamInfo->dataspace_ = 8; // 8:picture dataspace
552 display_->streamInfo->intent_ = PREVIEW;
553 display_->streamInfo->tunneledMode_ = 5; // 5:tunnel mode
554 display_->streamInfos.push_back(display_->streamInfo);
555 display_->rc = display_->streamOperator->CreateStreams(display_->streamInfos);
556 std::cout << "==========[test log] streamOperator->CreateStreams's RetCode = ";
557 std::cout << display_->rc << std::endl;
558 EXPECT_EQ(true, display_->rc == NO_ERROR);
559 std::cout << "==========[test log] CreateStreams success. " << std::endl;
560 display_->rc = display_->streamOperator->AttachBufferQueue(display_->streamInfo->streamId_, producer);
561 std::cout << "==========[test log] streamOperator->AttachBufferQueue's RetCode = " << display_->rc << std::endl;
562 EXPECT_EQ(true, display_->rc == NO_ERROR);
563 std::cout << "==========[test log] AttachBufferQueue success. " << std::endl;
564 sleep(3); // waiting 3s, prepare for detach bufferQueue.
565
566 display_->rc = display_->streamOperator->DetachBufferQueue(0);
567 std::cout << "==========[test log] streamOperator->DetachBufferQueue's RetCode = " << display_->rc << std::endl;
568 EXPECT_EQ(true, display_->rc != NO_ERROR);
569 if (display_->rc == NO_ERROR) {
570 std::cout << "==========[test log] DetachBufferQueue success. " << std::endl;
571 } else {
572 std::cout << "==========[test log] DetachBufferQueue fail, rc = " << display_->rc << std::endl;
573 }
574 // release stream
575 display_->streamIds = {DEFAULT_STREAM_ID};
576 display_->StopStream(display_->captureIds, display_->streamIds);
577 }