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