1 /*
2 * Copyright (c) 2020 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 "dfx_test.h"
16 #include <fstream>
17 #ifdef CAMERA_BUILT_ON_OHOS_LITE
18 #include "parameter.h"
19 #else
20 #include "parameters.h"
21 #endif
22
23 namespace {
24 static const int TimeTransformation_us = 1000000;
25 static const int Times = 1000;
26 std::ofstream writeIntoFile;
27 }
28
29 using namespace OHOS;
30 using namespace std;
31 using namespace testing::ext;
32 using namespace OHOS::Camera;
calTime(struct timeval start,struct timeval end)33 float DfxTest::calTime(struct timeval start, struct timeval end)
34 {
35 float time_use = 0;
36 time_use = (end.tv_sec - start.tv_sec) * TimeTransformation_us + (end.tv_usec - start.tv_usec);
37 return time_use;
38 }
SetUpTestCase(void)39 void DfxTest::SetUpTestCase(void) {}
TearDownTestCase(void)40 void DfxTest::TearDownTestCase(void) {}
SetUp(void)41 void DfxTest::SetUp(void)
42 {
43 Test_ = std::make_shared<OHOS::Camera::Test>();
44 Test_->Init();
45 }
TearDown(void)46 void DfxTest::TearDown(void)
47 {
48 Test_->Close();
49 }
50
51 #ifdef CAMERA_BUILT_ON_OHOS_LITE
52 /**
53 * @tc.name: Frame interrupt detection.
54 * @tc.desc: Frame interrupt detection.
55 * @tc.size: MediumTest
56 * @tc.type: DFX
57 */
58 HWTEST_F(DfxTest, Camera_Dfx_0001, TestSize.Level3)
59 {
60 std::cout << "==========[test log] Dfx: Frame interrupt detection, mock 20s timeout" << std::endl;
61 int result = 0;
62 char property[] ="frame_timeout";
63 char value[] = "on";
64 int parameter;
65 char defValue[] = "on";
66 char value1[32] = {0};
67 result = SetParameter(property, value);
68 if (!result) {
69 Test_->Open();
70 // Start stream
71 Test_->intents = {Camera::PREVIEW};
72 Test_->StartStream(Test_->intents);
73 // Get preview
74 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
75 // release stream
76 Test_->captureIds = {Test_->captureId_preview};
77 Test_->streamIds = {Test_->streamId_preview};
78 Test_->StopStream(Test_->captureIds, Test_->streamIds);
79 }
80 result = SetParameter(property, "off");
81 }
82
83 /**
84 * @tc.name: GetStreamOperator timeout.
85 * @tc.desc: mock Hdi_GetStreamOperator_Timeout.
86 * @tc.size: MediumTest
87 * @tc.type: DFX
88 */
89 HWTEST_F(DfxTest, Camera_Dfx_0010, TestSize.Level3)
90 {
91 std::cout << "==========[test log] Dfx: mock Hdi_GetStreamOperator_Timeout." << std::endl;
92 int result = 0;
93 char property[] ="hdi_getstreamoperator_timeout";
94 char value[] = "on";
95 int parameter;
96 char defValue[] = "on";
97 char value1[32] = {0};
98 result = SetParameter(property, value);
99 if (!result) {
100 parameter = GetParameter(property, defValue, value1, 32);
101 std::cout << "==========[test log] DFX: GetProperty Hdi_GetStreamOperator_Timeout = " << parameter << std::endl;
102 Test_->Open();
103 Test_->streamOperatorCallback = std::make_shared<StreamOperatorCallback>();
104 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
105 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
106 }
107
108 result = SetParameter(property, "off");
109 }
110
111 /**
112 * @tc.name: UpdateSettings timeout.
113 * @tc.desc: mock Hdi_UpdateSettings_Timeout.
114 * @tc.size: MediumTest
115 * @tc.type: DFX
116 */
117 HWTEST_F(DfxTest, Camera_Dfx_0011, TestSize.Level3)
118 {
119 std::cout << "==========[test log] Dfx: mock Hdi_UpdateSettings_Timeout." << std::endl;
120 int result = 0;
121 char property[] ="hdi_updatesettings_timeout";
122 char value[] = "on";
123 int parameter;
124 char defValue[] = "on";
125 char value1[32] = {0};
126 result = SetParameter(property, value);
127 if (!result) {
128 parameter = GetParameter(property, defValue, value1, 32);
129 std::cout << "==========[test log] DFX: GetProperty Hdi_UpdateSettings_Timeout = " << parameter << std::endl;
130 Test_->Open();
131 // Issue 3A parameters
132 std::shared_ptr<Camera::CameraSetting> meta = std::make_shared<Camera::CameraSetting>(100, 2000);
133 int32_t expo = 0xa0;
134 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
135 Test_->rc = Test_->cameraDevice->UpdateSettings(meta);
136 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
137 std::cout << "cameraDevice->UpdateSettings's rc " << Test_->rc << std::endl;
138 }
139 result = SetParameter(property, "off");
140 }
141
142 /**
143 * @tc.name: Hdi_GetEnabledResults_Timeout.
144 * @tc.desc: mock Hdi_GetEnabledResults_Timeout.
145 * @tc.size: MediumTest
146 * @tc.type: DFX
147 */
148 HWTEST_F(DfxTest, Camera_Dfx_0012, TestSize.Level3)
149 {
150 std::cout << "==========[test log] Dfx: mock Hdi_GetEnabledResults_Timeout." << std::endl;
151 int result = 0;
152 char property[] ="hdi_getenabledresults_timeout";
153 char value[] = "on";
154 int parameter;
155 char defValue[] = "on";
156 char value1[32] = {0};
157 result = SetParameter(property, value);
158 if (!result) {
159 parameter = GetParameter(property, defValue, value1, 32);
160 std::cout << "==========[test log] DFX: GetProperty Hdi_GetEnabledResults_Timeout = " << parameter << std::endl;
161 Test_->Open();
162 EXPECT_EQ(true, Test_->cameraDevice != nullptr);
163 std::vector<Camera::MetaType> enableTypes;
164 Test_->rc = Test_->cameraDevice->GetEnabledResults(enableTypes);
165 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
166 for (auto &type : enableTypes) {
167 std::cout << "==========[test log]Check hdi_device: type = " << type << std::endl;
168 }
169 Test_->rc = Test_->cameraDevice->SetResultMode(Camera::PER_FRAME);
170 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
171 }
172 result = SetParameter(property, "off");
173 }
174
175 /**
176 * @tc.name: Hdi_GetEnabledResults_Timeout.
177 * @tc.desc: mock Hdi_GetEnabledResults_Timeout.
178 * @tc.size: MediumTest
179 * @tc.type: DFX
180 */
181 HWTEST_F(DfxTest, Camera_Dfx_0013, TestSize.Level3)
182 {
183 std::cout << "==========[test log] Dfx: mock Hdi_GetEnabledResults_Timeout." << std::endl;
184 int result = 0;
185 char property[] ="hdi_getenabledresults_timeout";
186 char value[] = "on";
187 int parameter;
188 char defValue[] = "on";
189 char value1[32] = {0};
190 result = SetParameter(property, value);
191 if (!result) {
192 parameter = GetParameter(property, defValue, value1, 32);
193 std::cout << "==========[test log] DFX: GetProperty Hdi_GetEnabledResults_Timeout = " << parameter << std::endl;
194 Test_->Open();
195 EXPECT_EQ(true, Test_->cameraDevice != nullptr);
196 std::vector<Camera::MetaType> enableTypes;
197 Test_->rc = Test_->cameraDevice->GetEnabledResults(enableTypes);
198 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
199 for (auto &type : enableTypes) {
200 std::cout << "==========[test log]Check hdi_device: type = " << type << std::endl;
201 }
202 Test_->rc = Test_->cameraDevice->SetResultMode(Camera::PER_FRAME);
203 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
204 }
205 result = SetParameter(property, "off");
206 }
207
208 /**
209 * @tc.name: Hdi_DisableResult_Timeout.
210 * @tc.desc: mock Hdi_DisableResult_Timeout.
211 * @tc.size: MediumTest
212 * @tc.type: DFX
213 */
214 HWTEST_F(DfxTest, Camera_Dfx_0014, TestSize.Level3)
215 {
216 std::cout << "==========[test log] Dfx: mock Hdi_DisableResult_Timeout." << std::endl;
217 int result = 0;
218 char property[] ="hdi_disableresult_timeout";
219 char value[] = "on";
220 int parameter;
221 char defValue[] = "on";
222 char value1[32] = {0};
223 result = SetParameter(property, value);
224 if (!result) {
225 parameter = GetParameter(property, defValue, value1, 32);
226 std::cout << "==========[test log] DFX: GetProperty Hdi_DisableResult_Timeout = " << parameter << std::endl;
227 Test_->Open();
228 // Get the parameter tag currently supported by the device
229 std::vector<Camera::MetaType> results_first;
230 results_first.push_back(OHOS_SENSOR_EXPOSURE_TIME);
231 results_first.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
232 Test_->rc = Test_->cameraDevice->EnableResult(results_first);
233 std::vector<Camera::MetaType> results_original;
234 Test_->rc = Test_->cameraDevice->GetEnabledResults(results_original);
235 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
236 std::cout << "==========[test log]GetEnabledResults, size = " << results_original.size() << std::endl;
237
238 // disable a tag
239 std::vector<Camera::MetaType> disable_tag;
240 disable_tag.push_back(results_original[1]);
241 Test_->rc = Test_->cameraDevice->DisableResult(disable_tag);
242 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
243 std::cout << "==========[test log]Check hdi_device: DisableResult the tag:" << results_original[0] << std::endl;
244
245 // Get the parameter tag currently supported by the device again
246 std::vector<Camera::MetaType> results;
247 Test_->rc = Test_->cameraDevice->GetEnabledResults(results);
248 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
249 }
250 result = SetParameter(property, "off");
251 }
252
253 /**
254 * @tc.name: Hdi_Close_Timeout.
255 * @tc.desc: mock Hdi_Close_Timeout.
256 * @tc.size: MediumTest
257 * @tc.type: DFX
258 */
259 HWTEST_F(DfxTest, Camera_Dfx_0015, TestSize.Level3)
260 {
261 std::cout << "==========[test log] Dfx: mock Hdi_Close_Timeout." << std::endl;
262 int result = 0;
263 char property[] ="hdi_close_timeout";
264 char value[] = "on";
265 int parameter;
266 char defValue[] = "on";
267 char value1[32] = {0};
268 result = SetParameter(property, value);
269 if (!result) {
270 parameter = GetParameter(property, defValue, value1, 32);
271 std::cout << "==========[test log] DFX: GetProperty Hdi_Close_Timeout = " << parameter << std::endl;
272 Test_->Open();
273 Test_->Close();
274 }
275 result = SetParameter(property, "off");
276 }
277
278 /**
279 * @tc.name: Hdi_IsStreamsSupported_Timeout.
280 * @tc.desc: mock Hdi_IsStreamsSupported_Timeout.
281 * @tc.size: MediumTest
282 * @tc.type: DFX
283 */
284 HWTEST_F(DfxTest, Camera_Dfx_0020, TestSize.Level3) {
285 std::cout << "==========[test log] Dfx: mock Hdi_IsStreamsSupported_Timeout." << std::endl;
286 int result = 0;
287 char property[] ="Hdi_IsStreamsSupported_Timeout";
288 char value[] = "on";
289 int parameter;
290 char defValue[] = "on";
291 char value1[32] = {0};
292 result = SetParameter(property, value);
293 if (!result) {
294 parameter = GetParameter(property, defValue, value1, 32);
295 std::cout << "==========[test log] DFX:GetProperty Hdi_IsStreamsSupported_Timeout = " << parameter << std::endl;
296 // Turn on the camera
297 Test_->Open();
298 EXPECT_EQ(false, Test_->cameraDevice == nullptr);
299 // Get streamOperator
300 Test_->streamOperatorCallback = std::make_shared<StreamOperatorCallback>();
301 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
302 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
303 // Configure mode and modeSetting
304 Camera::OperationMode mode = Camera::NORMAL;
305 std::shared_ptr<CameraMetadata> modeSetting =
306 std::make_shared<CameraMetadata>(2, 128);
307 int64_t expoTime = 0;
308 modeSetting->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &expoTime, 1);
309 int64_t colorGains[4] = {0};
310 modeSetting->addEntry(OHOS_SENSOR_COLOR_CORRECTION_GAINS, &colorGains, 4);
311 // Configure stream information
312 Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
313 Test_->streamInfo->streamId_ = 1001; // 1001:streamId
314 Test_->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
315 Test_->streamInfo->height_ = 480; // 480:height of stream
316 Test_->streamInfo->width_ = 640; // 640:width of stream
317 Test_->streamInfo->datasapce_ = 8;
318 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
319 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon1f6d91800202(OHOS::SurfaceBuffer* buffer) 320 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
321 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
322 });
323 Test_->streamInfo->bufferQueue_->SetQueueSize(8);
324 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer;
325 Test_->streamInfo->intent_ = Camera::PREVIEW;
326 Test_->streamInfo->tunneledMode_ = 5;
327 Camera::StreamSupportType pType;
328 std::vector<std::shared_ptr<Camera::StreamInfo>> stre;
329 stre.push_back(Test_->streamInfo);
330 Test_->rc = Test_->streamOperator->IsStreamsSupported(NORMAL, modeSetting, stre, pType);
331 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
332 EXPECT_NE(pType, NOT_SUPPORTED);
333 if (Test_->rc == Camera::NO_ERROR) {
334 std::cout << "==========[test log]Check hdi: IsStreamsSupported success, pType = " << pType << std::endl;
335 } else {
336 std::cout << "==========[test log]Check hdi: IsStreamsSupported fail, rc = " << Test_->rc << std::endl;
337 }
338 }
339 result = SetParameter(property, "off");
340 }
341
342 /**
343 * @tc.name: Hdi_CreateStreams_Timeout.
344 * @tc.desc: mock Hdi_CreateStreams_Timeout.
345 * @tc.size: MediumTest
346 * @tc.type: DFX
347 */
348 HWTEST_F(DfxTest, Camera_Dfx_0021, TestSize.Level3)
349 {
350 std::cout << "==========[test log] Dfx: mock Hdi_CreateStreams_Timeout." << std::endl;
351 int result = 0;
352 char property[] ="hdi_createstreams_timeout";
353 char value[] = "on";
354 int parameter;
355 char defValue[] = "on";
356 char value1[32] = {0};
357 result = SetParameter(property, value);
358 if (!result) {
359 parameter = GetParameter(property, defValue, value1, 32);
360 std::cout << "==========[test log] DFX: GetProperty Hdi_CreateStreams_Timeout = " << parameter << std::endl;
361 Test_->Open();
362 // Create and get streamOperator information
363 Test_->streamOperatorCallback = std::make_shared<StreamOperatorCallback>();
364 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
365 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr);
366 // Create data stream
367 Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
368 Test_->streamInfo->streamId_ = 1001;
369 Test_->streamInfo->width_ = 640;
370 Test_->streamInfo->height_ = 480;
371 Test_->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
372 Test_->streamInfo->datasapce_ = 8;
373 Test_->streamInfo->intent_ = Camera::PREVIEW;
374 Test_->streamInfo->tunneledMode_ = 5;
375 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
376 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon1f6d91800302(OHOS::SurfaceBuffer* buffer) 377 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
378 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
379 });
380 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer;
381 Test_->streamInfos.push_back(Test_->streamInfo);
382 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
383 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
384 // release stream
385 std::vector<int> streamIds;
386 streamIds.push_back(Test_->streamInfo->streamId_);
387 Test_->rc = Test_->streamOperator->ReleaseStreams(streamIds);
388 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
389 }
390 result = SetParameter(property, "off");
391 }
392
393 /**
394 * @tc.name: Hdi_ReleaseStreams_Timeout.
395 * @tc.desc: mock Hdi_ReleaseStreams_Timeout.
396 * @tc.size: MediumTest
397 * @tc.type: DFX
398 */
399 HWTEST_F(DfxTest, Camera_Dfx_0022, TestSize.Level3)
400 {
401 std::cout << "==========[test log] Dfx: mock Hdi_ReleaseStreams_Timeout." << std::endl;
402 int result = 0;
403 char property[] ="hdi_releasestreams_timeout";
404 char value[] = "on";
405 int parameter;
406 char defValue[] = "on";
407 char value1[32] = {0};
408 result = SetParameter(property, value);
409 if (!result) {
410 parameter = GetParameter(property, defValue, value1, 32);
411 std::cout << "==========[test log] DFX: GetProperty Hdi_ReleaseStreams_Timeout = " << parameter << std::endl;
412 Test_->Open();
413 // Create and get streamOperator information
414 Test_->streamOperatorCallback = std::make_shared<StreamOperatorCallback>();
415 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
416 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr);
417 // Create data stream
418 Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
419 Test_->streamInfo->streamId_ = 1001;
420 Test_->streamInfo->width_ = 640;
421 Test_->streamInfo->height_ = 480;
422 Test_->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
423 Test_->streamInfo->datasapce_ = 8;
424 Test_->streamInfo->intent_ = Camera::PREVIEW;
425 Test_->streamInfo->tunneledMode_ = 5;
426 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
427 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon1f6d91800402(OHOS::SurfaceBuffer* buffer) 428 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
429 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
430 });
431 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer;
432 Test_->streamInfos.push_back(Test_->streamInfo);
433 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
434 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
435 // release stream
436 std::vector<int> streamIds;
437 streamIds.push_back(Test_->streamInfo->streamId_);
438 Test_->rc = Test_->streamOperator->ReleaseStreams(streamIds);
439 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
440 }
441 result = SetParameter(property, "off");
442 }
443
444 /**
445 * @tc.name: Hdi_CommitStreams_Timeout.
446 * @tc.desc: mock Hdi_CommitStreams_Timeout.
447 * @tc.size: MediumTest
448 * @tc.type: DFX
449 */
450 HWTEST_F(DfxTest, Camera_Dfx_0023, TestSize.Level3)
451 {
452 std::cout << "==========[test log] Dfx: mock Hdi_CommitStreams_Timeout." << std::endl;
453 int result = 0;
454 char property[] ="hdi_commitstreams_timeout";
455 char value[] = "on";
456 int parameter;
457 char defValue[] = "on";
458 char value1[32] = {0};
459 result = SetParameter(property, value);
460 if (!result) {
461 parameter = GetParameter(property, defValue, value1, 32);
462 std::cout << "==========[test log] DFX: GetProperty Hdi_CommitStreams_Timeout = " << parameter << std::endl;
463 Test_->Open();
464 // Start stream
465 Test_->intents = {Camera::PREVIEW};
466 Test_->StartStream(Test_->intents);
467 // release stream
468 Test_->captureIds = {};
469 Test_->streamIds = {Test_->streamId_preview};
470 Test_->StopStream(Test_->captureIds, Test_->streamIds);
471 }
472 result = SetParameter(property, "off");
473 }
474
475 /**
476 * @tc.name: Hdi_AttachBufferQueue_Timeout.
477 * @tc.desc: mock Hdi_AttachBufferQueue_Timeout.
478 * @tc.size: MediumTest
479 * @tc.type: DFX
480 */
481 HWTEST_F(DfxTest, Camera_Dfx_0024, TestSize.Level3)
482 {
483 std::cout << "==========[test log] Dfx: mock Hdi_AttachBufferQueue_Timeout." << std::endl;
484 int result = 0;
485 char property[] ="hdi_attachbufferqueue_timeout";
486 char value[] = "on";
487 int parameter;
488 char defValue[] = "on";
489 char value1[32] = {0};
490 result = SetParameter(property, value);
491 if (!result) {
492 parameter = GetParameter(property, defValue, value1, 32);
493 std::cout << "==========[test log] DFX: GetProperty Hdi_AttachBufferQueue_Timeout = " << parameter << std::endl;
494 Test_->Open();
495 Test_->streamOperatorCallback = std::make_shared<StreamOperatorCallback>();
496 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
497 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
498 // Create data stream
499 Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
500 Test_->streamInfo->streamId_ = 1001;
501 Test_->streamInfo->height_ = 480;
502 Test_->streamInfo->width_ = 640;
503 Test_->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
504 Test_->streamInfo->datasapce_ = 8;
505 Test_->streamInfo->intent_ = Camera::PREVIEW;
506 Test_->streamInfo->tunneledMode_ = 5;
507 std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos);
508 Test_->streamInfos.push_back(Test_->streamInfo);
509 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
510 std::cout << "==========[test log]Check hdi: streamOperator->CreateStreams's rc " << Test_->rc << std::endl;
511 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
512 // Distribution stream
513 Test_->rc = Test_->service->GetCameraAbility(Test_->cameraIds.front(), Test_->ability);
514 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability);
515 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
516 std::cout << "==========[test log]Check hdi: streamOperator->CommitStreams's rc " << Test_->rc << std::endl;
517 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
518 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon1f6d91800502(OHOS::SurfaceBuffer* buffer) 519 std::shared_ptr<OHOS::Surface> producer = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
520 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
521 });
522 Test_->rc = Test_->streamOperator->AttachBufferQueue(Test_->streamInfo->streamId_, producer);
523 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
524 if (Test_->rc == Camera::NO_ERROR) {
525 std::cout << "==========[test log]Check hdi: AttachBufferQueue success. " << std::endl;
526 } else {
527 std::cout << "==========[test log]Check hdi: AttachBufferQueue fail, rc = " << Test_->rc << std::endl;
528 }
529 // release stream
530 Test_->captureIds = {};
531 Test_->streamIds = {1001};
532 Test_->StopStream(Test_->captureIds, Test_->streamIds);
533 }
534 result = SetParameter(property, "off");
535 }
536
537 /**
538 * @tc.name: Hdi_DetachBufferQueue_Timeout.
539 * @tc.desc: mock Hdi_DetachBufferQueue_Timeout.
540 * @tc.size: MediumTest
541 * @tc.type: DFX
542 */
543 HWTEST_F(DfxTest, Camera_Dfx_0025, TestSize.Level3)
544 {
545 std::cout << "==========[test log] Dfx: mock Hdi_DetachBufferQueue_Timeout." << std::endl;
546 int result = 0;
547 char property[] ="hdi_detachbufferqueue_timeout";
548 char value[] = "on";
549 int parameter;
550 char defValue[] = "on";
551 char value1[32] = {0};
552 result = SetParameter(property, value);
553 if (!result) {
554 parameter = GetParameter(property, defValue, value1, 32);
555 std::cout << "==========[test log] DFX: GetProperty Hdi_DetachBufferQueue_Timeout = " << parameter << std::endl;
556 Test_->Open();
557 Test_->streamOperatorCallback = std::make_shared<StreamOperatorCallback>();
558 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
559 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
560 // Create data stream
561 Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
562 Test_->streamInfo->streamId_ = 1001;
563 Test_->streamInfo->width_ = 640;
564 Test_->streamInfo->height_ = 480;
565 Test_->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
566 Test_->streamInfo->intent_ = Camera::PREVIEW;
567 Test_->streamInfo->datasapce_ = 8;
568 Test_->streamInfo->tunneledMode_ = 5;
569 std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos);
570 Test_->streamInfos.push_back(Test_->streamInfo);
571 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
572 std::cout << "==========[test log]Check hdi: streamOperator->CreateStreams's rc " << Test_->rc << std::endl;
573 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
574 // Distribution stream
575 Test_->rc = Test_->service->GetCameraAbility(Test_->cameraIds.front(), Test_->ability);
576 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability);
577 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
578 std::cout << "==========[test log]Check hdi: streamOperator->CommitStreams's rc " << Test_->rc << std::endl;
579 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
580 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon1f6d91800602(OHOS::SurfaceBuffer* buffer) 581 std::shared_ptr<OHOS::Surface> producer = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
582 Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
583 });
584 Test_->rc = Test_->streamOperator->AttachBufferQueue(Test_->streamInfo->streamId_, producer);
585 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
586 if (Test_->rc == Camera::NO_ERROR) {
587 std::cout << "==========[test log]Check hdi: AttachBufferQueue success. " << std::endl;
588 } else {
589 std::cout << "==========[test log]Check hdi: AttachBufferQueue fail, rc = " << Test_->rc << std::endl;
590 }
591 sleep(3);
592 Test_->rc = Test_->streamOperator->DetachBufferQueue(Test_->streamInfo->streamId_);
593 std::cout << "==========[test log]Check hdi: streamOperator->DetachBufferQueue's rc " << Test_->rc << std::endl;
594 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
595 // release stream
596 Test_->captureIds = {};
597 Test_->streamIds = {1001};
598 Test_->StopStream(Test_->captureIds, Test_->streamIds);
599 }
600 result = SetParameter(property, "off");
601 }
602
603 /**
604 * @tc.name: Hdi_Capture_Timeout.
605 * @tc.desc: mock Hdi_Capture_Timeout.
606 * @tc.size: MediumTest
607 * @tc.type: DFX
608 */
609 HWTEST_F(DfxTest, Camera_Dfx_0026, TestSize.Level3)
610 {
611 std::cout << "==========[test log] Dfx: mock Hdi_Capture_Timeout." << std::endl;
612 int result = 0;
613 char property[] ="hdi_capture_timeout";
614 char value[] = "on";
615 int parameter;
616 char defValue[] = "on";
617 char value1[32] = {0};
618 result = SetParameter(property, value);
619 if (!result) {
620 parameter = GetParameter(property, defValue, value1, 32);
621 std::cout << "==========[test log] DFX: GetProperty Hdi_Capture_Timeout = " << parameter << std::endl;
622 Test_->Open();
623 // Configure preview stream information
624 Test_->intents = {Camera::PREVIEW};
625 Test_->StartStream(Test_->intents);
626 // Capture preview stream
627 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, true, true);
628 // post-processing
629 Test_->captureIds = {Test_->captureId_preview};
630 Test_->streamIds = {Test_->streamId_preview};
631 Test_->StopStream(Test_->captureIds, Test_->streamIds);
632 }
633 result = SetParameter(property, "off");
634 }
635
636 /**
637 * @tc.name: Hdi_ChangeToOfflineStream_Timeout.
638 * @tc.desc: mock Hdi_ChangeToOfflineStream_Timeout.
639 * @tc.size: MediumTest
640 * @tc.type: DFX
641 */
642 HWTEST_F(DfxTest, Camera_Dfx_0027, TestSize.Level3)
643 {
644 std::cout << "==========[test log] Dfx: mock Hdi_ChangeToOfflineStream_Timeout." << std::endl;
645 int result = 0;
646 char property[] ="hdi_change_to_offlinestream_timeout";
647 char value[] = "on";
648 int parameter;
649 char defValue[] = "on";
650 char value1[32] = {0};
651 result = SetParameter(property, value);
652 if (!result) {
653 parameter = GetParameter(property, defValue, value1, 32);
654 std::cout << "======[test log] DFX:GetProperty Hdi_ChangeToOfflineStream_Timeout = " << parameter << std::endl;
655 Test_->Open();
656 // 1. Configure two streams of information
657 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE};
658 Test_->StartStream(Test_->intents);
659 // 2. Capture the preview stream
660 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
661 // 3. Capture the camera stream, continuous shooting
662 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true);
663 sleep(5);
664 // 4. Convert to offline stream
665 Test_->offlineStreamOperatorCallback = std::make_shared<OHOS::Camera::StreamOperatorCallback>();
666 std::vector<int> offlineIds;
667 offlineIds.push_back(Test_->streamId_capture);
668 Test_->rc = Test_->streamOperator->ChangeToOfflineStream(
669 offlineIds, Test_->offlineStreamOperatorCallback, Test_->offlineStreamOperator);
670 ASSERT_EQ(Test_->rc, Camera::NO_ERROR);
671 std::cout << "==========[test log] ChangeToOfflineStream rc = " << Test_->rc << std::endl;
672 EXPECT_EQ(true, Test_->offlineStreamOperator != nullptr);
673 if (Test_->rc == Camera::NO_ERROR) {
674 std::cout << "==========[test log] offline StreamOperator != nullptr" << std::endl;
675 } else {
676 std::cout << "==========[test log] offline StreamOperator == nullptr" << std::endl;
677 }
678 // 5. Post-processing of the original stream
679 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture};
680 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture};
681 Test_->StopStream(Test_->captureIds, Test_->streamIds);
682 // 6. Post-processing of offline streams
683 Test_->cameraDevice->Close();
684 std::cout << "==========[test log] Pretend to wait 5s for callback..." << std::endl;
685 sleep(5);
686 Test_->StopOfflineStream(Test_->captureId_capture);
687 }
688 result = SetParameter(property, "off");
689 }
690
691 /**
692 * @tc.name: Hdi_Offline_CancelCapture_Timeout.
693 * @tc.desc: mock Hdi_Offline_ReleaseStreams_Timeout.
694 * @tc.size: MediumTest
695 * @tc.type: DFX
696 */
697 HWTEST_F(DfxTest, Camera_Dfx_0030, TestSize.Level3)
698 {
699 std::cout << "==========[test log] Dfx: mock Hdi_Offline_CancelCapture_Timeout." << std::endl;
700 int result = 0;
701 char property[] ="hdi_offline_cancelcapture_timeout";
702 char value[] = "on";
703 int parameter;
704 char defValue[] = "on";
705 char value1[32] = {0};
706 result = SetParameter(property, value);
707 if (!result) {
708 parameter = GetParameter(property, defValue, value1, 32);
709 std::cout << "======[test log] DFX:GetProperty Hdi_Offline_CancelCapture_Timeout = " << parameter << std::endl;
710 Test_->Open();
711 // 1. Configure two streams of information
712 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE};
713 Test_->StartStream(Test_->intents);
714 // 2. Capture the preview stream
715 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
716 // 3. Capture the camera stream, continuous shooting
717 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true);
718 sleep(5);
719 // 4. Convert to offline stream
720 Test_->offlineStreamOperatorCallback = std::make_shared<OHOS::Camera::StreamOperatorCallback>();
721 std::vector<int> offlineIds;
722 offlineIds.push_back(Test_->streamId_capture);
723 Test_->rc = Test_->streamOperator->ChangeToOfflineStream(
724 offlineIds, Test_->offlineStreamOperatorCallback, Test_->offlineStreamOperator);
725 ASSERT_EQ(Test_->rc, Camera::NO_ERROR);
726 std::cout << "==========[test log] ChangeToOfflineStream rc = " << Test_->rc << std::endl;
727 EXPECT_EQ(true, Test_->offlineStreamOperator != nullptr);
728 if (Test_->rc == Camera::NO_ERROR) {
729 std::cout << "==========[test log] offline StreamOperator != nullptr" << std::endl;
730 } else {
731 std::cout << "==========[test log] offline StreamOperator == nullptr" << std::endl;
732 }
733 // 5. Post-processing of the original stream
734 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture};
735 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture};
736 Test_->StopStream(Test_->captureIds, Test_->streamIds);
737 // 6. Post-processing of offline streams
738 Test_->cameraDevice->Close();
739 std::cout << "==========[test log] Pretend to wait 5s for callback..." << std::endl;
740 sleep(5);
741 Test_->StopOfflineStream(Test_->captureId_capture);
742 }
743 result = SetParameter(property, "off");
744 }
745
746 /**
747 * @tc.name: Hdi_Offline_ReleaseStreams_Timeout.
748 * @tc.desc: mock Hdi_Offline_ReleaseStreams_Timeout.
749 * @tc.size: MediumTest
750 * @tc.type: DFX
751 */
752 HWTEST_F(DfxTest, Camera_Dfx_0031, TestSize.Level3)
753 {
754 std::cout << "==========[test log] Dfx: mock Hdi_Offline_ReleaseStreams_Timeout." << std::endl;
755 int result = 0;
756 char property[] ="hdi_offline_releasestreams_timeout";
757 char value[] = "on";
758 int parameter;
759 char defValue[] = "on";
760 char value1[32] = {0};
761 result = SetParameter(property, value);
762 if (!result) {
763 parameter = GetParameter(property, defValue, value1, 32);
764 std::cout << "=====[test log] DFX:GetProperty Hdi_Offline_ReleaseStreams_Timeout = " << parameter << std::endl;
765 Test_->Open();
766 // 1. Configure two streams of information
767 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE};
768 Test_->StartStream(Test_->intents);
769 // 2. Capture the preview stream
770 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
771 // 3. Capture the camera stream, continuous shooting
772 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true);
773 sleep(5);
774 // 4. Convert to offline stream
775 Test_->offlineStreamOperatorCallback = std::make_shared<OHOS::Camera::StreamOperatorCallback>();
776 std::vector<int> offlineIds;
777 offlineIds.push_back(Test_->streamId_capture);
778 Test_->rc = Test_->streamOperator->ChangeToOfflineStream(
779 offlineIds, Test_->offlineStreamOperatorCallback, Test_->offlineStreamOperator);
780 ASSERT_EQ(Test_->rc, Camera::NO_ERROR);
781 std::cout << "==========[test log] ChangeToOfflineStream rc = " << Test_->rc << std::endl;
782 EXPECT_EQ(true, Test_->offlineStreamOperator != nullptr);
783 if (Test_->rc == Camera::NO_ERROR) {
784 std::cout << "==========[test log] offline StreamOperator != nullptr" << std::endl;
785 } else {
786 std::cout << "==========[test log] offline StreamOperator == nullptr" << std::endl;
787 }
788 // 5. Post-processing of the original stream
789 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture};
790 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture};
791 Test_->StopStream(Test_->captureIds, Test_->streamIds);
792 // 6. Post-processing of offline streams
793 Test_->cameraDevice->Close();
794 std::cout << "==========[test log] Pretend to wait 5s for callback..." << std::endl;
795 sleep(5);
796 Test_->StopOfflineStream(Test_->captureId_capture);
797 }
798 result = SetParameter(property, "off");
799 }
800
801 /**
802 * @tc.name: Hdi_Offline_Release_Timeout.
803 * @tc.desc: mock Hdi_Offline_Release_Timeout.
804 * @tc.size: MediumTest
805 * @tc.type: DFX
806 */
807 HWTEST_F(DfxTest, Camera_Dfx_0032, TestSize.Level3)
808 {
809 std::cout << "==========[test log] Dfx: mock Hdi_Offline_Release_Timeout." << std::endl;
810 int result = 0;
811 char property[] ="hdi_offline_release_timeout";
812 char value[] = "on";
813 int parameter;
814 char defValue[] = "on";
815 char value1[32] = {0};
816 result = SetParameter(property, value);
817 if (!result) {
818 parameter = GetParameter(property, defValue, value1, 32);
819 std::cout << "==========[test log] DFX: GetProperty Hdi_Offline_Release_Timeout = " << parameter << std::endl;
820 Test_->Open();
821 // 1. Configure two streams of information
822 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE};
823 Test_->StartStream(Test_->intents);
824 // 2. Capture the preview stream
825 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
826 // 3. Capture the camera stream, continuous shooting
827 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true);
828 sleep(5);
829 // 4. Convert to offline stream
830 Test_->offlineStreamOperatorCallback = std::make_shared<OHOS::Camera::StreamOperatorCallback>();
831 std::vector<int> offlineIds;
832 offlineIds.push_back(Test_->streamId_capture);
833 Test_->rc = Test_->streamOperator->ChangeToOfflineStream(
834 offlineIds, Test_->offlineStreamOperatorCallback, Test_->offlineStreamOperator);
835 ASSERT_EQ(Test_->rc, Camera::NO_ERROR);
836 std::cout << "==========[test log] ChangeToOfflineStream rc = " << Test_->rc << std::endl;
837 EXPECT_EQ(true, Test_->offlineStreamOperator != nullptr);
838 if (Test_->rc == Camera::NO_ERROR) {
839 std::cout << "==========[test log] offline StreamOperator != nullptr" << std::endl;
840 } else {
841 std::cout << "==========[test log] offline StreamOperator == nullptr" << std::endl;
842 }
843 // 5. Post-processing of the original stream
844 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture};
845 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture};
846 Test_->StopStream(Test_->captureIds, Test_->streamIds);
847 // 6. Post-processing of offline streams
848 Test_->cameraDevice->Close();
849 std::cout << "==========[test log] Pretend to wait 5s for callback..." << std::endl;
850 sleep(5);
851 Test_->StopOfflineStream(Test_->captureId_capture);
852 }
853 result = SetParameter(property, "off");
854 }
855 #else
856 /**
857 * @tc.name: Frame interrupt detection.
858 * @tc.desc: Frame interrupt detection.
859 * @tc.size: MediumTest
860 * @tc.type: DFX
861 */
862 HWTEST_F(DfxTest, Camera_Dfx_0001, TestSize.Level3)
863 {
864 std::cout << "==========[test log] Dfx: Frame interrupt detection, mock 20s timeout" << std::endl;
865 bool result = false;
866 std::string property="Frame_Timeout";
867 std::string value = "on";
868 std::string parameter;
869 result = OHOS::system::SetParameter(property, value);
870 if (result) {
871 Test_->Open();
872 // Start stream
873 Test_->intents = {Camera::PREVIEW};
874 Test_->StartStream(Test_->intents);
875 // Get preview
876 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
877 // release stream
878 Test_->captureIds = {Test_->captureId_preview};
879 Test_->streamIds = {Test_->streamId_preview};
880 Test_->StopStream(Test_->captureIds, Test_->streamIds);
881 Test_->StopConsumer(Test_->intents);
882 }
883 result = OHOS::system::SetParameter(property, "off");
884 }
885
886 /**
887 * @tc.name: GetStreamOperator timeout.
888 * @tc.desc: mock Hdi_GetStreamOperator_Timeout.
889 * @tc.size: MediumTest
890 * @tc.type: DFX
891 */
892 HWTEST_F(DfxTest, Camera_Dfx_0010, TestSize.Level3)
893 {
894 std::cout << "==========[test log] Dfx: mock Hdi_GetStreamOperator_Timeout." << std::endl;
895 bool result = false;
896 std::string property="Hdi_GetStreamOperator_Timeout";
897 std::string value = "on";
898 std::string parameter;
899 result = OHOS::system::SetParameter(property, value);
900 if (result) {
901 parameter = OHOS::system::GetParameter(property, value);
902 std::cout << "==========[test log] DFX: GetProperty Hdi_GetStreamOperator_Timeout = " << parameter << std::endl;
903 Test_->Open();
904 Test_->streamOperatorCallback = new StreamOperatorCallback();
905 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
906 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
907 }
908
909 result = OHOS::system::SetParameter(property, "off");
910 }
911
912 /**
913 * @tc.name: UpdateSettings timeout.
914 * @tc.desc: mock Hdi_UpdateSettings_Timeout.
915 * @tc.size: MediumTest
916 * @tc.type: DFX
917 */
918 HWTEST_F(DfxTest, Camera_Dfx_0011, TestSize.Level3)
919 {
920 std::cout << "==========[test log] Dfx: mock Hdi_UpdateSettings_Timeout." << std::endl;
921 bool result = false;
922 std::string property="Hdi_UpdateSettings_Timeout";
923 std::string value = "on";
924 std::string parameter;
925 result = OHOS::system::SetParameter(property, value);
926 if (result) {
927 parameter = OHOS::system::GetParameter(property, value);
928 std::cout << "==========[test log] DFX: GetProperty Hdi_UpdateSettings_Timeout = " << parameter << std::endl;
929 Test_->Open();
930 // Issue 3A parameters
931 std::shared_ptr<Camera::CameraSetting> meta = std::make_shared<Camera::CameraSetting>(100, 2000);
932 int32_t expo = 0xa0;
933 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
934 Test_->rc = Test_->cameraDevice->UpdateSettings(meta);
935 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
936 std::cout << "cameraDevice->UpdateSettings's rc " << Test_->rc << std::endl;
937 }
938 result = OHOS::system::SetParameter(property, "off");
939 }
940
941 /**
942 * @tc.name: Hdi_GetEnabledResults_Timeout.
943 * @tc.desc: mock Hdi_GetEnabledResults_Timeout.
944 * @tc.size: MediumTest
945 * @tc.type: DFX
946 */
947 HWTEST_F(DfxTest, Camera_Dfx_0012, TestSize.Level3)
948 {
949 std::cout << "==========[test log] Dfx: mock Hdi_GetEnabledResults_Timeout." << std::endl;
950 bool result = false;
951 std::string property="Hdi_GetEnabledResults_Timeout";
952 std::string value = "on";
953 std::string parameter;
954 result = OHOS::system::SetParameter(property, value);
955 if (result) {
956 parameter = OHOS::system::GetParameter(property, value);
957 std::cout << "==========[test log] DFX: GetProperty Hdi_GetEnabledResults_Timeout = " << parameter << std::endl;
958 Test_->Open();
959 EXPECT_EQ(true, Test_->cameraDevice != nullptr);
960 std::vector<Camera::MetaType> enableTypes;
961 Test_->rc = Test_->cameraDevice->GetEnabledResults(enableTypes);
962 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
963 for (auto &type : enableTypes) {
964 std::cout << "==========[test log]Check hdi_device: type = " << type << std::endl;
965 }
966 Test_->rc = Test_->cameraDevice->SetResultMode(Camera::PER_FRAME);
967 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
968 }
969 result = OHOS::system::SetParameter(property, "off");
970 }
971
972 /**
973 * @tc.name: Hdi_GetEnabledResults_Timeout.
974 * @tc.desc: mock Hdi_GetEnabledResults_Timeout.
975 * @tc.size: MediumTest
976 * @tc.type: DFX
977 */
978 HWTEST_F(DfxTest, Camera_Dfx_0013, TestSize.Level3)
979 {
980 std::cout << "==========[test log] Dfx: mock Hdi_GetEnabledResults_Timeout." << std::endl;
981 bool result = false;
982 std::string property="Hdi_GetEnabledResults_Timeout";
983 std::string value = "on";
984 std::string parameter;
985 result = OHOS::system::SetParameter(property, value);
986 if (result) {
987 parameter = OHOS::system::GetParameter(property, value);
988 std::cout << "==========[test log] DFX: GetProperty Hdi_GetEnabledResults_Timeout = " << parameter << std::endl;
989 Test_->Open();
990 EXPECT_EQ(true, Test_->cameraDevice != nullptr);
991 std::vector<Camera::MetaType> enableTypes;
992 Test_->rc = Test_->cameraDevice->GetEnabledResults(enableTypes);
993 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
994 for (auto &type : enableTypes) {
995 std::cout << "==========[test log]Check hdi_device: type = " << type << std::endl;
996 }
997 Test_->rc = Test_->cameraDevice->SetResultMode(Camera::PER_FRAME);
998 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
999 }
1000 result = OHOS::system::SetParameter(property, "off");
1001 }
1002
1003 /**
1004 * @tc.name: Hdi_DisableResult_Timeout.
1005 * @tc.desc: mock Hdi_DisableResult_Timeout.
1006 * @tc.size: MediumTest
1007 * @tc.type: DFX
1008 */
1009 HWTEST_F(DfxTest, Camera_Dfx_0014, TestSize.Level3)
1010 {
1011 std::cout << "==========[test log] Dfx: mock Hdi_DisableResult_Timeout." << std::endl;
1012 bool result = false;
1013 std::string property="Hdi_DisableResult_Timeout";
1014 std::string value = "on";
1015 std::string parameter;
1016 result = OHOS::system::SetParameter(property, value);
1017 if (result) {
1018 parameter = OHOS::system::GetParameter(property, value);
1019 std::cout << "==========[test log] DFX: GetProperty Hdi_DisableResult_Timeout = " << parameter << std::endl;
1020 Test_->Open();
1021 std::vector<Camera::MetaType> results;
1022 results.push_back(OHOS_SENSOR_EXPOSURE_TIME);
1023 results.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS);
1024 Test_->rc = Test_->cameraDevice->EnableResult(results);
1025 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1026 std::vector<Camera::MetaType> results_original;
1027 Test_->rc = Test_->cameraDevice->GetEnabledResults(results_original);
1028 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1029 std::cout << "==========[test log]GetEnabledResults, size = " << results_original.size() << std::endl;
1030
1031 // disable a tag
1032 std::vector<Camera::MetaType> disable_tag;
1033 disable_tag.push_back(results_original[1]);
1034 Test_->rc = Test_->cameraDevice->DisableResult(disable_tag);
1035 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1036 std::cout << "==========[test log]Check hdi_device: DisableResult the tag:" << results_original[0] << std::endl;
1037
1038 // Get the parameter tag currently supported by the device again
1039 Test_->rc = Test_->cameraDevice->GetEnabledResults(results);
1040 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1041 }
1042 result = OHOS::system::SetParameter(property, "off");
1043 }
1044
1045 /**
1046 * @tc.name: Hdi_Close_Timeout.
1047 * @tc.desc: mock Hdi_Close_Timeout.
1048 * @tc.size: MediumTest
1049 * @tc.type: DFX
1050 */
1051 HWTEST_F(DfxTest, Camera_Dfx_0015, TestSize.Level3)
1052 {
1053 std::cout << "==========[test log] Dfx: mock Hdi_Close_Timeout." << std::endl;
1054 bool result = false;
1055 std::string property="Hdi_Close_Timeout";
1056 std::string value = "on";
1057 std::string parameter;
1058 result = OHOS::system::SetParameter(property, value);
1059 if (result) {
1060 parameter = OHOS::system::GetParameter(property, value);
1061 std::cout << "==========[test log] DFX: GetProperty Hdi_Close_Timeout = " << parameter << std::endl;
1062 Test_->Open();
1063 Test_->Close();
1064 }
1065 result = OHOS::system::SetParameter(property, "off");
1066 }
1067
1068 /**
1069 * @tc.name: Hdi_IsStreamsSupported_Timeout.
1070 * @tc.desc: mock Hdi_IsStreamsSupported_Timeout.
1071 * @tc.size: MediumTest
1072 * @tc.type: DFX
1073 */
1074 HWTEST_F(DfxTest, Camera_Dfx_0020, TestSize.Level3) {
1075 std::cout << "==========[test log] Dfx: mock Hdi_IsStreamsSupported_Timeout." << std::endl;
1076 bool result = false;
1077 std::string property="Hdi_IsStreamsSupported_Timeout";
1078 std::string value = "on";
1079 std::string parameter;
1080 result = OHOS::system::SetParameter(property, value);
1081 if (result) {
1082 parameter = OHOS::system::GetParameter(property, value);
1083 std::cout << "======[test log] DFX: GetProperty Hdi_IsStreamsSupported_Timeout = " << parameter << std::endl;
1084 // Turn on the camera
1085 Test_->Open();
1086 EXPECT_EQ(false, Test_->cameraDevice == nullptr);
1087 // Get streamOperator
1088 Test_->streamOperatorCallback = new StreamOperatorCallback();
1089 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
1090 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1091 // Configure mode and modeSetting
1092 Camera::OperationMode mode = Camera::NORMAL;
1093 std::shared_ptr<CameraMetadata> modeSetting =
1094 std::make_shared<CameraMetadata>(2, 128);
1095 int64_t expoTime = 0;
1096 modeSetting->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &expoTime, 1);
1097 int64_t colorGains[4] = {0};
1098 modeSetting->addEntry(OHOS_SENSOR_COLOR_CORRECTION_GAINS, &colorGains, 4);
1099 // Configure stream information
1100 Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
1101 Test_->streamInfo->streamId_ = 1001; // 1001:streamId
1102 Test_->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
1103 Test_->streamInfo->height_ = 480; // 480:height of stream
1104 Test_->streamInfo->width_ = 640; // 640:width of stream
1105 Test_->streamInfo->datasapce_ = 8;
1106 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
1107 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon1f6d91800702(void* addr, uint32_t size) 1108 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) {
1109 Test_->SaveYUV("preview", addr, size);
1110 });
1111 Test_->streamInfo->bufferQueue_->SetQueueSize(8);
1112 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer;
1113 Test_->streamInfo->intent_ = Camera::PREVIEW;
1114 Test_->streamInfo->tunneledMode_ = 5;
1115 Camera::StreamSupportType pType;
1116 Test_->rc = Test_->streamOperator->IsStreamsSupported(NORMAL, modeSetting, {Test_->streamInfo}, pType);
1117 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1118 EXPECT_NE(pType, NOT_SUPPORTED);
1119 if (Test_->rc == Camera::NO_ERROR) {
1120 std::cout << "==========[test log]Check hdi: IsStreamsSupported success, pType = " << pType << std::endl;
1121 } else {
1122 std::cout << "==========[test log]Check hdi: IsStreamsSupported fail, rc = " << Test_->rc << std::endl;
1123 }
1124 }
1125 result = OHOS::system::SetParameter(property, "off");
1126 }
1127
1128 /**
1129 * @tc.name: Hdi_CreateStreams_Timeout.
1130 * @tc.desc: mock Hdi_CreateStreams_Timeout.
1131 * @tc.size: MediumTest
1132 * @tc.type: DFX
1133 */
1134 HWTEST_F(DfxTest, Camera_Dfx_0021, TestSize.Level3)
1135 {
1136 std::cout << "==========[test log] Dfx: mock Hdi_CreateStreams_Timeout." << std::endl;
1137 bool result = false;
1138 std::string property="Hdi_CreateStreams_Timeout";
1139 std::string value = "on";
1140 std::string parameter;
1141 result = OHOS::system::SetParameter(property, value);
1142 if (result) {
1143 parameter = OHOS::system::GetParameter(property, value);
1144 std::cout << "==========[test log] DFX: GetProperty Hdi_CreateStreams_Timeout = " << parameter << std::endl;
1145 Test_->Open();
1146 // Create and get streamOperator information
1147 Test_->streamOperatorCallback = new StreamOperatorCallback();
1148 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
1149 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr);
1150 // Create data stream
1151 Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
1152 Test_->streamInfo->streamId_ = 1001;
1153 Test_->streamInfo->width_ = 640;
1154 Test_->streamInfo->height_ = 480;
1155 Test_->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
1156 Test_->streamInfo->datasapce_ = 8;
1157 Test_->streamInfo->intent_ = Camera::PREVIEW;
1158 Test_->streamInfo->tunneledMode_ = 5;
1159 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
1160 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon1f6d91800802(void* addr, uint32_t size) 1161 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) {
1162 Test_->SaveYUV("preview", addr, size);
1163 });
1164 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer;
1165 Test_->streamInfos.push_back(Test_->streamInfo);
1166 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
1167 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1168 // release stream
1169 std::vector<int> streamIds;
1170 streamIds.push_back(Test_->streamInfo->streamId_);
1171 Test_->rc = Test_->streamOperator->ReleaseStreams(streamIds);
1172 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1173 }
1174 result = OHOS::system::SetParameter(property, "off");
1175 }
1176
1177 /**
1178 * @tc.name: Hdi_ReleaseStreams_Timeout.
1179 * @tc.desc: mock Hdi_ReleaseStreams_Timeout.
1180 * @tc.size: MediumTest
1181 * @tc.type: DFX
1182 */
1183 HWTEST_F(DfxTest, Camera_Dfx_0022, TestSize.Level3)
1184 {
1185 std::cout << "==========[test log] Dfx: mock Hdi_ReleaseStreams_Timeout." << std::endl;
1186 bool result = false;
1187 std::string property="Hdi_ReleaseStreams_Timeout";
1188 std::string value = "on";
1189 std::string parameter;
1190 result = OHOS::system::SetParameter(property, value);
1191 if (result) {
1192 parameter = OHOS::system::GetParameter(property, value);
1193 std::cout << "==========[test log] DFX: GetProperty Hdi_ReleaseStreams_Timeout = " << parameter << std::endl;
1194 Test_->Open();
1195 // Create and get streamOperator information
1196 Test_->streamOperatorCallback = new StreamOperatorCallback();
1197 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
1198 EXPECT_EQ(false, Test_->rc != Camera::NO_ERROR || Test_->streamOperator == nullptr);
1199 // Create data stream
1200 Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
1201 Test_->streamInfo->streamId_ = 1001;
1202 Test_->streamInfo->width_ = 640;
1203 Test_->streamInfo->height_ = 480;
1204 Test_->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
1205 Test_->streamInfo->datasapce_ = 8;
1206 Test_->streamInfo->intent_ = Camera::PREVIEW;
1207 Test_->streamInfo->tunneledMode_ = 5;
1208 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
1209 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon1f6d91800902(void* addr, uint32_t size) 1210 Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) {
1211 Test_->SaveYUV("preview", addr, size);
1212 });
1213 Test_->consumerMap_[Test_->streamInfo->intent_] = consumer;
1214 Test_->streamInfos.push_back(Test_->streamInfo);
1215 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
1216 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1217 // release stream
1218 std::vector<int> streamIds;
1219 streamIds.push_back(Test_->streamInfo->streamId_);
1220 Test_->rc = Test_->streamOperator->ReleaseStreams(streamIds);
1221 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1222 }
1223 result = OHOS::system::SetParameter(property, "off");
1224 }
1225
1226 /**
1227 * @tc.name: Hdi_CommitStreams_Timeout.
1228 * @tc.desc: mock Hdi_CommitStreams_Timeout.
1229 * @tc.size: MediumTest
1230 * @tc.type: DFX
1231 */
1232 HWTEST_F(DfxTest, Camera_Dfx_0023, TestSize.Level3)
1233 {
1234 std::cout << "==========[test log] Dfx: mock Hdi_CommitStreams_Timeout." << std::endl;
1235 bool result = false;
1236 std::string property="Hdi_CommitStreams_Timeout";
1237 std::string value = "on";
1238 std::string parameter;
1239 result = OHOS::system::SetParameter(property, value);
1240 if (result) {
1241 parameter = OHOS::system::GetParameter(property, value);
1242 std::cout << "==========[test log] DFX: GetProperty Hdi_CommitStreams_Timeout = " << parameter << std::endl;
1243 Test_->Open();
1244 // Start stream
1245 Test_->intents = {Camera::PREVIEW};
1246 Test_->StartStream(Test_->intents);
1247 // release stream
1248 Test_->captureIds = {};
1249 Test_->streamIds = {Test_->streamId_preview};
1250 Test_->StopStream(Test_->captureIds, Test_->streamIds);
1251 Test_->StopConsumer(Test_->intents);
1252 }
1253 result = OHOS::system::SetParameter(property, "off");
1254 }
1255
1256 /**
1257 * @tc.name: Hdi_AttachBufferQueue_Timeout.
1258 * @tc.desc: mock Hdi_AttachBufferQueue_Timeout.
1259 * @tc.size: MediumTest
1260 * @tc.type: DFX
1261 */
1262 HWTEST_F(DfxTest, Camera_Dfx_0024, TestSize.Level3)
1263 {
1264 std::cout << "==========[test log] Dfx: mock Hdi_AttachBufferQueue_Timeout." << std::endl;
1265 bool result = false;
1266 std::string property="Hdi_AttachBufferQueue_Timeout";
1267 std::string value = "on";
1268 std::string parameter;
1269 result = OHOS::system::SetParameter(property, value);
1270 if (result) {
1271 parameter = OHOS::system::GetParameter(property, value);
1272 std::cout << "==========[test log] DFX: GetProperty Hdi_AttachBufferQueue_Timeout = " << parameter << std::endl;
1273 Test_->Open();
1274 Test_->streamOperatorCallback = new StreamOperatorCallback();
1275 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
1276 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1277 // Create data stream
1278 Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
1279 Test_->streamInfo->streamId_ = 1001;
1280 Test_->streamInfo->height_ = 480;
1281 Test_->streamInfo->width_ = 640;
1282 Test_->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
1283 Test_->streamInfo->datasapce_ = 8;
1284 Test_->streamInfo->intent_ = Camera::PREVIEW;
1285 Test_->streamInfo->tunneledMode_ = 5;
1286 std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos);
1287 Test_->streamInfos.push_back(Test_->streamInfo);
1288 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
1289 std::cout << "==========[test log]Check hdi: streamOperator->CreateStreams's rc " << Test_->rc << std::endl;
1290 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1291 // Distribution stream
1292 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability);
1293 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1294 std::cout << "==========[test log]Check hdi: streamOperator->CommitStreams's rc " << Test_->rc << std::endl;
1295 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
1296 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon1f6d91800a02(void* addr, uint32_t size) 1297 OHOS::sptr<OHOS::IBufferProducer> producer = consumer->CreateProducer([this](void* addr, uint32_t size) {
1298 Test_->SaveYUV("preview", addr, size);
1299 });
1300 Test_->rc = Test_->streamOperator->AttachBufferQueue(Test_->streamInfo->streamId_, producer);
1301 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1302 if (Test_->rc == Camera::NO_ERROR) {
1303 std::cout << "==========[test log]Check hdi: AttachBufferQueue success. " << std::endl;
1304 } else {
1305 std::cout << "==========[test log]Check hdi: AttachBufferQueue fail, rc = " << Test_->rc << std::endl;
1306 }
1307 // release stream
1308 Test_->captureIds = {};
1309 Test_->streamIds = {1001};
1310 Test_->StopStream(Test_->captureIds, Test_->streamIds);
1311 Test_->StopConsumer(Test_->intents);
1312 }
1313 result = OHOS::system::SetParameter(property, "off");
1314 }
1315
1316 /**
1317 * @tc.name: Hdi_DetachBufferQueue_Timeout.
1318 * @tc.desc: mock Hdi_DetachBufferQueue_Timeout.
1319 * @tc.size: MediumTest
1320 * @tc.type: DFX
1321 */
1322 HWTEST_F(DfxTest, Camera_Dfx_0025, TestSize.Level3)
1323 {
1324 std::cout << "==========[test log] Dfx: mock Hdi_DetachBufferQueue_Timeout." << std::endl;
1325 bool result = false;
1326 std::string property="Hdi_DetachBufferQueue_Timeout";
1327 std::string value = "on";
1328 std::string parameter;
1329 result = OHOS::system::SetParameter(property, value);
1330 if (result) {
1331 parameter = OHOS::system::GetParameter(property, value);
1332 std::cout << "==========[test log] DFX: GetProperty Hdi_DetachBufferQueue_Timeout = " << parameter << std::endl;
1333 Test_->Open();
1334 Test_->streamOperatorCallback = new StreamOperatorCallback();
1335 Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
1336 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1337 // Create data stream
1338 Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
1339 Test_->streamInfo->streamId_ = 1001;
1340 Test_->streamInfo->width_ = 640;
1341 Test_->streamInfo->height_ = 480;
1342 Test_->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
1343 Test_->streamInfo->intent_ = Camera::PREVIEW;
1344 Test_->streamInfo->datasapce_ = 8;
1345 Test_->streamInfo->tunneledMode_ = 5;
1346 std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos);
1347 Test_->streamInfos.push_back(Test_->streamInfo);
1348 Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
1349 std::cout << "==========[test log]Check hdi: streamOperator->CreateStreams's rc " << Test_->rc << std::endl;
1350 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1351 // Distribution stream
1352 Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability);
1353 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1354 std::cout << "==========[test log]Check hdi: streamOperator->CommitStreams's rc " << Test_->rc << std::endl;
1355 std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
1356 std::make_shared<OHOS::Camera::Test::StreamConsumer>();
__anon1f6d91800b02(void* addr, uint32_t size) 1357 OHOS::sptr<OHOS::IBufferProducer> producer = consumer->CreateProducer([this](void* addr, uint32_t size) {
1358 Test_->SaveYUV("preview", addr, size);
1359 });
1360 Test_->rc = Test_->streamOperator->AttachBufferQueue(Test_->streamInfo->streamId_, producer);
1361 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1362 if (Test_->rc == Camera::NO_ERROR) {
1363 std::cout << "==========[test log]Check hdi: AttachBufferQueue success. " << std::endl;
1364 } else {
1365 std::cout << "==========[test log]Check hdi: AttachBufferQueue fail, rc = " << Test_->rc << std::endl;
1366 }
1367 sleep(3);
1368 Test_->rc = Test_->streamOperator->DetachBufferQueue(Test_->streamInfo->streamId_);
1369 std::cout << "==========[test log]Check hdi: streamOperator->DetachBufferQueue's rc " << Test_->rc << std::endl;
1370 EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
1371 // release stream
1372 Test_->captureIds = {};
1373 Test_->streamIds = {1001};
1374 Test_->StopStream(Test_->captureIds, Test_->streamIds);
1375 Test_->StopConsumer(Test_->intents);
1376 }
1377 result = OHOS::system::SetParameter(property, "off");
1378 }
1379
1380 /**
1381 * @tc.name: Hdi_Capture_Timeout.
1382 * @tc.desc: mock Hdi_Capture_Timeout.
1383 * @tc.size: MediumTest
1384 * @tc.type: DFX
1385 */
1386 HWTEST_F(DfxTest, Camera_Dfx_0026, TestSize.Level3)
1387 {
1388 std::cout << "==========[test log] Dfx: mock Hdi_Capture_Timeout." << std::endl;
1389 bool result = false;
1390 std::string property="Hdi_Capture_Timeout";
1391 std::string value = "on";
1392 std::string parameter;
1393 result = OHOS::system::SetParameter(property, value);
1394 if (result) {
1395 parameter = OHOS::system::GetParameter(property, value);
1396 std::cout << "==========[test log] DFX: GetProperty Hdi_Capture_Timeout = " << parameter << std::endl;
1397 Test_->Open();
1398 // Configure preview stream information
1399 Test_->intents = {Camera::PREVIEW};
1400 Test_->StartStream(Test_->intents);
1401 // Capture preview stream
1402 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, true, true);
1403 // post-processing
1404 Test_->captureIds = {Test_->captureId_preview};
1405 Test_->streamIds = {Test_->streamId_preview};
1406 Test_->StopStream(Test_->captureIds, Test_->streamIds);
1407 Test_->StopConsumer(Test_->intents);
1408 }
1409 result = OHOS::system::SetParameter(property, "off");
1410 }
1411
1412 /**
1413 * @tc.name: Hdi_ChangeToOfflineStream_Timeout.
1414 * @tc.desc: mock Hdi_ChangeToOfflineStream_Timeout.
1415 * @tc.size: MediumTest
1416 * @tc.type: DFX
1417 */
1418 HWTEST_F(DfxTest, Camera_Dfx_0027, TestSize.Level3)
1419 {
1420 std::cout << "==========[test log] Dfx: mock Hdi_ChangeToOfflineStream_Timeout." << std::endl;
1421 bool result = false;
1422 std::string property="Hdi_ChangeToOfflineStream_Timeout";
1423 std::string value = "on";
1424 std::string parameter;
1425 result = OHOS::system::SetParameter(property, value);
1426 if (result) {
1427 parameter = OHOS::system::GetParameter(property, value);
1428 std::cout << "======[test log] DFX: GetProperty Hdi_ChangeToOfflineStream_Timeout = " << parameter << std::endl;
1429 Test_->Open();
1430 // 1. Configure two streams of information
1431 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE};
1432 Test_->StartStream(Test_->intents);
1433 // 2. Capture the preview stream
1434 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
1435 // 3. Capture the camera stream, continuous shooting
1436 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true);
1437 sleep(5);
1438 // 4. Convert to offline stream
1439 Test_->offlineStreamOperatorCallback = Test_->streamOperatorCallback;
1440 Test_->rc = Test_->streamOperator->ChangeToOfflineStream(
1441 {Test_->streamId_capture}, Test_->offlineStreamOperatorCallback, Test_->offlineStreamOperator);
1442 ASSERT_EQ(Test_->rc, Camera::NO_ERROR);
1443 std::cout << "==========[test log] ChangeToOfflineStream rc = " << Test_->rc << std::endl;
1444 EXPECT_EQ(true, Test_->offlineStreamOperator != nullptr);
1445 if (Test_->rc == Camera::NO_ERROR) {
1446 std::cout << "==========[test log] offline StreamOperator != nullptr" << std::endl;
1447 } else {
1448 std::cout << "==========[test log] offline StreamOperator == nullptr" << std::endl;
1449 }
1450 // 5. Post-processing of the original stream
1451 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture};
1452 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture};
1453 Test_->StopStream(Test_->captureIds, Test_->streamIds);
1454 // 6. Post-processing of offline streams
1455 Test_->cameraDevice->Close();
1456 std::cout << "==========[test log] Pretend to wait 5s for callback..." << std::endl;
1457 sleep(5);
1458 Test_->StopOfflineStream(Test_->captureId_capture);
1459 Test_->StopConsumer(Test_->intents);
1460 }
1461 result = OHOS::system::SetParameter(property, "off");
1462 }
1463
1464 /**
1465 * @tc.name: Hdi_Offline_CancelCapture_Timeout.
1466 * @tc.desc: mock Hdi_Offline_ReleaseStreams_Timeout.
1467 * @tc.size: MediumTest
1468 * @tc.type: DFX
1469 */
1470 HWTEST_F(DfxTest, Camera_Dfx_0030, TestSize.Level3)
1471 {
1472 std::cout << "=======[test log] Dfx: mock Hdi_Offline_CancelCapture_Timeout." << std::endl;
1473 bool result = false;
1474 std::string property="Hdi_Offline_CancelCapture_Timeout";
1475 std::string value = "on";
1476 std::string parameter;
1477 result = OHOS::system::SetParameter(property, value);
1478 if (result) {
1479 parameter = OHOS::system::GetParameter(property, value);
1480 std::cout << "====[test log] DFX: GetProperty Hdi_Offline_CancelCapture_Timeout = " << parameter << std::endl;
1481 Test_->Open();
1482 // 1. Configure two streams of information
1483 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE};
1484 Test_->StartStream(Test_->intents);
1485 // 2. Capture the preview stream
1486 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
1487 // 3. Capture the camera stream, continuous shooting
1488 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true);
1489 sleep(5);
1490 // 4. Convert to offline stream
1491 Test_->offlineStreamOperatorCallback = Test_->streamOperatorCallback;
1492 Test_->rc = Test_->streamOperator->ChangeToOfflineStream(
1493 {Test_->streamId_capture}, Test_->offlineStreamOperatorCallback, Test_->offlineStreamOperator);
1494 ASSERT_EQ(Test_->rc, Camera::NO_ERROR);
1495 std::cout << "==========[test log] ChangeToOfflineStream rc = " << Test_->rc << std::endl;
1496 EXPECT_EQ(true, Test_->offlineStreamOperator != nullptr);
1497 if (Test_->rc == Camera::NO_ERROR) {
1498 std::cout << "==========[test log] offline StreamOperator != nullptr" << std::endl;
1499 } else {
1500 std::cout << "==========[test log] offline StreamOperator == nullptr" << std::endl;
1501 }
1502 // 5. Post-processing of the original stream
1503 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture};
1504 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture};
1505 Test_->StopStream(Test_->captureIds, Test_->streamIds);
1506 // 6. Post-processing of offline streams
1507 Test_->cameraDevice->Close();
1508 std::cout << "==========[test log] Pretend to wait 5s for callback..." << std::endl;
1509 sleep(5);
1510 Test_->StopOfflineStream(Test_->captureId_capture);
1511 Test_->StopConsumer(Test_->intents);
1512 }
1513 result = OHOS::system::SetParameter(property, "off");
1514 }
1515
1516 /**
1517 * @tc.name: Hdi_Offline_ReleaseStreams_Timeout.
1518 * @tc.desc: mock Hdi_Offline_ReleaseStreams_Timeout.
1519 * @tc.size: MediumTest
1520 * @tc.type: DFX
1521 */
1522 HWTEST_F(DfxTest, Camera_Dfx_0031, TestSize.Level3)
1523 {
1524 std::cout << "==========[test log] Dfx: mock Hdi_Offline_ReleaseStreams_Timeout." << std::endl;
1525 bool result = false;
1526 std::string property="Hdi_Offline_ReleaseStreams_Timeout";
1527 std::string value = "on";
1528 std::string parameter;
1529 result = OHOS::system::SetParameter(property, value);
1530 if (result) {
1531 parameter = OHOS::system::GetParameter(property, value);
1532 std::cout << "======[test log] DFX: GetProperty Hdi_Offline_ReleaseStreams_Timeout = ";
1533 std::cout << parameter << std::endl;
1534 Test_->Open();
1535 // 1. Configure two streams of information
1536 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE};
1537 Test_->StartStream(Test_->intents);
1538 // 2. Capture the preview stream
1539 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
1540 // 3. Capture the camera stream, continuous shooting
1541 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true);
1542 sleep(5);
1543 // 4. Convert to offline stream
1544 Test_->offlineStreamOperatorCallback = Test_->streamOperatorCallback;
1545 Test_->rc = Test_->streamOperator->ChangeToOfflineStream(
1546 {Test_->streamId_capture}, Test_->offlineStreamOperatorCallback, Test_->offlineStreamOperator);
1547 ASSERT_EQ(Test_->rc, Camera::NO_ERROR);
1548 std::cout << "==========[test log] ChangeToOfflineStream rc = " << Test_->rc << std::endl;
1549 EXPECT_EQ(true, Test_->offlineStreamOperator != nullptr);
1550 if (Test_->rc == Camera::NO_ERROR) {
1551 std::cout << "==========[test log] offline StreamOperator != nullptr" << std::endl;
1552 } else {
1553 std::cout << "==========[test log] offline StreamOperator == nullptr" << std::endl;
1554 }
1555 // 5. Post-processing of the original stream
1556 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture};
1557 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture};
1558 Test_->StopStream(Test_->captureIds, Test_->streamIds);
1559 // 6. Post-processing of offline streams
1560 Test_->cameraDevice->Close();
1561 std::cout << "==========[test log] Pretend to wait 5s for callback..." << std::endl;
1562 sleep(5);
1563 Test_->StopOfflineStream(Test_->captureId_capture);
1564 Test_->StopConsumer(Test_->intents);
1565 }
1566 result = OHOS::system::SetParameter(property, "off");
1567 }
1568
1569 /**
1570 * @tc.name: Hdi_Offline_Release_Timeout.
1571 * @tc.desc: mock Hdi_Offline_Release_Timeout.
1572 * @tc.size: MediumTest
1573 * @tc.type: DFX
1574 */
1575 HWTEST_F(DfxTest, Camera_Dfx_0032, TestSize.Level3)
1576 {
1577 std::cout << "==========[test log] Dfx: mock Hdi_Offline_Release_Timeout." << std::endl;
1578 bool result = false;
1579 std::string property="Hdi_Offline_Release_Timeout";
1580 std::string value = "on";
1581 std::string parameter;
1582 result = OHOS::system::SetParameter(property, value);
1583 if (result) {
1584 parameter = OHOS::system::GetParameter(property, value);
1585 std::cout << "==========[test log] DFX: GetProperty Hdi_Offline_Release_Timeout = " << parameter << std::endl;
1586 Test_->Open();
1587 // 1. Configure two streams of information
1588 Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE};
1589 Test_->StartStream(Test_->intents);
1590 // 2. Capture the preview stream
1591 Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
1592 // 3. Capture the camera stream, continuous shooting
1593 Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true);
1594 sleep(5);
1595 // 4. Convert to offline stream
1596 Test_->offlineStreamOperatorCallback = Test_->streamOperatorCallback;
1597 Test_->rc = Test_->streamOperator->ChangeToOfflineStream(
1598 {Test_->streamId_capture}, Test_->offlineStreamOperatorCallback, Test_->offlineStreamOperator);
1599 ASSERT_EQ(Test_->rc, Camera::NO_ERROR);
1600 std::cout << "==========[test log] ChangeToOfflineStream rc = " << Test_->rc << std::endl;
1601 EXPECT_EQ(true, Test_->offlineStreamOperator != nullptr);
1602 if (Test_->rc == Camera::NO_ERROR) {
1603 std::cout << "==========[test log] offline StreamOperator != nullptr" << std::endl;
1604 } else {
1605 std::cout << "==========[test log] offline StreamOperator == nullptr" << std::endl;
1606 }
1607 // 5. Post-processing of the original stream
1608 Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture};
1609 Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture};
1610 Test_->StopStream(Test_->captureIds, Test_->streamIds);
1611 // 6. Post-processing of offline streams
1612 Test_->cameraDevice->Close();
1613 std::cout << "==========[test log] Pretend to wait 5s for callback..." << std::endl;
1614 sleep(5);
1615 Test_->StopOfflineStream(Test_->captureId_capture);
1616 Test_->StopConsumer(Test_->intents);
1617 }
1618 result = OHOS::system::SetParameter(property, "off");
1619 }
1620 #endif
1621