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 (cameraBase == nullptr)
24     cameraBase = std::make_shared<TestCameraBase>();
25     cameraBase->FBInit();
26     cameraBase->Init();
27 }
TearDown(void)28 void UtestHdiFuncTest::TearDown(void)
29 {
30     cameraBase->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     cameraBase->AchieveStreamOperator();
45     // Create data stream
46     cameraBase->intents = {PREVIEW};
47     cameraBase->StartStream(cameraBase->intents);
48     // Get preview
49     cameraBase->StartCapture(cameraBase->STREAM_ID_PREVIEW, cameraBase->CAPTURE_ID_PREVIEW, false, true);
50     // release stream
51     cameraBase->captureIds = {cameraBase->CAPTURE_ID_PREVIEW};
52     cameraBase->streamIds = {cameraBase->STREAM_ID_PREVIEW};
53     cameraBase->StopStream(cameraBase->captureIds, cameraBase->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     cameraBase->OpenCamera();
67     // Create and get streamOperator information
68     cameraBase->AchieveStreamOperator();
69     // start stream
70     cameraBase->intents = {PREVIEW};
71     cameraBase->StartStream(cameraBase->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     cameraBase->rc = cameraBase->streamOperator->Capture(captureId, captureInfo, true);
78     EXPECT_EQ(INVALID_ARGUMENT, cameraBase->rc);
79     if (cameraBase->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     cameraBase->AchieveStreamOperator();
100     // start stream
101     cameraBase->intents = {PREVIEW};
102     cameraBase->StartStream(cameraBase->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     cameraBase->rc = cameraBase->streamOperator->Capture(captureId, captureInfo, isStreaming);
110     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
111     if (cameraBase->rc == NO_ERROR) {
112         std::cout << "==========[test log] Capture success." << std::endl;
113     } else {
114         std::cout << "==========[test log] Capture fail, rc = " << cameraBase->rc << std::endl;
115     }
116     sleep(3); // waiting function Capture execute for 3s.
117     cameraBase->rc = cameraBase->streamOperator->CancelCapture(captureId);
118     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
119     if (cameraBase->rc == NO_ERROR) {
120         std::cout << "==========[test log] CancelCapture success." << std::endl;
121     } else {
122         std::cout << "==========[test log] CancelCapture fail, rc = " << cameraBase->rc << std::endl;
123     }
124     cameraBase->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     cameraBase->AchieveStreamOperator();
141     // start stream
142     cameraBase->intents = {PREVIEW};
143     cameraBase->StartStream(cameraBase->intents);
144     // Get preview
145     cameraBase->StartCapture(cameraBase->STREAM_ID_PREVIEW, cameraBase->CAPTURE_ID_PREVIEW, false, true);
146     // release stream
147     cameraBase->captureIds = {cameraBase->CAPTURE_ID_PREVIEW};
148     cameraBase->streamIds = {cameraBase->STREAM_ID_PREVIEW};
149     cameraBase->StopStream(cameraBase->captureIds, cameraBase->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     cameraBase->AchieveStreamOperator();
165     // start stream
166     cameraBase->intents = {PREVIEW};
167     cameraBase->StartStream(cameraBase->intents);
168     // Get preview
169     int captureId = 2001;
170     std::shared_ptr<CaptureInfo> captureInfo = std::make_shared<CaptureInfo>();
171     captureInfo->streamIds_ = {cameraBase->STREAM_ID_PREVIEW};
172     captureInfo->enableShutterCallback_ = true;
173     cameraBase->rc = cameraBase->streamOperator->Capture(captureId, captureInfo, false);
174     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
175     sleep(3); // waiting 3s, prepare for execute function CancelCapture
176     cameraBase->streamOperator->CancelCapture(captureId);
177     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
178     if (cameraBase->rc == NO_ERROR) {
179         std::cout << "==========[test log] CancelCapture success." << std::endl;
180     } else {
181         std::cout << "==========[test log] CancelCapture fail, rc = " << cameraBase->rc << std::endl;
182     }
183     // release stream
184     cameraBase->rc = cameraBase->streamOperator->ReleaseStreams(captureInfo->streamIds_);
185     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
186     if (cameraBase->rc == NO_ERROR) {
187         std::cout << "==========[test log] ReleaseStreams success." << std::endl;
188     } else {
189         std::cout << "==========[test log] ReleaseStreams fail, rc = " << cameraBase->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     cameraBase->OpenCamera();
204     // Create and get streamOperator information
205     cameraBase->AchieveStreamOperator();
206     // start stream
207     cameraBase->intents = {PREVIEW};
208     cameraBase->StartStream(cameraBase->intents);
209     // Get preview
210     int captureId = -1;
211     std::shared_ptr<CaptureInfo> captureInfo = std::make_shared<CaptureInfo>();
212     captureInfo->streamIds_ = {cameraBase->STREAM_ID_PREVIEW};
213     captureInfo->enableShutterCallback_ = false;
214     bool isStreaming = true;
215     cameraBase->rc = cameraBase->streamOperator->Capture(captureId, captureInfo, isStreaming);
216     EXPECT_EQ(INVALID_ARGUMENT, cameraBase->rc);
217     if (cameraBase->rc == NO_ERROR) {
218         std::cout << "==========[test log] Capture success." << std::endl;
219     } else {
220         std::cout << "==========[test log] Capture fail, rc = " << cameraBase->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     cameraBase->AchieveStreamOperator();
238     // start stream
239     cameraBase->intents = {PREVIEW};
240     cameraBase->StartStream(cameraBase->intents);
241     // Get preview
242     cameraBase->StartCapture(cameraBase->STREAM_ID_PREVIEW, cameraBase->CAPTURE_ID_PREVIEW, true, true);
243     // release stream
244     cameraBase->captureIds = {cameraBase->CAPTURE_ID_PREVIEW};
245     cameraBase->streamIds = {cameraBase->STREAM_ID_PREVIEW};
246     cameraBase->StopStream(cameraBase->captureIds, cameraBase->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     cameraBase->AchieveStreamOperator();
261     // start stream
262     cameraBase->intents = {PREVIEW};
263     cameraBase->StartStream(cameraBase->intents);
264     // Get preview
265     cameraBase->StartCapture(cameraBase->STREAM_ID_PREVIEW, cameraBase->CAPTURE_ID_PREVIEW, false, true);
266     // release stream
267     cameraBase->captureIds = {cameraBase->CAPTURE_ID_PREVIEW};
268     cameraBase->streamIds = {cameraBase->STREAM_ID_PREVIEW};
269     cameraBase->StopStream(cameraBase->captureIds, cameraBase->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     cameraBase->AchieveStreamOperator();
284     // start stream
285     cameraBase->intents = {PREVIEW};
286     cameraBase->StartStream(cameraBase->intents);
287     // Get preview
288     int captureId = 100;
289     std::shared_ptr<CaptureInfo> captureInfo = std::make_shared<CaptureInfo>();
290     captureInfo->streamIds_ = {cameraBase->STREAM_ID_PREVIEW};
291     captureInfo->enableShutterCallback_ = false;
292     bool isStreaming = true;
293     cameraBase->rc = cameraBase->streamOperator->Capture(captureId, captureInfo, isStreaming);
294     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
295     sleep(3); // waiting 3s, prepare for execute function CancelCapture
296     cameraBase->rc = cameraBase->streamOperator->CancelCapture(-1);
297     EXPECT_EQ(INVALID_ARGUMENT, cameraBase->rc);
298     cameraBase->rc = cameraBase->streamOperator->CancelCapture(captureId);
299     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
300     if (cameraBase->rc == NO_ERROR) {
301         std::cout << "==========[test log] CancelCapture success." << std::endl;
302     } else {
303         std::cout << "==========[test log] CancelCapture fail, rc = " << cameraBase->rc << std::endl;
304     }
305     // release stream
306     cameraBase->rc = cameraBase->streamOperator->ReleaseStreams(captureInfo->streamIds_);
307     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
308     if (cameraBase->rc == NO_ERROR) {
309         std::cout << "==========[test log] ReleaseStreams success." << std::endl;
310     } else {
311         std::cout << "==========[test log] ReleaseStreams fail, rc = " << cameraBase->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     cameraBase->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         cameraBase->BufferCallback(b, cameraBase->preview_mode);
334         return;
335     };
336     producer->SetCallback(callback);
337 
338     cameraBase->streamInfo = std::make_shared<StreamInfo>();
339     cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID;
340     cameraBase->streamInfo->width_ = 640; // 640:picture width
341     cameraBase->streamInfo->height_ = 480; // 480:picture height
342     cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
343     cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace
344     cameraBase->streamInfo->intent_ = PREVIEW;
345     cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode
346     cameraBase->streamInfos.push_back(cameraBase->streamInfo);
347     cameraBase->rc = cameraBase->streamOperator->CreateStreams(cameraBase->streamInfos);
348     std::cout << "==========[test log] streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl;
349     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
350     if (cameraBase->rc == NO_ERROR) {
351         std::cout << "==========[test log] CreateStreams success." << std::endl;
352     } else {
353         std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl;
354     }
355     cameraBase->rc = cameraBase->streamOperator->AttachBufferQueue(cameraBase->streamInfo->streamId_, producer);
356     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
357     if (cameraBase->rc == NO_ERROR) {
358         std::cout << "==========[test log] AttachBufferQueue success. " << std::endl;
359     } else {
360         std::cout << "==========[test log] AttachBufferQueue fail, rc = " << cameraBase->rc << std::endl;
361     }
362     sleep(3); // waiting 3s, prepare for release stream.
363     // release stream
364     cameraBase->streamIds = {DEFAULT_STREAM_ID};
365     cameraBase->StopStream(cameraBase->captureIds, cameraBase->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     cameraBase->AchieveStreamOperator();
379     // Create data stream
380     cameraBase->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         cameraBase->BufferCallback(b, cameraBase->preview_mode);
388         return;
389     };
390     producer->SetCallback(callback);
391     cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID;
392     cameraBase->streamInfo->width_ = 640; // 640:picture width
393     cameraBase->streamInfo->height_ = 480; // 480:picture height
394     cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
395     cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace
396     cameraBase->streamInfo->intent_ = PREVIEW;
397     cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode
398     cameraBase->streamInfos.push_back(cameraBase->streamInfo);
399     cameraBase->rc = cameraBase->streamOperator->CreateStreams(cameraBase->streamInfos);
400     std::cout << "==========[test log] streamOperator->CreateStreams's RetCode = " << cameraBase->rc << std::endl;
401     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
402     if (cameraBase->rc == NO_ERROR) {
403         std::cout << "==========[test log] CreateStreams success." << std::endl;
404     } else {
405         std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl;
406     }
407     cameraBase->rc = cameraBase->streamOperator->AttachBufferQueue(0, producer);
408     EXPECT_EQ(true, cameraBase->rc != NO_ERROR);
409     if (cameraBase->rc == NO_ERROR) {
410         std::cout << "==========[test log] AttachBufferQueue success. " << std::endl;
411     } else {
412         std::cout << "==========[test log] AttachBufferQueue fail, rc = " << cameraBase->rc << std::endl;
413     }
414     sleep(3); // waiting 3s, prepare for release stream.
415     // Release the stream
416     cameraBase->streamIds = {DEFAULT_STREAM_ID};
417     cameraBase->StopStream(cameraBase->captureIds, cameraBase->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     cameraBase->AchieveStreamOperator();
431     if (cameraBase->rc == NO_ERROR) {
432         std::cout << "==========[test log] GetStreamOperator success. " << std::endl;
433     } else {
434         std::cout << "==========[test log] GetStreamOperator fail, rc = " << cameraBase->rc << std::endl;
435     }
436     // Create data stream
437     cameraBase->streamInfo = std::make_shared<StreamInfo>();
438     cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID;
439     cameraBase->streamInfo->width_ = 640; // 640:picture width
440     cameraBase->streamInfo->height_ = 480; // 480:picture height
441     cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
442     cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace
443     cameraBase->streamInfo->intent_ = PREVIEW;
444     cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode
445     cameraBase->streamInfos.push_back(cameraBase->streamInfo);
446     cameraBase->rc = cameraBase->streamOperator->CreateStreams(cameraBase->streamInfos);
447     std::cout << "==========[test log] streamOperator->CreateStreams's RetCode = ";
448     std::cout << cameraBase->rc << std::endl;
449     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
450     if (cameraBase->rc == NO_ERROR) {
451         std::cout << "==========[test log] CreateStreams success. " << std::endl;
452     } else {
453         std::cout << "==========[test log] CreateStreams fail, rc = " << cameraBase->rc << std::endl;
454     }
455     cameraBase->rc = cameraBase->streamOperator->AttachBufferQueue(cameraBase->streamInfo->streamId_, nullptr);
456     EXPECT_EQ(true, cameraBase->rc != NO_ERROR);
457     if (cameraBase->rc == NO_ERROR) {
458         std::cout << "==========[test log] AttachBufferQueue success. " << std::endl;
459     } else {
460         std::cout << "==========[test log] AttachBufferQueue fail, rc = " << cameraBase->rc << std::endl;
461     }
462     sleep(3); // waiting 3s, prepare for release stream.
463     // release stream
464     cameraBase->streamIds = {DEFAULT_STREAM_ID};
465     cameraBase->StopStream(cameraBase->captureIds, cameraBase->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     cameraBase->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         cameraBase->BufferCallback(b, cameraBase->preview_mode);
487         return;
488     };
489     producer->SetCallback(callback);
490     cameraBase->streamInfo = std::make_shared<StreamInfo>();
491     cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID;
492     cameraBase->streamInfo->width_ = 640; // 640:picture width
493     cameraBase->streamInfo->height_ = 480; // 480:picture height
494     cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
495     cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace
496     cameraBase->streamInfo->intent_ = PREVIEW;
497     cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode
498     cameraBase->streamInfos.push_back(cameraBase->streamInfo);
499     cameraBase->rc = cameraBase->streamOperator->CreateStreams(cameraBase->streamInfos);
500     std::cout << "==========[test log] streamOperator->CreateStreams's RetCode = ";
501     std::cout << cameraBase->rc << std::endl;
502     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
503     std::cout << "==========[test log] CreateStreams success. " << std::endl;
504     cameraBase->rc = cameraBase->streamOperator->AttachBufferQueue(cameraBase->streamInfo->streamId_, producer);
505     std::cout << "==========[test log] streamOperator->AttachBufferQueue's RetCode = ";
506     std::cout << cameraBase->rc << std::endl;
507     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
508     sleep(3); // waiting 3s, prepare for attach bufferQueue.
509     std::cout << "==========[test log] AttachBufferQueue success. " << std::endl;
510     cameraBase->rc = cameraBase->streamOperator->DetachBufferQueue(cameraBase->streamInfo->streamId_);
511     std::cout << "==========[test log] streamOperator->DetachBufferQueue's RetCode = ";
512     std::cout << cameraBase->rc << std::endl;
513     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
514     if (cameraBase->rc == NO_ERROR) {
515         std::cout << "==========[test log] DetachBufferQueue success. " << std::endl;
516     } else {
517         std::cout << "==========[test log] DetachBufferQueue fail, rc = " << cameraBase->rc << std::endl;
518     }
519     // release stream
520     cameraBase->streamIds = {DEFAULT_STREAM_ID};
521     cameraBase->StopStream(cameraBase->captureIds, cameraBase->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     cameraBase->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         cameraBase->BufferCallback(b, cameraBase->preview_mode);
543         return;
544     };
545     producer->SetCallback(callback);
546     cameraBase->streamInfo = std::make_shared<StreamInfo>();
547     cameraBase->streamInfo->streamId_ = DEFAULT_STREAM_ID;
548     cameraBase->streamInfo->width_ = 640; // 640:picture width
549     cameraBase->streamInfo->height_ = 480; // 480:picture height
550     cameraBase->streamInfo->format_ = CAMERA_FORMAT_YUYV_422_PKG;
551     cameraBase->streamInfo->dataspace_ = 8; // 8:picture dataspace
552     cameraBase->streamInfo->intent_ = PREVIEW;
553     cameraBase->streamInfo->tunneledMode_ = 5; // 5:tunnel mode
554     cameraBase->streamInfos.push_back(cameraBase->streamInfo);
555     cameraBase->rc = cameraBase->streamOperator->CreateStreams(cameraBase->streamInfos);
556     std::cout << "==========[test log] streamOperator->CreateStreams's RetCode = ";
557     std::cout << cameraBase->rc << std::endl;
558     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
559     std::cout << "==========[test log] CreateStreams success. " << std::endl;
560     cameraBase->rc = cameraBase->streamOperator->AttachBufferQueue(cameraBase->streamInfo->streamId_, producer);
561     std::cout << "==========[test log] streamOperator->AttachBufferQueue's RetCode = " << cameraBase->rc << std::endl;
562     EXPECT_EQ(true, cameraBase->rc == NO_ERROR);
563     std::cout << "==========[test log] AttachBufferQueue success. " << std::endl;
564     sleep(3); // waiting 3s, prepare for detach bufferQueue.
565 
566     cameraBase->rc = cameraBase->streamOperator->DetachBufferQueue(0);
567     std::cout << "==========[test log] streamOperator->DetachBufferQueue's RetCode = " << cameraBase->rc << std::endl;
568     EXPECT_EQ(true, cameraBase->rc != NO_ERROR);
569     if (cameraBase->rc == NO_ERROR) {
570         std::cout << "==========[test log] DetachBufferQueue success. " << std::endl;
571     } else {
572         std::cout << "==========[test log] DetachBufferQueue fail, rc = " << cameraBase->rc << std::endl;
573     }
574     // release stream
575     cameraBase->streamIds = {DEFAULT_STREAM_ID};
576     cameraBase->StopStream(cameraBase->captureIds, cameraBase->streamIds);
577 }
578