1 /*
2 * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file expected in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "hdi_stream_uttest.h"
16
17 using namespace OHOS;
18 using namespace std;
19 using namespace testing::ext;
20 using namespace OHOS::Camera;
21
SetUpTestCase(void)22 void HdiStreamUtTest::SetUpTestCase(void) {}
TearDownTestCase(void)23 void HdiStreamUtTest::TearDownTestCase(void) {}
SetUp(void)24 void HdiStreamUtTest::SetUp(void)
25 {
26 cameraTest = std::make_shared<OHOS::Camera::Test>();
27 cameraTest->Init();
28 }
29
TearDown(void)30 void HdiStreamUtTest::TearDown(void)
31 {
32 cameraTest->Close();
33 }
34
35 /**
36 * @tc.name: IsStreamSupported
37 * @tc.desc: IsStreamSupported, normal cameraId
38 * @tc.size: MediumTest
39 * @tc.type: Function
40 */
41 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_3300, TestSize.Level0)
42 {
43 cameraTest->Open();
44 EXPECT_EQ(false, cameraTest->cameraDevice == nullptr);
45 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
46 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
47 cameraTest->streamOperator);
48 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
49 std::shared_ptr<CameraMetadata> modeSetting = std::make_shared<CameraMetadata>(2, 128);
50 int64_t expoTime = 0;
51 modeSetting->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &expoTime, 1);
52 int64_t colorGains[4] = {0};
53 modeSetting->addEntry(OHOS_SENSOR_COLOR_CORRECTION_GAINS, &colorGains, 4);
54
55 cameraTest->streamInfo = std::make_shared<StreamInfo>();
56 cameraTest->streamInfo->streamId_ = 101;
57 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
58 cameraTest->streamInfo->height_ = 480;
59 cameraTest->streamInfo->width_ = 640;
60 cameraTest->streamInfo->dataspace_ = 8;
61
62 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
63 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10102(void* addr, uint32_t size) 64 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
65 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
66 });
67
68 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(8);
69 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
70 cameraTest->streamInfo->intent_ = PREVIEW;
71 cameraTest->streamInfo->tunneledMode_ = 5;
72 StreamSupportType pType;
73 std::vector<StreamInfo> streams;
74 streams.push_back(*cameraTest->streamInfo);
75 std::vector<uint8_t> modeSettingVec;
76 MetadataUtils::ConvertMetadataToVec(modeSetting, modeSettingVec);
77 cameraTest->rc = cameraTest->streamOperator->IsStreamsSupported(OperationMode::NORMAL, modeSettingVec,
78 streams, pType);
79 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
80 #if defined DISPLAY_COMMUNITY
81 EXPECT_EQ(true, pType ==HDI::Camera::V1_0::DYNAMIC_SUPPORTED);
82 #else
83 EXPECT_NE(true, pType ==HDI::Camera::V1_0::DYNAMIC_SUPPORTED);
84 #endif
85 }
86
87 /**
88 * @tc.name: CreateStreams
89 * @tc.desc: CreateStreams, success
90 * @tc.size: MediumTest
91 * @tc.type: Function
92 */
93 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_3400, TestSize.Level0)
94 {
95 cameraTest->Open();
96 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
97 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
98 cameraTest->streamOperator);
99 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
100
101 cameraTest->streamInfo = std::make_shared<StreamInfo>();
102 cameraTest->streamInfo->streamId_ = 101;
103 cameraTest->streamInfo->width_ = 640;
104 cameraTest->streamInfo->height_ = 480;
105 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
106 cameraTest->streamInfo->dataspace_ = 8;
107 cameraTest->streamInfo->intent_ = PREVIEW;
108 cameraTest->streamInfo->tunneledMode_ = 5;
109
110 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
111 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10202(void* addr, uint32_t size) 112 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
113 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
114 });
115
116 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
117 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
118 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
119 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
120
121 std::vector<int> streamIds;
122 streamIds.push_back(cameraTest->streamInfo->streamId_);
123 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams(streamIds);
124 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
125 }
126
127 /**
128 * @tc.name: CreateStreams
129 * @tc.desc: CreateStreams, StreamInfo->streamId = -1, return error
130 * @tc.size: MediumTest
131 * @tc.type: Function
132 */
133 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_3500, TestSize.Level0)
134 {
135 cameraTest->Open();
136 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
137 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
138 cameraTest->streamOperator);
139 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
140
141 cameraTest->streamInfo = std::make_shared<StreamInfo>();
142 cameraTest->streamInfo->streamId_ = -1;
143 cameraTest->streamInfo->width_ = 640;
144 cameraTest->streamInfo->height_ = 480;
145 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
146 cameraTest->streamInfo->dataspace_ = 8;
147 cameraTest->streamInfo->intent_ = PREVIEW;
148 cameraTest->streamInfo->tunneledMode_ = 5;
149
150 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
151 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10302(void* addr, uint32_t size) 152 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
153 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
154 });
155
156 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
157 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
158 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
159 EXPECT_EQ(cameraTest->rc, INVALID_ARGUMENT);
160 }
161
162 /**
163 * @tc.name: CreateStreams
164 * @tc.desc: CreateStreams, StreamInfo->streamId = 2147483391, success
165 * @tc.size: MediumTest
166 * @tc.type: Function
167 */
168 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_3600, TestSize.Level0)
169 {
170 cameraTest->Open();
171 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
172 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
173 cameraTest->streamOperator);
174 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
175
176 cameraTest->streamInfo = std::make_shared<StreamInfo>();
177 cameraTest->streamInfo->streamId_ = 2147483391;
178 cameraTest->streamInfo->width_ = 640;
179 cameraTest->streamInfo->height_ = 480;
180 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
181 cameraTest->streamInfo->dataspace_ = 8;
182 cameraTest->streamInfo->intent_ = PREVIEW;
183 cameraTest->streamInfo->tunneledMode_ = 5;
184
185 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
186 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10402(void* addr, uint32_t size) 187 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
188 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
189 });
190
191 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
192 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
193 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
194 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
195
196 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamInfo->streamId_});
197 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
198 }
199
200 /**
201 * @tc.name: CreateStreams
202 * @tc.desc: CreateStreams, StreamInfo->width = -1, return error
203 * @tc.size: MediumTest
204 * @tc.type: Function
205 */
206 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_3700, TestSize.Level0)
207 {
208 cameraTest->Open();
209 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
210 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
211 cameraTest->streamOperator);
212 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
213
214 cameraTest->streamInfo = std::make_shared<StreamInfo>();
215 cameraTest->streamInfo->streamId_ = 101;
216 cameraTest->streamInfo->width_ = -1;
217 cameraTest->streamInfo->height_ = 640;
218 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
219 cameraTest->streamInfo->dataspace_ = 8;
220 cameraTest->streamInfo->intent_ = PREVIEW;
221 cameraTest->streamInfo->tunneledMode_ = 5;
222
223 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
224 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10502(void* addr, uint32_t size) 225 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
226 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
227 });
228
229 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
230 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
231 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
232 EXPECT_EQ(cameraTest->rc, INVALID_ARGUMENT);
233 }
234
235 /**
236 * @tc.name: CreateStreams
237 * @tc.desc: CreateStreams, StreamInfo->width = 2147483647, success
238 * @tc.size: MediumTest
239 * @tc.type: Function
240 */
241 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_3800, TestSize.Level0)
242 {
243 cameraTest->Open();
244 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
245 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
246 cameraTest->streamOperator);
247 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
248
249 cameraTest->streamInfo = std::make_shared<StreamInfo>();
250 cameraTest->streamInfo->streamId_ = 101;
251 cameraTest->streamInfo->width_ = 2147483647;
252 cameraTest->streamInfo->height_ = 640;
253 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
254 cameraTest->streamInfo->dataspace_ = 8;
255 cameraTest->streamInfo->intent_ = PREVIEW;
256 cameraTest->streamInfo->tunneledMode_ = 5;
257
258 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
259 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10602(void* addr, uint32_t size) 260 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
261 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
262 });
263
264 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(8);
265 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
266 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
267 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
268 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
269
270 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamInfo->streamId_});
271 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
272 }
273
274 /**
275 * @tc.name: CreateStreams
276 * @tc.desc: CreateStreams, StreamInfo->height = -1, success
277 * @tc.size: MediumTest
278 * @tc.type: Function
279 */
280 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_3900, TestSize.Level0)
281 {
282 cameraTest->Open();
283 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
284 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
285 cameraTest->streamOperator);
286 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
287
288 cameraTest->streamInfo = std::make_shared<StreamInfo>();
289 cameraTest->streamInfo->streamId_ = 101;
290 cameraTest->streamInfo->width_ = 1920;
291 cameraTest->streamInfo->height_ = -1;
292 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
293 cameraTest->streamInfo->dataspace_ = 8;
294 cameraTest->streamInfo->intent_ = PREVIEW;
295 cameraTest->streamInfo->tunneledMode_ = 5;
296
297 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
298 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10702(void* addr, uint32_t size) 299 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
300 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
301 });
302
303 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(8);
304 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
305 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
306 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
307 EXPECT_EQ(cameraTest->rc, INVALID_ARGUMENT);
308 }
309
310 /**
311 * @tc.name: CreateStreams
312 * @tc.desc: CreateStreams, StreamInfo->height = 2147483647, success
313 * @tc.size: MediumTest
314 * @tc.type: Function
315 */
316 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_4000, TestSize.Level0)
317 {
318 cameraTest->Open();
319 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
320 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
321 cameraTest->streamOperator);
322 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
323
324 cameraTest->streamInfo = std::make_shared<StreamInfo>();
325 cameraTest->streamInfo->streamId_ = 101;
326 cameraTest->streamInfo->width_ = 1920;
327 cameraTest->streamInfo->height_ = 2147483647;
328 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
329 cameraTest->streamInfo->dataspace_ = 8;
330 cameraTest->streamInfo->intent_ = PREVIEW;
331 cameraTest->streamInfo->tunneledMode_ = 5;
332
333 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
334 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10802(void* addr, uint32_t size) 335 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
336 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
337 });
338
339 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(8);
340 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
341 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
342 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
343 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
344
345 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamInfo->streamId_});
346 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
347 }
348
349 /**
350 * @tc.name: CreateStreams
351 * @tc.desc: CreateStreams, StreamInfo->format = 2147483647, success
352 * @tc.size: MediumTest
353 * @tc.type: Function
354 */
355 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_4100, TestSize.Level0)
356 {
357 cameraTest->Open();
358 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
359 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
360 cameraTest->streamOperator);
361 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
362
363 cameraTest->streamInfo = std::make_shared<StreamInfo>();
364 cameraTest->streamInfo->streamId_ = 101;
365 cameraTest->streamInfo->width_ = 1920;
366 cameraTest->streamInfo->height_ = 1080;
367 cameraTest->streamInfo->format_ = 2147483647;
368 cameraTest->streamInfo->dataspace_ = 8;
369 cameraTest->streamInfo->intent_ = PREVIEW;
370 cameraTest->streamInfo->tunneledMode_ = 5;
371
372 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
373 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10902(void* addr, uint32_t size) 374 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
375 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
376 });
377
378 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(8);
379 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
380 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
381 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
382 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
383
384 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamInfo->streamId_});
385 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
386 }
387
388 /**
389 * @tc.name: CreateStreams
390 * @tc.desc: CreateStreams, StreamInfo->dataspace = 2147483647, success
391 * @tc.size: MediumTest
392 * @tc.type: Function
393 */
394 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_4200, TestSize.Level0)
395 {
396 cameraTest->Open();
397 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
398 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
399 cameraTest->streamOperator);
400 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
401
402 cameraTest->streamInfo = std::make_shared<StreamInfo>();
403 cameraTest->streamInfo->streamId_ = 101;
404 cameraTest->streamInfo->width_ = 1920;
405 cameraTest->streamInfo->height_ = 1080;
406 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
407 cameraTest->streamInfo->dataspace_ = 2147483647;
408 cameraTest->streamInfo->intent_ = PREVIEW;
409 cameraTest->streamInfo->tunneledMode_ = 5;
410
411 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
412 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10a02(void* addr, uint32_t size) 413 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
414 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
415 });
416
417 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(8);
418 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
419 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
420 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
421 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
422
423 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamInfo->streamId_});
424 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
425 }
426
427 /**
428 * @tc.name: CreateStreams
429 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = PREVIEW, success
430 * @tc.size: MediumTest
431 * @tc.type: Function
432 */
433 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_4300, TestSize.Level0)
434 {
435 cameraTest->Open();
436 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
437 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
438 cameraTest->streamOperator);
439 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
440
441 cameraTest->streamInfo = std::make_shared<StreamInfo>();
442 cameraTest->streamInfo->streamId_ = 101;
443 cameraTest->streamInfo->width_ = 1920;
444 cameraTest->streamInfo->height_ = 1080;
445 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
446 cameraTest->streamInfo->dataspace_ = 8;
447 cameraTest->streamInfo->intent_ = PREVIEW;
448 cameraTest->streamInfo->tunneledMode_ = 5;
449
450 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
451 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10b02(void* addr, uint32_t size) 452 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
453 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
454 });
455
456 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
457 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
458 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
459 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
460
461 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamInfo->streamId_});
462 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
463 }
464
465 /**
466 * @tc.name: CreateStreams
467 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = VIDEO, success
468 * @tc.size: MediumTest
469 * @tc.type: Function
470 */
471 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_4400, TestSize.Level0)
472 {
473 cameraTest->Open();
474 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
475 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
476 cameraTest->streamOperator);
477 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
478
479 cameraTest->streamInfo = std::make_shared<StreamInfo>();
480 cameraTest->streamInfo->streamId_ = 101;
481 cameraTest->streamInfo->width_ = 1920;
482 cameraTest->streamInfo->height_ = 1080;
483 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
484 cameraTest->streamInfo->dataspace_ = 8;
485 cameraTest->streamInfo->intent_ = VIDEO;
486 cameraTest->streamInfo->tunneledMode_ = 5;
487 cameraTest->streamInfo->encodeType_ = ENCODE_TYPE_H265;
488
489 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
490 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10c02(void* addr, uint32_t size) 491 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
492 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
493 });
494
495 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(8);
496 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
497 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
498 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
499 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
500
501 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamInfo->streamId_});
502 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
503 }
504
505 /**
506 * @tc.name: CreateStreams
507 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = STILL_CAPTURE, success
508 * @tc.size: MediumTest
509 * @tc.type: Function
510 */
511 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_4500, TestSize.Level0)
512 {
513 cameraTest->Open();
514 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
515 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
516 cameraTest->streamOperator);
517 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
518
519 cameraTest->streamInfo = std::make_shared<StreamInfo>();
520 cameraTest->streamInfo->streamId_ = 101;
521 cameraTest->streamInfo->width_ = 1920;
522 cameraTest->streamInfo->height_ = 1080;
523 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
524 cameraTest->streamInfo->dataspace_ = 8;
525 cameraTest->streamInfo->intent_ = STILL_CAPTURE;
526 cameraTest->streamInfo->tunneledMode_ = 5;
527 cameraTest->streamInfo->encodeType_ = ENCODE_TYPE_NULL;
528
529 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
530 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10d02(void* addr, uint32_t size) 531 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
532 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
533 });
534
535 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(8);
536 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
537 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
538 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
539 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
540
541 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamInfo->streamId_});
542 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
543 }
544
545 /**
546 * @tc.name: CreateStreams
547 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = POST_VIEW, success
548 * @tc.size: MediumTest
549 * @tc.type: Function
550 */
551 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_4600, TestSize.Level0)
552 {
553 cameraTest->Open();
554 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
555 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
556 cameraTest->streamOperator);
557 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
558
559 cameraTest->streamInfo = std::make_shared<StreamInfo>();
560 cameraTest->streamInfo->streamId_ = 101;
561 cameraTest->streamInfo->width_ = 1920;
562 cameraTest->streamInfo->height_ = 1080;
563 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
564 cameraTest->streamInfo->dataspace_ = 8;
565 cameraTest->streamInfo->intent_ = POST_VIEW;
566 cameraTest->streamInfo->tunneledMode_ = 5;
567
568 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
569 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10e02(void* addr, uint32_t size) 570 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
571 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
572 });
573
574 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(8);
575 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
576 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
577 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
578 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
579
580 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamInfo->streamId_});
581 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
582 }
583
584 /**
585 * @tc.name: CreateStreams
586 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = StreamIntent::ANALYZE, success
587 * @tc.size: MediumTest
588 * @tc.type: Function
589 */
590 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_4700, TestSize.Level0)
591 {
592 cameraTest->Open();
593 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
594 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
595 cameraTest->streamOperator);
596 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
597
598 cameraTest->streamInfo = std::make_shared<StreamInfo>();
599 cameraTest->streamInfo->streamId_ = 101;
600 cameraTest->streamInfo->width_ = 1920;
601 cameraTest->streamInfo->height_ = 1080;
602 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
603 cameraTest->streamInfo->dataspace_ = 8;
604 cameraTest->streamInfo->intent_ = StreamIntent::ANALYZE;
605 cameraTest->streamInfo->tunneledMode_ = 5;
606
607 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
608 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea10f02(void* addr, uint32_t size) 609 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
610 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
611 });
612
613 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(8);
614 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
615 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
616 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
617 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
618
619 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamInfo->streamId_});
620 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
621 }
622
623 /**
624 * @tc.name: CreateStreams
625 * @tc.desc: CreateStreams, StreamInfo->StreamIntent = PREVIEW, success
626 * @tc.size: MediumTest
627 * @tc.type: Function
628 */
629 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_4800, TestSize.Level0)
630 {
631 cameraTest->Open();
632 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
633 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
634 cameraTest->streamOperator);
635 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
636
637 cameraTest->streamInfo = std::make_shared<StreamInfo>();
638 cameraTest->streamInfo->streamId_ = 101;
639 cameraTest->streamInfo->width_ = 1920;
640 cameraTest->streamInfo->height_ = 1080;
641 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
642 cameraTest->streamInfo->dataspace_ = 8;
643 cameraTest->streamInfo->intent_ = PREVIEW;
644 cameraTest->streamInfo->tunneledMode_ = 5;
645
646 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
647 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea11002(void* addr, uint32_t size) 648 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
649 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
650 });
651
652 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(8);
653 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
654 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
655 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
656 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
657
658 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamInfo->streamId_});
659 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
660 }
661
662 /**
663 * @tc.name: startStream, stopStream
664 * @tc.desc: startStream, stopStream
665 * @tc.size: MediumTest
666 * @tc.type: Function
667 */
668 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_4900, TestSize.Level0)
669 {
670 cameraTest->Open();
671 cameraTest->intents = {PREVIEW};
672 cameraTest->StartStream(cameraTest->intents);
673 cameraTest->captureIds = {};
674 cameraTest->streamIds = {cameraTest->streamIdPreview};
675 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
676 }
677
678 /**
679 * @tc.name: GetStreamAttributes
680 * @tc.desc: GetStreamAttributes, success
681 * @tc.size: MediumTest
682 * @tc.type: Function
683 */
684 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_5000, TestSize.Level0)
685 {
686 cameraTest->Open();
687 cameraTest->intents = {PREVIEW};
688 cameraTest->StartStream(cameraTest->intents);
689
690 std::vector<StreamAttribute> attributes;
691 cameraTest->rc = cameraTest->streamOperator->GetStreamAttributes(attributes);
692 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
693 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamIdPreview});
694 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
695 }
696
697 /**
698 * @tc.name: capture
699 * @tc.desc: capture, input normal
700 * @tc.size: MediumTest
701 * @tc.type: Function
702 */
703 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_5100, TestSize.Level0)
704 {
705 cameraTest->Open();
706 cameraTest->intents = {PREVIEW};
707 cameraTest->StartStream(cameraTest->intents);
708 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
709 cameraTest->captureIds = {cameraTest->captureIdPreview};
710 cameraTest->streamIds = {cameraTest->streamIdPreview};
711 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
712 }
713
714 /**
715 * @tc.name: capture
716 * @tc.desc: preview, capture->captureInfo->streamId = -1, return error
717 * @tc.size: MediumTest
718 * @tc.type: Function
719 */
720 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_5200, TestSize.Level0)
721 {
722 cameraTest->Open();
723 cameraTest->intents = {PREVIEW};
724 cameraTest->StartStream(cameraTest->intents);
725 int captureId = 2001;
726 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
727 cameraTest->captureInfo->streamIds_ = {-1};
728 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
729 cameraTest->captureInfo->enableShutterCallback_ = true;
730 cameraTest->rc = cameraTest->streamOperator->Capture(captureId, *cameraTest->captureInfo, true);
731 EXPECT_EQ(INVALID_ARGUMENT, cameraTest->rc);
732 sleep(1);
733 cameraTest->streamOperator->CancelCapture(captureId);
734 cameraTest->captureIds = {};
735 cameraTest->streamIds = {cameraTest->streamIdPreview};
736 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
737 }
738
739
740 /**
741 * @tc.name: capture
742 * @tc.desc: preview, capture->captureInfo->streamId = 65535, return success
743 * @tc.size: MediumTest
744 * @tc.type: Function
745 */
746 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_5300, TestSize.Level0)
747 {
748 cameraTest->Open();
749 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
750 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
751 cameraTest->streamOperator);
752 EXPECT_EQ(false, cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || cameraTest->streamOperator == nullptr);
753
754 cameraTest->streamInfo = std::make_shared<StreamInfo>();
755 cameraTest->streamInfo->streamId_ = 65535;
756 cameraTest->streamInfo->width_ = 1920;
757 cameraTest->streamInfo->height_ = 1080;
758 cameraTest->streamInfo->format_ = cameraTest->previewFormat;
759 cameraTest->streamInfo->dataspace_ = 8;
760 cameraTest->streamInfo->intent_ = PREVIEW;
761 cameraTest->streamInfo->tunneledMode_ = 5;
762
763 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
764 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea11102(void* addr, uint32_t size) 765 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
766 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
767 });
768
769 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(8);
770 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
771 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
772 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
773 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
774
775 cameraTest->rc = cameraTest->streamOperator->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
776 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
777 int captureId = 2001;
778 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
779 cameraTest->captureInfo->streamIds_ = {65535};
780 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
781 cameraTest->captureInfo->enableShutterCallback_ =true;
782 bool isStreaming = true;
783 cameraTest->rc = cameraTest->streamOperator->Capture(captureId, *cameraTest->captureInfo, isStreaming);
784 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
785 sleep(1);
786 cameraTest->streamOperator->CancelCapture(captureId);
787
788 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams(cameraTest->captureInfo->streamIds_);
789 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
790 cameraTest->cameraDevice->Close();
791 }
792
793 /**
794 * @tc.name: capture
795 * @tc.desc: preview, capture->captureId = -1, return error
796 * @tc.size: MediumTest
797 * @tc.type: Function
798 */
799 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_5400, TestSize.Level0)
800 {
801 cameraTest->Open();
802 cameraTest->intents = {PREVIEW};
803 cameraTest->StartStream(cameraTest->intents);
804
805 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
806 cameraTest->captureInfo->streamIds_ = {cameraTest->streamIdPreview};
807 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
808 cameraTest->captureInfo->enableShutterCallback_ = false;
809 bool isStreaming = true;
810 int captureId = -1;
811 cameraTest->rc = cameraTest->streamOperator->Capture(captureId, *cameraTest->captureInfo, isStreaming);
812 EXPECT_EQ(INVALID_ARGUMENT, cameraTest->rc);
813 sleep(1);
814 cameraTest->rc = cameraTest->streamOperator->CancelCapture(cameraTest->captureIdPreview);
815 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams({cameraTest->streamIdPreview});
816 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
817 }
818
819 /**
820 * @tc.name: capture
821 * @tc.desc: preview, capture->captureInfo->enableShutterCallback = true, return success
822 * @tc.size: MediumTest
823 * @tc.type: Function
824 */
825 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_5500, TestSize.Level0)
826 {
827 cameraTest->Open();
828 cameraTest->intents = {PREVIEW};
829 cameraTest->StartStream(cameraTest->intents);
830 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, true, true);
831
832 cameraTest->captureIds = {cameraTest->captureIdPreview};
833 cameraTest->streamIds = {cameraTest->streamIdPreview};
834 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
835 }
836
837 /**
838 * @tc.name: CancelCapture
839 * @tc.desc: CancelCapture captureId = -1
840 * @tc.size: MediumTest
841 * @tc.type: Function
842 */
843 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_5600, TestSize.Level0)
844 {
845 cameraTest->Open();
846 cameraTest->intents = {PREVIEW};
847 cameraTest->StartStream(cameraTest->intents);
848 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, true, true);
849 cameraTest->rc = cameraTest->streamOperator->CancelCapture(-1);
850 EXPECT_EQ(INVALID_ARGUMENT, cameraTest->rc);
851 cameraTest->captureIds = {cameraTest->captureIdPreview};
852 cameraTest->streamIds = {cameraTest->streamIdPreview};
853 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
854 }
855
856 /**
857 * @tc.name: AttachBufferQueue & DetachBufferQueue
858 * @tc.desc: AttachBufferQueue & DetachBufferQueue
859 * @tc.size: MediumTest
860 * @tc.type: Function
861 */
862 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_5800, TestSize.Level0)
863 {
864 cameraTest->Open();
865 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
866 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
867 cameraTest->streamOperator);
868
869 cameraTest->streamInfo = std::make_shared<StreamInfo>();
870 cameraTest->streamInfo->streamId_ = 101; // PREVIEW streamId
871 cameraTest->streamInfo->width_ = 720; // Pixel Width
872 cameraTest->streamInfo->height_ = 480; // Pixel height
873 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
874 cameraTest->streamInfo->dataspace_ = UT_DATA_SIZE;
875 cameraTest->streamInfo->intent_ = PREVIEW;
876 cameraTest->streamInfo->tunneledMode_ = UT_TUNNEL_MODE;
877 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
878 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea11202(void* addr, uint32_t size) 879 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
880 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
881 });
882
883 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
884 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
885 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
886
887 cameraTest->streamInfoSnapshot = std::make_shared<StreamInfo>();
888 cameraTest->streamInfoSnapshot->streamId_ = 102; // STILL_CAPTURE streamId
889 cameraTest->streamInfoSnapshot->width_ = 720; // Pixel Width
890 cameraTest->streamInfoSnapshot->height_ = 480; // Pixel height
891 cameraTest->streamInfoSnapshot->format_ = PIXEL_FMT_YCRCB_420_SP;
892 cameraTest->streamInfoSnapshot->dataspace_ = UT_DATA_SIZE;
893 cameraTest->streamInfoSnapshot->intent_ = STILL_CAPTURE;
894 cameraTest->streamInfoSnapshot->tunneledMode_ = UT_TUNNEL_MODE;
895 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> snapshotConsumer =
896 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
897 cameraTest->streamInfoSnapshot->bufferQueue_ = snapshotConsumer->CreateProducerSeq([this](void* addr,
__anon2461cea11302(void* addr, uint32_t size) 898 uint32_t size) {
899 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
900 });
901
902 cameraTest->streamInfoSnapshot->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
903 cameraTest->consumerMap_[cameraTest->streamInfoSnapshot->intent_] = snapshotConsumer;
904 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
905
906 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
907 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
908
909 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> preview_consumer =
910 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
911 OHOS::sptr<OHOS::IBufferProducer> producerTemp = preview_consumer->CreateProducer([this](void* addr,
__anon2461cea11402(void* addr, uint32_t size) 912 uint32_t size) {
913 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
914 });
915
916 OHOS::sptr<BufferProducerSequenceable> bufferQueue = new BufferProducerSequenceable(producerTemp);
917 cameraTest->rc = cameraTest->streamOperator->AttachBufferQueue(cameraTest->streamInfoSnapshot->streamId_,
918 bufferQueue);
919 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
920
921 cameraTest->rc = cameraTest->streamOperator->DetachBufferQueue(cameraTest->streamInfoSnapshot->streamId_);
922 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
923
924 std::vector<int> streamIds = {cameraTest->streamInfo->streamId_, cameraTest->streamInfoSnapshot->streamId_};
925 cameraTest->rc = cameraTest->streamOperator->ReleaseStreams(streamIds);
926 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
927 }
928
929 /**
930 * @tc.name: offlineStreamOperator
931 * @tc.desc: offlineStreamOperator, input normal
932 * @tc.size: MediumTest
933 * @tc.type: Function
934 */
935 HWTEST_F(HdiStreamUtTest, SUB_Driver_Camera_Merge_6100, TestSize.Level0)
936 {
937 cameraTest->Open();
938 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
939 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
940 cameraTest->streamOperator);
941
942 cameraTest->streamInfo = std::make_shared<StreamInfo>();
943 cameraTest->streamInfo->streamId_ = cameraTest->streamIdPreview;
944 cameraTest->streamInfo->width_ = 1920;
945 cameraTest->streamInfo->height_ = 1080;
946 cameraTest->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
947 cameraTest->streamInfo->dataspace_ = UT_DATA_SIZE;
948 cameraTest->streamInfo->intent_ = PREVIEW;
949 cameraTest->streamInfo->tunneledMode_ = UT_TUNNEL_MODE;
950 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
951 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea11502(void* addr, uint32_t size) 952 cameraTest->streamInfo->bufferQueue_ = consumer->CreateProducerSeq([this](void* addr, uint32_t size) {
953 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
954 });
955 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
956 cameraTest->consumerMap_[cameraTest->streamInfo->intent_] = consumer;
957 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
958
959 cameraTest->streamInfoSnapshot = std::make_shared<StreamInfo>();
960 cameraTest->streamInfoSnapshot->streamId_ = 102;
961 cameraTest->streamInfoSnapshot->width_ = 1920;
962 cameraTest->streamInfoSnapshot->height_ = 1080;
963 cameraTest->streamInfoSnapshot->format_ = PIXEL_FMT_YCRCB_420_SP;
964 cameraTest->streamInfoSnapshot->dataspace_ = UT_DATA_SIZE;
965 cameraTest->streamInfoSnapshot->intent_ = STILL_CAPTURE;
966 cameraTest->streamInfoSnapshot->tunneledMode_ = UT_TUNNEL_MODE;
967 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> snapshotConsumer =
968 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
969 cameraTest->streamInfoSnapshot->bufferQueue_ = snapshotConsumer->CreateProducerSeq([this](void* addr,
__anon2461cea11602(void* addr, uint32_t size) 970 uint32_t size) {
971 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
972 });
973 cameraTest->streamInfoSnapshot->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
974 cameraTest->consumerMap_[cameraTest->streamInfoSnapshot->intent_] = snapshotConsumer;
975 cameraTest->streamInfos.push_back(*cameraTest->streamInfoSnapshot);
976
977 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
978 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
979
980 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
981 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
982
983 int captureId = 2001;
984 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
985 cameraTest->captureInfo->streamIds_ = {102};
986 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
987 cameraTest->captureInfo->enableShutterCallback_ = true;
988 bool isStreaming = true;
989 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->Capture(captureId, *cameraTest->captureInfo, isStreaming);
990 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
991 sleep(UT_SECOND_TIMES);
992 OHOS::sptr<IStreamOperatorCallback> streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
993 OHOS::sptr<IOfflineStreamOperator> offlineStreamOperator = nullptr;
994
995 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->ChangeToOfflineStream({cameraTest->streamInfoSnapshot->streamId_},
996 streamOperatorCallback, offlineStreamOperator);
997 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
998
999 sleep(UT_SECOND_TIMES);
1000
1001 cameraTest->rc = (CamRetCode)offlineStreamOperator->CancelCapture(captureId);
1002
1003 EXPECT_EQ(true, cameraTest->rc == HDI::Camera::V1_0::NO_ERROR);
1004
1005 std::vector<int> streamIds = {102};
1006 cameraTest->rc = (CamRetCode)offlineStreamOperator->ReleaseStreams(streamIds);
1007 EXPECT_EQ(true, cameraTest->rc == HDI::Camera::V1_0::NO_ERROR);
1008
1009 cameraTest->rc = (CamRetCode)offlineStreamOperator->Release();
1010 EXPECT_EQ(true, cameraTest->rc == HDI::Camera::V1_0::NO_ERROR);
1011
1012 cameraTest->rc = (CamRetCode)cameraTest->streamOperator->ReleaseStreams({1201});
1013 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1014 sleep(UT_SECOND_TIMES);
1015 }
1016
1017 #ifdef DISPLAY_COMMUNITY
1018 /**
1019 * @tc.name: CAMERA_BUSY
1020 * @tc.desc: CAMERA_BUSY
1021 * @tc.level: Level1
1022 * @tc.size: MediumTest
1023 * @tc.type: Function
1024 */
1025 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_001, TestSize.Level1)
1026 {
1027 cameraTest->Open();
1028 cameraTest->intents = {PREVIEW};
1029 cameraTest->StartStream(cameraTest->intents);
1030 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1031 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> preview_consumer =
1032 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
1033 OHOS::sptr<OHOS::IBufferProducer> producerTemp = preview_consumer->CreateProducer([this](void* addr,
__anon2461cea11702(void* addr, uint32_t size) 1034 uint32_t size) {
1035 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
1036 });
1037
1038 OHOS::sptr<BufferProducerSequenceable> bufferProduder = new BufferProducerSequenceable(producerTemp);
1039 cameraTest->rc = cameraTest->streamOperator->AttachBufferQueue(cameraTest->streamIdPreview, bufferProduder);
1040 EXPECT_EQ(true, cameraTest->rc == CAMERA_BUSY);
1041 cameraTest->captureIds = {cameraTest->captureIdPreview};
1042 cameraTest->streamIds = {cameraTest->streamIdPreview};
1043 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1044 }
1045
1046 /**
1047 * @tc.name: DEVICE_ERROR
1048 * @tc.desc: DEVICE_ERROR
1049 * @tc.size: MediumTest
1050 * @tc.type: Function
1051 */
1052 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_002, TestSize.Level0)
1053 {
1054 cameraTest->Open();
1055 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
1056 cameraTest->rc = cameraTest->cameraDevice->GetStreamOperator(cameraTest->streamOperatorCallback,
1057 cameraTest->streamOperator);
1058
1059 cameraTest->streamInfo = std::make_shared<StreamInfo>();
1060 cameraTest->streamInfo->streamId_ = cameraTest->streamIdPreview;
1061 cameraTest->streamInfo->width_ = cameraTest->previewWidth;
1062 cameraTest->streamInfo->height_ = cameraTest->previewHeight;
1063 cameraTest->streamInfo->format_ = cameraTest->previewFormat;
1064 cameraTest->streamInfo->dataspace_ = UT_DATA_SIZE;
1065 cameraTest->streamInfo->intent_ = StreamIntent::PREVIEW;
1066 cameraTest->streamInfo->tunneledMode_ = UT_TUNNEL_MODE;
1067
1068 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer_pre =
1069 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon2461cea11802(void* addr, uint32_t size) 1070 cameraTest->streamInfo->bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) {
1071 cameraTest->DumpImageFile(cameraTest->streamIdPreview, "yuv", addr, size);
1072 });
1073 cameraTest->streamInfo->bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
1074 cameraTest->streamInfos.push_back(*cameraTest->streamInfo);
1075 cameraTest->rc = cameraTest->streamOperator->CreateStreams(cameraTest->streamInfos);
1076 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
1077
1078 cameraTest->captureInfo = std::make_shared<CaptureInfo>();
1079 cameraTest->captureInfo->streamIds_ = {cameraTest->streamIdPreview};
1080 cameraTest->captureInfo->captureSetting_ = cameraTest->abilityVec;
1081 cameraTest->captureInfo->enableShutterCallback_ = true;
1082 cameraTest->rc = cameraTest->streamOperator->Capture(cameraTest->streamIdPreview, *cameraTest->captureInfo, true);
1083 EXPECT_EQ(true, cameraTest->rc == DEVICE_ERROR);
1084 }
1085
1086 /**
1087 * @tc.name: INSUFFICIENT_RESOURCES
1088 * @tc.desc: INSUFFICIENT_RESOURCES
1089 * @tc.size: MediumTest
1090 * @tc.type: Function
1091 */
1092 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_003, TestSize.Level0)
1093 {
1094 EXPECT_TRUE(HDI::Camera::V1_0::INSUFFICIENT_RESOURCES == -2);
1095 }
1096
1097 /**
1098 * @tc.name: CAMERA_CLOSED
1099 * @tc.desc: CAMERA_CLOSED
1100 * @tc.size: MediumTest
1101 * @tc.type: Function
1102 */
1103 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_004, TestSize.Level0)
1104 {
1105 EXPECT_TRUE(HDI::Camera::V1_0::CAMERA_CLOSED == -5);
1106 }
1107
1108 /**
1109 * @tc.name: NO_PERMISSION
1110 * @tc.desc: NO_PERMISSION
1111 * @tc.size: MediumTest
1112 * @tc.type: Function
1113 */
1114 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_005, TestSize.Level0)
1115 {
1116 EXPECT_TRUE(HDI::Camera::V1_0::NO_PERMISSION == -7);
1117 }
1118
1119 /**
1120 * @tc.name: FLASHLIGHT_UNAVAILABLE
1121 * @tc.desc: FLASHLIGHT_UNAVAILABLE
1122 * @tc.size: MediumTest
1123 * @tc.type: Function
1124 */
1125 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_006, TestSize.Level0)
1126 {
1127 EXPECT_TRUE(HDI::Camera::V1_0::FLASHLIGHT_UNAVAILABLE == 2);
1128 }
1129
1130 /**
1131 * @tc.name: UNKNOWN_ERROR
1132 * @tc.desc: UNKNOWN_ERROR
1133 * @tc.size: MediumTest
1134 * @tc.type: Function
1135 */
1136 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_007, TestSize.Level0)
1137 {
1138 EXPECT_TRUE(HDI::Camera::V1_0::UNKNOWN_ERROR == 0);
1139 }
1140
1141 /**
1142 * @tc.name: BUFFER_LOST
1143 * @tc.desc: BUFFER_LOST
1144 * @tc.size: MediumTest
1145 * @tc.type: Function
1146 */
1147 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_008, TestSize.Level0)
1148 {
1149 EXPECT_TRUE(HDI::Camera::V1_0::BUFFER_LOST == 1);
1150 }
1151
1152 /**
1153 * @tc.name: FATAL_ERROR
1154 * @tc.desc: FATAL_ERROR
1155 * @tc.size: MediumTest
1156 * @tc.type: Function
1157 */
1158 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_009, TestSize.Level0)
1159 {
1160 EXPECT_TRUE(HDI::Camera::V1_0::FATAL_ERROR == 0);
1161 }
1162
1163 /**
1164 * @tc.name: REQUEST_TIMEOUT
1165 * @tc.desc: REQUEST_TIMEOUT
1166 * @tc.size: MediumTest
1167 * @tc.type: Function
1168 */
1169 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_010, TestSize.Level0)
1170 {
1171 EXPECT_TRUE(HDI::Camera::V1_0::REQUEST_TIMEOUT == 1);
1172 }
1173
1174 /**
1175 * @tc.name: DRIVER_ERROR
1176 * @tc.desc: DRIVER_ERROR
1177 * @tc.size: MediumTest
1178 * @tc.type: Function
1179 */
1180 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_011, TestSize.Level0)
1181 {
1182 EXPECT_TRUE(HDI::Camera::V1_0::DRIVER_ERROR == 2);
1183 }
1184
1185 /**
1186 * @tc.name: DEVICE_PREEMPT
1187 * @tc.desc: DEVICE_PREEMPT
1188 * @tc.size: MediumTest
1189 * @tc.type: Function
1190 */
1191 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_012, TestSize.Level0)
1192 {
1193 EXPECT_TRUE(HDI::Camera::V1_0::DEVICE_PREEMPT == 3);
1194 }
1195
1196 /**
1197 * @tc.name: DEVICE_DISCONNECT
1198 * @tc.desc: DEVICE_DISCONNECT
1199 * @tc.size: MediumTest
1200 * @tc.type: Function
1201 */
1202 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_013, TestSize.Level0)
1203 {
1204 EXPECT_TRUE(HDI::Camera::V1_0::DEVICE_DISCONNECT == 4);
1205 }
1206
1207 /**
1208 * @tc.name: DCAMERA_ERROR_BEGIN
1209 * @tc.desc: DCAMERA_ERROR_BEGIN
1210 * @tc.size: MediumTest
1211 * @tc.type: Function
1212 */
1213 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_014, TestSize.Level0)
1214 {
1215 EXPECT_TRUE(HDI::Camera::V1_0::DCAMERA_ERROR_BEGIN == 1024);
1216 }
1217
1218 /**
1219 * @tc.name: DCAMERA_ERROR_DEVICE_IN_USE
1220 * @tc.desc: DCAMERA_ERROR_DEVICE_IN_USE
1221 * @tc.size: MediumTest
1222 * @tc.type: Function
1223 */
1224 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_015, TestSize.Level0)
1225 {
1226 EXPECT_TRUE(HDI::Camera::V1_0::DCAMERA_ERROR_DEVICE_IN_USE == 1025);
1227 std::cout << "DCAMERA_ERROR_DEVICE_IN_USE value is " << HDI::Camera::V1_0::DCAMERA_ERROR_DEVICE_IN_USE << std::endl;
1228 }
1229
1230 /**
1231 * @tc.name: DCAMERA_ERROR_NO_PERMISSION
1232 * @tc.desc: DCAMERA_ERROR_NO_PERMISSION
1233 * @tc.size: MediumTest
1234 * @tc.type: Function
1235 */
1236 HWTEST_F(HdiStreamUtTest, SUB_DriverSystem_CameraHdiMg_016, TestSize.Level0)
1237 {
1238 EXPECT_TRUE(HDI::Camera::V1_0::DCAMERA_ERROR_NO_PERMISSION == 1026);
1239 std::cout << "DCAMERA_ERROR_NO_PERMISSION value is " << HDI::Camera::V1_0::DCAMERA_ERROR_NO_PERMISSION << std::endl;
1240 }
1241 #endif