1 /*
2 * Copyright (C) 2020-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "camera_lite_test.h"
17
18 #include <components/ui_surface_view.h>
19 #include <sys/stat.h>
20 #include <sys/time.h>
21 #include <sys/types.h>
22
23 #include <algorithm>
24 #include <cstdlib>
25 #include <fstream>
26 #include <iostream>
27 #include <memory>
28 #include <sstream>
29 #include <string>
30
31 #include "camera_kit.h"
32
33 using namespace std;
34 using namespace OHOS;
35 using namespace OHOS::Media;
36 using namespace testing::ext;
37
38 namespace OHOS {
39 /* *
40 * get current dir
41 * @return string current file path of the test suites
42 */
GetCurDir()43 string GetCurDir()
44 {
45 string filePath = "";
46 char *buffer;
47 if ((buffer = getcwd(NULL, 0)) == NULL) {
48 perror("get file path error");
49 } else {
50 printf("Current Dir: %s\r\n", buffer);
51 filePath = buffer;
52 free(buffer);
53 }
54 return filePath + "/";
55 }
56
57 // SetUpTestCase
SetUpTestCase(void)58 void CameraLiteTest::SetUpTestCase(void)
59 {
60 g_testPath = GetCurDir();
61 cout << "SetUpTestCase" << endl;
62 }
63
64 // TearDownTestCase
TearDownTestCase(void)65 void CameraLiteTest::TearDownTestCase(void)
66 {
67 g_testPath = "";
68 cout << "TearDownTestCase" << endl;
69 }
70
SetUp(void)71 void CameraLiteTest::SetUp(void)
72 {
73 // CameraSetUp
74 g_onGetCameraAbilityFlag = false;
75 g_onConfigureFlag = false;
76 g_onGetSupportedSizesFlag = false;
77
78 // CameraDeviceCallBack
79 g_onCameraAvailableFlag = false;
80 g_onCameraUnavailableFlag = false;
81
82 // CameraStateCallback
83 g_onCreatedFlag = false;
84 g_onCreateFailedFlag = false;
85 g_onConfiguredFlag = false;
86 g_onConfigureFailedFlag = false;
87 g_onReleasedFlag = false;
88
89 // FrameStateCallback
90 g_onCaptureTriggerAbortedFlag = false;
91 g_onCaptureTriggerCompletedFlag = false;
92 g_onCaptureTriggerStartedFlag = false;
93 g_onFrameFinishedFlag = false;
94 g_onGetFrameConfigureType = false;
95 g_onFrameErrorFlag = false;
96 g_onFrameProgressedFlag = false;
97 g_onFrameStartedFlag = false;
98 g_onRecorderFlag = false;
99 cout << "SetUp" << endl;
100 }
101
102 // Tear down
TearDown(void)103 void CameraLiteTest::TearDown(void)
104 {
105 cout << "TearDown." << endl;
106 }
107
SetupAudioSource(const Recorder & rec)108 int32_t SetupAudioSource(const Recorder &rec)
109 {
110 Recorder *recorder = (Recorder *)&rec;
111 int32_t ret = SUCCESS;
112 int32_t audioSourceId = 0;
113 AudioCodecFormat audioFormat = AAC_LC;
114 AudioSourceType inputSource = AUDIO_MIC;
115 int32_t sampleRate = 48000;
116 int32_t channelCount = 1;
117 int32_t audioEncodingBitRate = sampleRate;
118 if ((ret = recorder->SetAudioSource(inputSource, audioSourceId)) != SUCCESS) {
119 cout << "SetAudioSource failed." << ret << endl;
120 return FAIL;
121 }
122 if ((ret = recorder->SetAudioEncoder(audioSourceId, audioFormat)) != SUCCESS) {
123 cout << "SetAudioEncoder failed." << ret << endl;
124 return FAIL;
125 }
126 if ((ret = recorder->SetAudioSampleRate(audioSourceId, sampleRate)) != SUCCESS) {
127 cout << "SetAudioSampleRate failed." << ret << endl;
128 return FAIL;
129 }
130 if ((ret = recorder->SetAudioChannels(audioSourceId, channelCount)) != SUCCESS) {
131 cout << "SetAudioChannels failed." << ret << endl;
132 return FAIL;
133 }
134 if ((ret = recorder->SetAudioEncodingBitRate(audioSourceId, audioEncodingBitRate)) != SUCCESS) {
135 cout << "SetAudioEncodingBitRate failed." << ret << endl;
136 return FAIL;
137 }
138 return SUCCESS;
139 }
140
141 /* *
142 * create Recorder
143 */
SampleCreateRecorder()144 Recorder *SampleCreateRecorder()
145 {
146 int ret = 0;
147 VideoSourceType source = VIDEO_SOURCE_SURFACE_ES;
148 int32_t frameRate = 30;
149 double fps = 30;
150 int32_t rate = 4096;
151 int32_t sourceId = 0;
152 int32_t width = 1920;
153 int32_t height = 1080;
154 VideoCodecFormat encoder = HEVC;
155 Recorder *recorder = new Recorder();
156 if ((ret = recorder->SetVideoSource(source, sourceId)) != SUCCESS) {
157 cout << "SetVideoSource failed." << ret << endl;
158 delete recorder;
159 return nullptr;
160 }
161 if ((ret = recorder->SetVideoEncoder(sourceId, encoder)) != SUCCESS) {
162 cout << "SetVideoEncoder failed." << ret << endl;
163 delete recorder;
164 return nullptr;
165 }
166 if ((ret = recorder->SetVideoSize(sourceId, width, height)) != SUCCESS) {
167 cout << "SetVideoSize failed." << ret << endl;
168 delete recorder;
169 return nullptr;
170 }
171 if ((ret = recorder->SetVideoFrameRate(sourceId, frameRate)) != SUCCESS) {
172 cout << "SetVideoFrameRate failed." << ret << endl;
173 delete recorder;
174 return nullptr;
175 }
176 if ((ret = recorder->SetVideoEncodingBitRate(sourceId, rate)) != SUCCESS) {
177 cout << "SetVideoEncodingBitRate failed." << ret << endl;
178 delete recorder;
179 return nullptr;
180 }
181 if ((ret = recorder->SetCaptureRate(sourceId, fps)) != SUCCESS) {
182 cout << "SetCaptureRate failed." << ret << endl;
183 delete recorder;
184 return nullptr;
185 }
186 if ((ret = SetupAudioSource(*recorder) != SUCCESS)) {
187 delete recorder;
188 return nullptr;
189 }
190 return recorder;
191 }
192
193 /* *
194 * Create Frame StateCallback
195 */
196 class SampleFrameStateCallback : public FrameStateCallback {
197 /* *
198 * check file exist
199 *
200 * @param filename the filename
201 * @return check result
202 */
FileCheck(const string & filename)203 int32_t FileCheck(const string &filename)
204 {
205 fstream fileTmp;
206 fileTmp.open(filename);
207 if (!fileTmp) {
208 cout << "file is not exist!" << endl;
209 return RET_ERR;
210 } else {
211 cout << "file is exist!" << endl;
212 fileTmp.close();
213 return RET_OK;
214 }
215 }
216
217 /* *
218 * Save Capture
219 *
220 * @param testPath the file path
221 * @param buffer the buffer
222 * @param size the size
223 * @return save result
224 */
SampleSaveCapture(string testPath,const char * buffer,uint32_t size)225 int32_t SampleSaveCapture(string testPath, const char *buffer, uint32_t size)
226 {
227 cout << "Start saving picture" << endl;
228 string filePath = "";
229 struct timeval tv = {0};
230
231 gettimeofday(&tv, NULL);
232 struct tm *ltm = localtime(&tv.tv_sec);
233 if (ltm != nullptr) {
234 ostringstream ss("Capture_");
235 ss << "Capture" << ltm->tm_hour << "_" << ltm->tm_min << "_" << ltm->tm_sec << ".jpg";
236 filePath = testPath + ss.str();
237 ofstream pic(testPath + ss.str(), ofstream::out | ofstream::trunc);
238 cout << "write " << size << " bytes" << endl;
239 pic.write(buffer, size);
240 cout << "Saving picture end" << endl;
241 }
242 const char *filename = filePath.data();
243 int32_t ret = FileCheck(string(filename));
244 return ret;
245 }
246
OnFrameFinished(Camera & cam,FrameConfig & fc,FrameResult & res)247 void OnFrameFinished(Camera &cam, FrameConfig &fc, FrameResult &res) override
248 {
249 g_onFrameStartedFlag = true;
250 g_onFrameProgressedFlag = true;
251 cout << "Receive frame complete inform." << endl;
252 if (fc.GetFrameConfigType() == FRAME_CONFIG_CAPTURE) {
253 g_onGetFrameConfigureType = true;
254 cout << "Capture frame received." << endl;
255 list<Surface *> surfaceList = fc.GetSurfaces();
256 for (Surface *surface : surfaceList) {
257 SurfaceBuffer *buffer = surface->AcquireBuffer();
258 if (buffer != nullptr) {
259 char *virtAddr = static_cast<char *>(buffer->GetVirAddr());
260 if (virtAddr != nullptr) {
261 SampleSaveCapture(g_testPath, virtAddr, buffer->GetSize());
262 } else {
263 g_onFrameErrorFlag = true;
264 }
265 surface->ReleaseBuffer(buffer);
266 } else {
267 g_onFrameErrorFlag = true;
268 }
269 delete surface;
270 }
271 delete &fc;
272 } else {
273 g_onFrameErrorFlag = true;
274 }
275 g_onFrameFinishedFlag = true;
276 }
277 };
278
279 /* *
280 * create CameraStateCallback
281 */
282 class SampleCameraStateMng : public CameraStateCallback {
283 public:
284 SampleCameraStateMng() = delete;
285
SampleCameraStateMng(EventHandler & eventHdlr)286 explicit SampleCameraStateMng(EventHandler &eventHdlr) : eventHandler_(eventHdlr) {}
287
~SampleCameraStateMng()288 ~SampleCameraStateMng()
289 {
290 if (recorder_ != nullptr) {
291 recorder_->Release();
292 }
293 if (cam_ != nullptr) {
294 cam_->Release();
295 }
296 }
297
OnCreated(Camera & c)298 void OnCreated(Camera &c) override
299 {
300 g_onCreatedFlag = true;
301 cout << "Sample recv OnCreate camera." << endl;
302 auto config = CameraConfig::CreateCameraConfig();
303 config->SetFrameStateCallback(&fsCb, &eventHandler_);
304 c.Configure(*config);
305 g_onConfigureFlag = true;
306 cam_ = &c;
307 }
308
OnCreateFailed(const std::string cameraId,int32_t errorCode)309 void OnCreateFailed(const std::string cameraId, int32_t errorCode) override
310 {
311 g_onCreateFailedFlag = true;
312 cout << "Camera ID: " << cameraId << endl;
313 cout << "Sample recv OnCreateFailed camera.: " << errorCode << endl;
314 }
315
OnReleased(Camera & c)316 void OnReleased(Camera &c) override
317 {
318 g_onReleasedFlag = true;
319 cout << "Sample recv OnReleased camera." << endl;
320 }
321
StartRecord()322 void StartRecord()
323 {
324 int ret;
325 if (isRecording_) {
326 cout << "Camera is already recording." << endl;
327 return;
328 }
329 if (recorder_ != nullptr) {
330 cout << "Recorder is not null" << endl;
331 }
332 recorder_ = SampleCreateRecorder();
333 if (recorder_ == nullptr) {
334 cout << "Recorder not available" << endl;
335 return;
336 }
337 string path = GetCurDir();
338 ret = recorder_->SetOutputPath(path);
339 if (ret != SUCCESS) {
340 cout << "SetOutputPath failed :" << ret << std::endl;
341 return;
342 }
343
344 ret = recorder_->Prepare();
345 if (ret != SUCCESS) {
346 cout << "Prepare failed.=" << ret << endl;
347 return;
348 }
349 auto surface = recorder_->GetSurface(0);
350 surface->SetWidthAndHeight(WIDTH, HEIGHT);
351 surface->SetQueueSize(QUEUE_SIZE);
352 surface->SetSize(BUFFER_SIZE * BUFFER_SIZE);
353 FrameConfig *fc = new FrameConfig(FRAME_CONFIG_RECORD);
354 fc->AddSurface(*surface);
355 ret = recorder_->Start();
356 if (ret != SUCCESS) {
357 cout << "recorder start failed. ret=" << ret << endl;
358 delete fc;
359 return;
360 }
361 static int cnt = 3;
362 while (cam_ == nullptr) {
363 if (cnt-- < 0)
364 break;
365 cout << "Wait camera created success" << endl;
366 sleep(1);
367 }
368 if (cam_ ==nullptr) {
369 cout << "StartRecord camera created failed is cam_ is nullptr" << endl;
370 return;
371 }
372 ret = cam_->TriggerLoopingCapture(*fc);
373 if (ret != 0) {
374 cout << "camera start recording failed. ret=" << ret << endl;
375 return;
376 }
377 isRecording_ = true;
378 g_onRecorderFlag = true;
379 cout << "camera start recording succeed." << endl;
380 }
381
StartPreview()382 void StartPreview()
383 {
384 if (isPreviewing_) {
385 cout << "Camera is already previewing." << endl;
386 return;
387 }
388 FrameConfig *fc = new FrameConfig(FRAME_CONFIG_PREVIEW);
389 UISurfaceView *surface = new UISurfaceView();
390 int width = 960;
391 int height = 480;
392 if (surface == nullptr) {
393 cout << "CreateSurface failed" << endl;
394 delete fc;
395 return;
396 }
397 surface->SetPosition(0, 0, width, height);
398 surface->GetSurface()->SetWidthAndHeight(WIDTH, HEIGHT);
399 fc->AddSurface(*(surface->GetSurface()));
400 static int cnt = 3;
401 while (cam_ == nullptr) {
402 if (cnt-- < 0)
403 break;
404 cout << "Wait camera created success" << endl;
405 sleep(1);
406 }
407 if (cam_ ==nullptr) {
408 cout << "StartPreview camera created failed is cam_ is nullptr" << endl;
409 return;
410 }
411 int32_t ret = cam_->TriggerLoopingCapture(*fc);
412 if (ret != 0) {
413 cout << "camera start preview failed. ret=" << ret << endl;
414 delete fc;
415 return;
416 }
417 delete surface;
418 isPreviewing_ = true;
419 g_onPreviewFlag = true;
420 cout << "camera start preview succeed." << endl;
421 }
422
Capture(void)423 void Capture(void)
424 {
425 FrameConfig *fc = new FrameConfig(FRAME_CONFIG_CAPTURE);
426 Surface *surface = Surface::CreateSurface();
427 if (surface == nullptr) {
428 cout << "CreateSurface failed" << endl;
429 delete fc;
430 return;
431 }
432 surface->SetWidthAndHeight(WIDTH, HEIGHT);
433 fc->AddSurface(*surface);
434 static int cnt = 3;
435 while (cam_ == nullptr) {
436 if (cnt-- < 0)
437 break;
438 cout << "Wait camera created success" << endl;
439 sleep(1);
440 }
441 if (cam_ ==nullptr) {
442 cout << "Capture camera created failed is cam_ is nullptr" << endl;
443 return;
444 }
445 g_onCaptureTriggerStartedFlag = true;
446 cam_->TriggerSingleCapture(*fc);
447 g_onCaptureTriggerCompletedFlag = true;
448 }
449
Stop()450 void Stop()
451 {
452 if (recorder_ != nullptr) {
453 int32_t ret = recorder_->Stop(true);
454 if (ret != 0) {
455 cout << "recorder_ stop failed. ret=" << ret << endl;
456 }
457 }
458
459 if (cam_ == nullptr) {
460 cout << "Camera is not ready." << endl;
461 return;
462 }
463 cam_->StopLoopingCapture(-1);
464 isPreviewing_ = false;
465 isRecording_ = false;
466 g_onRecorderFlag = false;
467 g_onPreviewFlag = false;
468 }
469
470 bool isPreviewing_ = false;
471 bool isRecording_ = false;
472 EventHandler &eventHandler_;
473 Camera *cam_ = nullptr;
474 Recorder *recorder_ = nullptr;
475 SampleFrameStateCallback fsCb;
476 };
477
478 /* *
479 * create CameraStateCallback for state test
480 */
481 class SampleCameraStateCallback : public CameraStateCallback {
482 public:
483 SampleCameraStateCallback() = delete;
484
SampleCameraStateCallback(EventHandler & eventHdlr)485 explicit SampleCameraStateCallback(EventHandler &eventHdlr) : eventHandler_(eventHdlr) {}
486
~SampleCameraStateCallback()487 ~SampleCameraStateCallback()
488 {
489 if (cam_ != nullptr) {
490 cam_->Release();
491 }
492 }
493
OnCreated(Camera & c)494 void OnCreated(Camera &c) override
495 {
496 g_onCreatedFlag = true;
497 cout << "camera Create success." << endl;
498 auto config = CameraConfig::CreateCameraConfig();
499 config->SetFrameStateCallback(&fsCb, &eventHandler_);
500 c.Configure(*config);
501 cam_ = &c;
502 }
503
OnCreateFailed(const std::string cameraId,int32_t errorCode)504 void OnCreateFailed(const std::string cameraId, int32_t errorCode) override
505 {
506 g_onCreateFailedFlag = true;
507 cout << "Camera ID: " << cameraId << endl;
508 cout << "Camera Create Failed: " << errorCode << endl;
509 }
510
OnReleased(Camera & c)511 void OnReleased(Camera &c) override
512 {
513 g_onReleasedFlag = true;
514 cout << "camera Releasedsuccess." << endl;
515 }
516
OnConfigured(Camera & c)517 void OnConfigured(Camera &c) override
518 {
519 g_onConfiguredFlag = true;
520 cout << "Camera Configured success." << endl;
521 }
522
OnConfigureFailed(const std::string cameraId,int32_t errorCode)523 void OnConfigureFailed(const std::string cameraId, int32_t errorCode) override
524 {
525 g_onConfigureFailedFlag = true;
526 cout << "Camera ID: " << cameraId << endl;
527 cout << "Camera Configured failed: " << errorCode << endl;
528 }
529
530 EventHandler &eventHandler_;
531 Camera *cam_ = nullptr;
532 SampleFrameStateCallback fsCb;
533 };
534
535 /* *
536 * Create camera device callback
537 */
538 class SampleCameraDeviceCallback : public CameraDeviceCallback {
539 public:
SampleCameraDeviceCallback()540 SampleCameraDeviceCallback() {}
541
~SampleCameraDeviceCallback()542 ~SampleCameraDeviceCallback() {}
543
OnCameraStatus(std::string cameraId,int32_t status)544 void OnCameraStatus(std::string cameraId, int32_t status) override
545 {
546 cout << "SampleCameraDeviceCallback OnCameraStatus cam Id: \n" << cameraId << endl;
547 if (status == CAMERA_DEVICE_STATE_AVAILABLE) {
548 g_onCameraAvailableFlag = true;
549 cout << "SampleCameraDeviceCallback onCameraAvailable\n" << endl;
550 } else if (status == CAMERA_DEVICE_STATE_UNAVAILABLE) {
551 g_onCameraUnavailableFlag = true;
552 cout << "SampleCameraDeviceCallback onCameraUnavailable\n" << endl;
553 }
554 }
555 };
556
557 /* *
558 * Get camera Id
559 */
GetCameraId(CameraKit * cameraKit,list<string> & cameraList,string & cameraId)560 bool GetCameraId(CameraKit *cameraKit, list<string> &cameraList, string &cameraId)
561 {
562 cameraKit = CameraKit::GetInstance();
563 cameraList = cameraKit->GetCameraIds();
564 for (auto &cam : cameraList) {
565 cout << "camera name:" << cam << endl;
566 const CameraAbility *ability = cameraKit->GetCameraAbility(cam);
567 g_onGetCameraAbilityFlag = true;
568 /* find camera which fits user's ability */
569 list<CameraPicSize> sizeList = ability->GetSupportedSizes(0);
570 if (sizeList.size() != 0) {
571 g_onGetSupportedSizesFlag = true;
572 }
573 for (auto &pic : sizeList) {
574 cout << "Pic size: " << pic.width << "x" << pic.height << endl;
575 if (pic.width == WIDTH && pic.height == HEIGHT) {
576 /* 1920:width,1080:height */
577 cameraId = cam;
578 break;
579 }
580 }
581 }
582
583 if (cameraId.empty()) {
584 cout << "No available camera.(1080p wanted)" << endl;
585 return false;
586 } else
587 return true;
588 }
589
590 /* start camera kit interface test */
HWTEST_F(CameraLiteTest,Test_GetInstance_001,Level1)591 HWTEST_F(CameraLiteTest, Test_GetInstance_001, Level1)
592 {
593 CameraKit *cameraKit = CameraKit::GetInstance();
594 EXPECT_NE(cameraKit, nullptr);
595 }
596
HWTEST_F(CameraLiteTest,PrfTest_GetInstance_001,Level1)597 HWTEST_F(CameraLiteTest, PrfTest_GetInstance_001, Level1)
598 {
599 CameraKit *cameraKit = nullptr;
600 struct timespec tv1 = {0};
601 struct timespec tv2 = {0};
602 int64_t performanceTestTimes = 10;
603 int64_t usecTimes = 1000000;
604 int64_t totalTime = 0;
605 for (int32_t i = 0; i < performanceTestTimes; i++) {
606 clock_gettime(CLOCK_REALTIME, &tv1);
607 cameraKit = CameraKit::GetInstance();
608 clock_gettime(CLOCK_REALTIME, &tv2);
609 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
610 }
611 int64_t expectTime = 1000000;
612 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
613 }
614
HWTEST_F(CameraLiteTest,Test_GetCameraIds_001,Level1)615 HWTEST_F(CameraLiteTest, Test_GetCameraIds_001, Level1)
616 {
617 CameraKit *cameraKit = CameraKit::GetInstance();
618 list<string> cameraList = cameraKit->GetCameraIds();
619 EXPECT_TRUE(cameraList.size() > 0);
620 }
621
HWTEST_F(CameraLiteTest,PrfTest_GetCameraIds_001,Level1)622 HWTEST_F(CameraLiteTest, PrfTest_GetCameraIds_001, Level1)
623 {
624 CameraKit *cameraKit = CameraKit::GetInstance();
625 list<string> cameraList;
626 struct timespec tv1 = {0};
627 struct timespec tv2 = {0};
628 int64_t performanceTestTimes = 10;
629 int64_t usecTimes = 1000000;
630 int64_t totalTime = 0;
631 for (int32_t i = 0; i < performanceTestTimes; i++) {
632 clock_gettime(CLOCK_REALTIME, &tv1);
633 cameraList = cameraKit->GetCameraIds();
634 clock_gettime(CLOCK_REALTIME, &tv2);
635 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
636 }
637 int64_t expectTime = 1000000;
638 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
639 }
640
HWTEST_F(CameraLiteTest,Test_GetCameraAbility_001,Level1)641 HWTEST_F(CameraLiteTest, Test_GetCameraAbility_001, Level1)
642 {
643 CameraKit *cameraKit = CameraKit::GetInstance();
644 string cameraId = "0";
645 const CameraAbility *ability = cameraKit->GetCameraAbility(cameraId);
646 EXPECT_NE(ability, nullptr);
647 }
648
HWTEST_F(CameraLiteTest,Test_GetCameraAbility_002,Level1)649 HWTEST_F(CameraLiteTest, Test_GetCameraAbility_002, Level1)
650 {
651 CameraKit *cameraKit = CameraKit::GetInstance();
652 string errorCameraId = "-1";
653 const CameraAbility *ability = cameraKit->GetCameraAbility(errorCameraId);
654 EXPECT_EQ(ability, nullptr);
655 }
656
HWTEST_F(CameraLiteTest,Test_GetCameraAbility_003,Level1)657 HWTEST_F(CameraLiteTest, Test_GetCameraAbility_003, Level1)
658 {
659 CameraKit *cameraKit = CameraKit::GetInstance();
660 string errorCameraId = "main";
661 const CameraAbility *ability = cameraKit->GetCameraAbility(errorCameraId);
662 EXPECT_EQ(ability, nullptr);
663 }
664
HWTEST_F(CameraLiteTest,PrfTest_GetCameraAbility_001,Level1)665 HWTEST_F(CameraLiteTest, PrfTest_GetCameraAbility_001, Level1)
666 {
667 CameraKit *cameraKit = CameraKit::GetInstance();
668 const CameraAbility *ability = nullptr;
669 string cameraId = "0";
670 struct timespec tv1 = {0};
671 struct timespec tv2 = {0};
672 int64_t performanceTestTimes = 10;
673 int64_t usecTimes = 1000000;
674 int64_t totalTime = 0;
675 for (int32_t i = 0; i < performanceTestTimes; i++) {
676 clock_gettime(CLOCK_REALTIME, &tv1);
677 ability = cameraKit->GetCameraAbility(cameraId);
678 clock_gettime(CLOCK_REALTIME, &tv2);
679 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
680 }
681 int64_t expectTime = 1000000;
682 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
683 }
684
HWTEST_F(CameraLiteTest,Test_GetCameraInfo_001,Level1)685 HWTEST_F(CameraLiteTest, Test_GetCameraInfo_001, Level1)
686 {
687 CameraKit *cameraKit = CameraKit::GetInstance();
688 list<string> cameraList = cameraKit->GetCameraIds();
689 for (auto &cameraId : cameraList) {
690 const CameraInfo *cameraInfo = cameraKit->GetCameraInfo(cameraId);
691 EXPECT_NE(cameraInfo, nullptr);
692 }
693 }
694
HWTEST_F(CameraLiteTest,Test_GetCameraInfo_002,Level1)695 HWTEST_F(CameraLiteTest, Test_GetCameraInfo_002, Level1)
696 {
697 CameraKit *cameraKit = CameraKit::GetInstance();
698 string errorCameraId = "-1";
699 const CameraInfo *cameraInfo = cameraKit->GetCameraInfo(errorCameraId);
700 EXPECT_EQ(cameraInfo, nullptr);
701 }
702
HWTEST_F(CameraLiteTest,Test_GetCameraInfo_003,Level1)703 HWTEST_F(CameraLiteTest, Test_GetCameraInfo_003, Level1)
704 {
705 CameraKit *cameraKit = CameraKit::GetInstance();
706 string errorCameraId = "main";
707 const CameraInfo *cameraInfo = cameraKit->GetCameraInfo(errorCameraId);
708 EXPECT_EQ(cameraInfo, nullptr);
709 }
710
HWTEST_F(CameraLiteTest,PrfTest_GetCameraInfo_001,Level1)711 HWTEST_F(CameraLiteTest, PrfTest_GetCameraInfo_001, Level1)
712 {
713 struct timespec tv1 = {0};
714 struct timespec tv2 = {0};
715 CameraKit *cameraKit = CameraKit::GetInstance();
716 string cameraId = "0";
717 int64_t performanceTestTimes = 10;
718 int64_t usecTimes = 1000000;
719 int64_t totalTime = 0;
720 for (int32_t i = 0; i < performanceTestTimes; i++) {
721 clock_gettime(CLOCK_REALTIME, &tv1);
722 cameraKit->GetCameraInfo(cameraId);
723 clock_gettime(CLOCK_REALTIME, &tv2);
724 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
725 }
726 int64_t expectTime = 1000000;
727 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
728 }
729
HWTEST_F(CameraLiteTest,Test_RegisterCameraDeviceCallback_001,Level1)730 HWTEST_F(CameraLiteTest, Test_RegisterCameraDeviceCallback_001, Level1)
731 {
732 CameraKit *cameraKit = nullptr;
733 list<string> cameraList;
734 string cameraId;
735 EventHandler eventHdlr;
736 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
737 SampleCameraStateMng camStateMng(eventHdlr);
738 SampleCameraDeviceCallback deviceCallback = SampleCameraDeviceCallback();
739 g_onCameraAvailableFlag = false;
740 cameraKit->RegisterCameraDeviceCallback(deviceCallback, eventHdlr);
741 sleep(2);
742 EXPECT_TRUE(g_onCameraAvailableFlag);
743 }
744
HWTEST_F(CameraLiteTest,PrfTest_RegisterCameraDeviceCallback_001,Level1)745 HWTEST_F(CameraLiteTest, PrfTest_RegisterCameraDeviceCallback_001, Level1)
746 {
747 CameraKit *cameraKit = nullptr;
748 list<string> cameraList;
749 string cameraId;
750 EventHandler eventHdlr;
751 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
752 SampleCameraStateMng camStateMng(eventHdlr);
753 SampleCameraDeviceCallback deviceCallback = SampleCameraDeviceCallback();
754 struct timespec tv1 = {0};
755 struct timespec tv2 = {0};
756 int64_t performanceTestTimes = 10;
757 int64_t usecTimes = 1000000;
758 int64_t totalTime = 0;
759 for (int32_t i = 0; i < performanceTestTimes; i++) {
760 clock_gettime(CLOCK_REALTIME, &tv1);
761 cameraKit->RegisterCameraDeviceCallback(deviceCallback, eventHdlr);
762 clock_gettime(CLOCK_REALTIME, &tv2);
763 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
764 }
765 int64_t expectTime = 1000000;
766 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
767 }
768
HWTEST_F(CameraLiteTest,Test_UnregisterCameraDeviceCallback_001,Level1)769 HWTEST_F(CameraLiteTest, Test_UnregisterCameraDeviceCallback_001, Level1)
770 {
771 CameraKit *cameraKit = nullptr;
772 list<string> cameraList;
773 string cameraId;
774 EventHandler eventHdlr;
775 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
776 SampleCameraStateMng camStateMng(eventHdlr);
777 SampleCameraDeviceCallback deviceCallback = SampleCameraDeviceCallback();
778 g_onCameraAvailableFlag = false;
779 cameraKit->RegisterCameraDeviceCallback(deviceCallback, eventHdlr);
780 sleep(2);
781 EXPECT_EQ(g_onCameraAvailableFlag, true);
782 g_onCameraAvailableFlag = false;
783 cameraKit->UnregisterCameraDeviceCallback(deviceCallback);
784 sleep(2);
785 EXPECT_EQ(g_onCameraAvailableFlag, false);
786 }
787
HWTEST_F(CameraLiteTest,PrfTest_UnregisterCameraDeviceCallback_001,Level1)788 HWTEST_F(CameraLiteTest, PrfTest_UnregisterCameraDeviceCallback_001, Level1)
789 {
790 CameraKit *cameraKit = nullptr;
791 list<string> cameraList;
792 string cameraId;
793 EventHandler eventHdlr;
794 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
795 SampleCameraStateMng camStateMng(eventHdlr);
796 SampleCameraDeviceCallback deviceCallback = SampleCameraDeviceCallback();
797 struct timespec tv1 = {0};
798 struct timespec tv2 = {0};
799 int64_t performanceTestTimes = 10;
800 int64_t usecTimes = 1000000;
801 int64_t totalTime = 0;
802 for (int32_t i = 0; i < performanceTestTimes; i++) {
803 cameraKit->RegisterCameraDeviceCallback(deviceCallback, eventHdlr);
804 clock_gettime(CLOCK_REALTIME, &tv1);
805 cameraKit->UnregisterCameraDeviceCallback(deviceCallback);
806 clock_gettime(CLOCK_REALTIME, &tv2);
807 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
808 }
809 int64_t expectTime = 1000000;
810 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
811 }
812
HWTEST_F(CameraLiteTest,Test_CreateCamera_001,Level1)813 HWTEST_F(CameraLiteTest, Test_CreateCamera_001, Level1)
814 {
815 CameraKit *cameraKit = CameraKit::GetInstance();
816 string cameraId = "0";
817 EventHandler eventHdlr;
818 SampleCameraStateMng camStateMng(eventHdlr);
819 g_onCreatedFlag = false;
820 g_onCreateFailedFlag = false;
821 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
822 sleep(2);
823 EXPECT_EQ(g_onCreatedFlag, true);
824 EXPECT_EQ(g_onCreateFailedFlag, false);
825 }
826
HWTEST_F(CameraLiteTest,Test_CreateCamera_002,Level1)827 HWTEST_F(CameraLiteTest, Test_CreateCamera_002, Level1)
828 {
829 CameraKit *cameraKit = CameraKit::GetInstance();
830 string cameraId = "main";
831 EventHandler eventHdlr;
832 SampleCameraStateMng camStateMng(eventHdlr);
833 g_onCreatedFlag = false;
834 g_onCreateFailedFlag = false;
835 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
836 sleep(2);
837 EXPECT_EQ(g_onCreatedFlag, false);
838 EXPECT_EQ(g_onCreateFailedFlag, true);
839 }
840
HWTEST_F(CameraLiteTest,Test_CreateCamera_003,Level1)841 HWTEST_F(CameraLiteTest, Test_CreateCamera_003, Level1)
842 {
843 CameraKit *cameraKit = CameraKit::GetInstance();
844 list<string> cameraList;
845 string cameraId = "0";
846 EventHandler eventHdlr;
847 g_onCreatedFlag = false;
848 g_onCreateFailedFlag = false;
849 SampleCameraStateMng camStateMng(eventHdlr);
850 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
851 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
852 sleep(2);
853 EXPECT_EQ(g_onCreatedFlag, true);
854 }
855
HWTEST_F(CameraLiteTest,Test_CreateCamera_004,Level1)856 HWTEST_F(CameraLiteTest, Test_CreateCamera_004, Level1)
857 {
858 CameraKit *cameraKit = CameraKit::GetInstance();
859 string cameraId = "0";
860 EventHandler eventHdlr;
861 g_onCreatedFlag = false;
862 g_onCreateFailedFlag = false;
863 SampleCameraStateMng camStateMng(eventHdlr);
864 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
865 sleep(2);
866 cameraId = "-1";
867 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
868 sleep(2);
869 EXPECT_EQ(g_onCreatedFlag, true);
870 EXPECT_EQ(g_onCreateFailedFlag, true);
871 }
872
HWTEST_F(CameraLiteTest,PrfTest_CreateCamera_001,Level1)873 HWTEST_F(CameraLiteTest, PrfTest_CreateCamera_001, Level1)
874 {
875 CameraKit *cameraKit = CameraKit::GetInstance();
876 string cameraId = "0";
877 EventHandler eventHdlr;
878 SampleCameraStateMng camStateMng(eventHdlr);
879 struct timespec tv1 = {0};
880 struct timespec tv2 = {0};
881 int64_t performanceTestTimes = 10;
882 int64_t totalTime = 0;
883 int64_t usecTimes = 1000000;
884 for (int32_t i = 0; i < performanceTestTimes; i++) {
885 clock_gettime(CLOCK_REALTIME, &tv1);
886 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
887 clock_gettime(CLOCK_REALTIME, &tv2);
888 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
889 }
890 int64_t expectTime = 500000000;
891 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
892 } /* end camera kit interface test */
893
894 /* start camera ability interface test */
HWTEST_F(CameraLiteTest,Test_GetSupportedSizes_001,Level1)895 HWTEST_F(CameraLiteTest, Test_GetSupportedSizes_001, Level1)
896 {
897 CameraKit *cameraKit = CameraKit::GetInstance();
898 list<string> cameraList = cameraKit->GetCameraIds();
899 for (auto &cameraId : cameraList) {
900 const CameraAbility *ability = cameraKit->GetCameraAbility(cameraId);
901 list<CameraPicSize> cameraPicSizes = ability->GetSupportedSizes(0);
902 EXPECT_TRUE(cameraPicSizes.size() > 0);
903 }
904 }
905
HWTEST_F(CameraLiteTest,PrfTest_GetSupportedSizes_001,Level1)906 HWTEST_F(CameraLiteTest, PrfTest_GetSupportedSizes_001, Level1)
907 {
908 CameraKit *cameraKit = CameraKit::GetInstance();
909 string cameraId = "0";
910 const CameraAbility *ability = cameraKit->GetCameraAbility(cameraId);
911 struct timespec tv1 = {0};
912 struct timespec tv2 = {0};
913 int64_t performanceTestTimes = 10;
914 int64_t usecTimes = 1000000;
915 int64_t totalTime = 0;
916 for (int32_t i = 0; i < performanceTestTimes; i++) {
917 clock_gettime(CLOCK_REALTIME, &tv1);
918 ability->GetSupportedSizes(0);
919 clock_gettime(CLOCK_REALTIME, &tv2);
920 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
921 }
922 int64_t expectTime = 1000000;
923 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
924 }
925
HWTEST_F(CameraLiteTest,Test_GetSupportedAfModes_001,Level1)926 HWTEST_F(CameraLiteTest, Test_GetSupportedAfModes_001, Level1)
927 {
928 CameraKit *cameraKit = CameraKit::GetInstance();
929 list<string> cameraList = cameraKit->GetCameraIds();
930 for (auto &cameraId : cameraList) {
931 const CameraAbility *ability = cameraKit->GetCameraAbility(cameraId);
932 list<int32_t> afModes = ability->GetSupportedAfModes();
933 EXPECT_TRUE(afModes.size() >= 0);
934 }
935 }
936
HWTEST_F(CameraLiteTest,PrfTest_GetSupportedAfModes_001,Level1)937 HWTEST_F(CameraLiteTest, PrfTest_GetSupportedAfModes_001, Level1)
938 {
939 CameraKit *cameraKit = CameraKit::GetInstance();
940 string cameraId = "0";
941 const CameraAbility *ability = cameraKit->GetCameraAbility(cameraId);
942 struct timespec tv1 = {0};
943 struct timespec tv2 = {0};
944 int64_t performanceTestTimes = 10;
945 int64_t usecTimes = 1000000;
946 int64_t totalTime = 0;
947 for (int32_t i = 0; i < performanceTestTimes; i++) {
948 clock_gettime(CLOCK_REALTIME, &tv1);
949 ability->GetSupportedAfModes();
950 clock_gettime(CLOCK_REALTIME, &tv2);
951 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
952 }
953 int64_t expectTime = 1000000;
954 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
955 }
956
HWTEST_F(CameraLiteTest,Test_GetSupportedAeModes_001,Level1)957 HWTEST_F(CameraLiteTest, Test_GetSupportedAeModes_001, Level1)
958 {
959 CameraKit *cameraKit = CameraKit::GetInstance();
960 list<string> cameraList = cameraKit->GetCameraIds();
961 for (auto &cameraId : cameraList) {
962 const CameraAbility *ability = cameraKit->GetCameraAbility(cameraId);
963 list<int32_t> aeModes = ability->GetSupportedAeModes();
964 EXPECT_TRUE(aeModes.size() >= 0);
965 }
966 }
967
HWTEST_F(CameraLiteTest,PrfTest_GetSupportedAeModes_001,Level1)968 HWTEST_F(CameraLiteTest, PrfTest_GetSupportedAeModes_001, Level1)
969 {
970 CameraKit *cameraKit = CameraKit::GetInstance();
971 string cameraId = "0";
972 const CameraAbility *ability = cameraKit->GetCameraAbility(cameraId);
973 struct timespec tv1 = {0};
974 struct timespec tv2 = {0};
975 int64_t performanceTestTimes = 10;
976 int64_t totalTime = 0;
977 int64_t usecTimes = 1000000;
978 for (int32_t i = 0; i < performanceTestTimes; i++) {
979 clock_gettime(CLOCK_REALTIME, &tv1);
980 ability->GetSupportedAeModes();
981 clock_gettime(CLOCK_REALTIME, &tv2);
982 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
983 }
984 int64_t expectTime = 1000000;
985 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
986 } /* end camera ability interface test*/
987
988 /* start camera state callback test */
HWTEST_F(CameraLiteTest,Test_OnCreate_001,Level1)989 HWTEST_F(CameraLiteTest, Test_OnCreate_001, Level1)
990 {
991 CameraKit *cameraKit = CameraKit::GetInstance();
992 string cameraId = "0";
993 EventHandler eventHdlr;
994 SampleCameraStateMng camStateMng(eventHdlr);
995 g_onCreatedFlag = false;
996 g_onCreateFailedFlag = false;
997 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
998 sleep(2);
999 EXPECT_EQ(g_onCreatedFlag, true);
1000 EXPECT_EQ(g_onCreateFailedFlag, false);
1001 }
1002
HWTEST_F(CameraLiteTest,Test_OnCreate_002,Level1)1003 HWTEST_F(CameraLiteTest, Test_OnCreate_002, Level1)
1004 {
1005 CameraKit *cameraKit = CameraKit::GetInstance();
1006 string cameraId = "0";
1007 EventHandler eventHdlr;
1008 SampleCameraStateMng camStateMng(eventHdlr);
1009 g_onCreatedFlag = false;
1010 g_onCreateFailedFlag = false;
1011 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1012 sleep(2);
1013 camStateMng.Stop();
1014 EXPECT_EQ(g_onCreatedFlag, true);
1015 EXPECT_NE(g_onCreateFailedFlag, true);
1016 }
1017
HWTEST_F(CameraLiteTest,Test_OnCreateFailed_001,Level1)1018 HWTEST_F(CameraLiteTest, Test_OnCreateFailed_001, Level1)
1019 {
1020 CameraKit *cameraKit = CameraKit::GetInstance();
1021 string cameraId = "-1";
1022 EventHandler eventHdlr;
1023 SampleCameraStateMng camStateMng(eventHdlr);
1024 g_onCreateFailedFlag = false;
1025 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1026 sleep(2);
1027 EXPECT_EQ(g_onCreateFailedFlag, true);
1028 }
1029
HWTEST_F(CameraLiteTest,Test_OnCreateFailed_002,Level1)1030 HWTEST_F(CameraLiteTest, Test_OnCreateFailed_002, Level1)
1031 {
1032 CameraKit *cameraKit = CameraKit::GetInstance();
1033 string cameraId = "main";
1034 EventHandler eventHdlr;
1035 SampleCameraStateMng camStateMng(eventHdlr);
1036 g_onCreateFailedFlag = false;
1037 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1038 sleep(2);
1039 EXPECT_EQ(g_onCreateFailedFlag, true);
1040 } /* end camera state callback test */
1041
1042 /* start frame config & frame state call back interface test */
HWTEST_F(CameraLiteTest,Test_FrameConfig_001,Level1)1043 HWTEST_F(CameraLiteTest, Test_FrameConfig_001, Level1)
1044 {
1045 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1046 EXPECT_NE(frameConfig.get(), nullptr);
1047 }
1048
HWTEST_F(CameraLiteTest,Test_FrameConfig_002,Level1)1049 HWTEST_F(CameraLiteTest, Test_FrameConfig_002, Level1)
1050 {
1051 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_RECORD);
1052 EXPECT_NE(frameConfig.get(), nullptr);
1053 }
1054
HWTEST_F(CameraLiteTest,Test_FrameConfig_003,Level1)1055 HWTEST_F(CameraLiteTest, Test_FrameConfig_003, Level1)
1056 {
1057 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CAPTURE);
1058 EXPECT_NE(frameConfig.get(), nullptr);
1059 }
1060
HWTEST_F(CameraLiteTest,Test_FrameConfig_004,Level1)1061 HWTEST_F(CameraLiteTest, Test_FrameConfig_004, Level1)
1062 {
1063 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CALLBACK);
1064 EXPECT_NE(frameConfig.get(), nullptr);
1065 }
1066
HWTEST_F(CameraLiteTest,PrfTest_Frameconfig_001,Level1)1067 HWTEST_F(CameraLiteTest, PrfTest_Frameconfig_001, Level1)
1068 {
1069 shared_ptr<FrameConfig> frameConfig = nullptr;
1070 struct timespec tv1 = {0};
1071 struct timespec tv2 = {0};
1072 int64_t performanceTestTimes = 10;
1073 int64_t usecTimes = 1000000;
1074 int64_t totalTime = 0;
1075 for (int32_t i = 0; i < performanceTestTimes; i++) {
1076 clock_gettime(CLOCK_REALTIME, &tv1);
1077 frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1078 clock_gettime(CLOCK_REALTIME, &tv2);
1079 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1080 }
1081 int64_t expectTime = 1000000;
1082 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1083 }
1084
HWTEST_F(CameraLiteTest,PrfTest_Frameconfig_002,Level1)1085 HWTEST_F(CameraLiteTest, PrfTest_Frameconfig_002, Level1)
1086 {
1087 shared_ptr<FrameConfig> frameConfig = nullptr;
1088 struct timespec tv1 = {0};
1089 struct timespec tv2 = {0};
1090 int64_t performanceTestTimes = 10;
1091 int64_t usecTimes = 1000000;
1092 int64_t totalTime = 0;
1093 for (int32_t i = 0; i < performanceTestTimes; i++) {
1094 clock_gettime(CLOCK_REALTIME, &tv1);
1095 frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_RECORD);
1096 clock_gettime(CLOCK_REALTIME, &tv2);
1097 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1098 }
1099 int64_t expectTime = 1000000;
1100 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1101 }
1102
HWTEST_F(CameraLiteTest,PrfTest_Frameconfig_003,Level1)1103 HWTEST_F(CameraLiteTest, PrfTest_Frameconfig_003, Level1)
1104 {
1105 shared_ptr<FrameConfig> frameConfig = nullptr;
1106 struct timespec tv1 = {0};
1107 struct timespec tv2 = {0};
1108 int64_t performanceTestTimes = 10;
1109 int64_t usecTimes = 1000000;
1110 int64_t totalTime = 0;
1111 for (int32_t i = 0; i < performanceTestTimes; i++) {
1112 clock_gettime(CLOCK_REALTIME, &tv1);
1113 frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CAPTURE);
1114 clock_gettime(CLOCK_REALTIME, &tv2);
1115 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1116 }
1117 int64_t expectTime = 1000000;
1118 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1119 }
1120
HWTEST_F(CameraLiteTest,PrfTest_Frameconfig_004,Level1)1121 HWTEST_F(CameraLiteTest, PrfTest_Frameconfig_004, Level1)
1122 {
1123 shared_ptr<FrameConfig> frameConfig = nullptr;
1124 struct timespec tv1 = {0};
1125 struct timespec tv2 = {0};
1126 int64_t performanceTestTimes = 10;
1127 int64_t usecTimes = 1000000;
1128 int64_t totalTime = 0;
1129 for (int32_t i = 0; i < performanceTestTimes; i++) {
1130 clock_gettime(CLOCK_REALTIME, &tv1);
1131 frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CALLBACK);
1132 clock_gettime(CLOCK_REALTIME, &tv2);
1133 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1134 }
1135 int64_t expectTime = 1000000;
1136 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1137 }
1138
HWTEST_F(CameraLiteTest,Test_GetFrameConfigureType_001,Level1)1139 HWTEST_F(CameraLiteTest, Test_GetFrameConfigureType_001, Level1)
1140 {
1141 CameraKit *cameraKit = CameraKit::GetInstance();
1142 string cameraId = "0";
1143 EventHandler eventHdlr;
1144 SampleCameraStateMng camStateMng(eventHdlr);
1145 g_onGetFrameConfigureType = false;
1146 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1147 sleep(2);
1148 camStateMng.Capture();
1149 sleep(2);
1150 EXPECT_EQ(g_onGetFrameConfigureType, true);
1151 }
1152
HWTEST_F(CameraLiteTest,Test_GetFrameConfigureType_002,Level1)1153 HWTEST_F(CameraLiteTest, Test_GetFrameConfigureType_002, Level1)
1154 {
1155 CameraKit *cameraKit = CameraKit::GetInstance();
1156 string cameraId = "0";
1157 EventHandler eventHdlr;
1158 SampleCameraStateMng camStateMng(eventHdlr);
1159 g_onGetFrameConfigureType = false;
1160 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1161 sleep(2);
1162 camStateMng.Capture();
1163 sleep(2);
1164 camStateMng.Stop();
1165 EXPECT_EQ(g_onGetFrameConfigureType, true);
1166 }
1167
HWTEST_F(CameraLiteTest,Test_GetFrameConfigureType_003,Level1)1168 HWTEST_F(CameraLiteTest, Test_GetFrameConfigureType_003, Level1)
1169 {
1170 CameraKit *cameraKit = CameraKit::GetInstance();
1171 string cameraId = "0";
1172 EventHandler eventHdlr;
1173 SampleCameraStateMng camStateMng(eventHdlr);
1174 g_onGetFrameConfigureType = false;
1175 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1176 sleep(2);
1177 camStateMng.StartPreview();
1178 sleep(2);
1179 camStateMng.Stop();
1180 EXPECT_EQ(g_onGetFrameConfigureType, true);
1181 }
1182
HWTEST_F(CameraLiteTest,Test_GetFrameConfigureType_004,Level1)1183 HWTEST_F(CameraLiteTest, Test_GetFrameConfigureType_004, Level1)
1184 {
1185 CameraKit *cameraKit = CameraKit::GetInstance();
1186 string cameraId = "0";
1187 EventHandler eventHdlr;
1188 SampleCameraStateMng camStateMng(eventHdlr);
1189 g_onGetFrameConfigureType = false;
1190 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1191 sleep(2);
1192 camStateMng.Capture();
1193 sleep(2);
1194 camStateMng.StartPreview();
1195 sleep(2);
1196 camStateMng.Stop();
1197 EXPECT_EQ(g_onGetFrameConfigureType, true);
1198 }
1199
HWTEST_F(CameraLiteTest,Test_GetFrameConfigureType_005,Level1)1200 HWTEST_F(CameraLiteTest, Test_GetFrameConfigureType_005, Level1)
1201 {
1202 CameraKit *cameraKit = CameraKit::GetInstance();
1203 string cameraId = "0";
1204 EventHandler eventHdlr;
1205 SampleCameraStateMng camStateMng(eventHdlr);
1206 g_onGetFrameConfigureType = false;
1207 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1208 sleep(2);
1209 camStateMng.StartPreview();
1210 sleep(2);
1211 camStateMng.Capture();
1212 sleep(2);
1213 camStateMng.Stop();
1214 EXPECT_EQ(g_onGetFrameConfigureType, true);
1215 }
1216
HWTEST_F(CameraLiteTest,Test_SetVendorParameter_001,Level1)1217 HWTEST_F(CameraLiteTest, Test_SetVendorParameter_001, Level1)
1218 {
1219 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1220 uint8_t *privateTag = new uint8_t[PRIVATE_TAG_LEN];
1221 privateTag[4] = 5;
1222 frameConfig->SetVendorParameter(privateTag, PRIVATE_TAG_LEN);
1223 uint8_t *privateTagTemp = new uint8_t[10];
1224 frameConfig->GetVendorParameter(privateTagTemp, 10);
1225 EXPECT_TRUE(privateTagTemp[4] == 5);
1226 delete[] privateTag;
1227 delete[] privateTagTemp;
1228 }
1229
HWTEST_F(CameraLiteTest,Test_SetVendorParameter_002,Level1)1230 HWTEST_F(CameraLiteTest, Test_SetVendorParameter_002, Level1)
1231 {
1232 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CAPTURE);
1233 uint8_t *privateTag = new uint8_t[PRIVATE_TAG_LEN];
1234 privateTag[10] = 10;
1235 frameConfig->SetVendorParameter(privateTag, PRIVATE_TAG_LEN);
1236 uint8_t *privateTagTemp = new uint8_t[PRIVATE_TAG_LEN];
1237 frameConfig->GetVendorParameter(privateTagTemp, PRIVATE_TAG_LEN);
1238 EXPECT_TRUE(privateTagTemp[10] == 10);
1239 delete[] privateTag;
1240 delete[] privateTagTemp;
1241 }
1242
HWTEST_F(CameraLiteTest,Test_SetVendorParameter_003,Level1)1243 HWTEST_F(CameraLiteTest, Test_SetVendorParameter_003, Level1)
1244 {
1245 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_RECORD);
1246 uint8_t *privateTag = new uint8_t[PRIVATE_TAG_LEN];
1247 privateTag[0] = 1;
1248 frameConfig->SetVendorParameter(privateTag, PRIVATE_TAG_LEN);
1249 uint8_t *privateTagTemp = new uint8_t[PRIVATE_TAG_LEN];
1250 frameConfig->GetVendorParameter(privateTagTemp, PRIVATE_TAG_LEN);
1251 EXPECT_TRUE(privateTagTemp[0] == 1);
1252 delete[] privateTag;
1253 delete[] privateTagTemp;
1254 }
1255
HWTEST_F(CameraLiteTest,Test_SetVendorParameter_004,Level1)1256 HWTEST_F(CameraLiteTest, Test_SetVendorParameter_004, Level1)
1257 {
1258 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CALLBACK);
1259 uint8_t *privateTag = new uint8_t[PRIVATE_TAG_LEN];
1260 privateTag[31] = 31;
1261 frameConfig->SetVendorParameter(privateTag, PRIVATE_TAG_LEN);
1262 uint8_t *privateTagTemp = new uint8_t[PRIVATE_TAG_LEN];
1263 frameConfig->GetVendorParameter(privateTagTemp, PRIVATE_TAG_LEN);
1264 EXPECT_TRUE(privateTagTemp[31] == 31);
1265 delete[] privateTag;
1266 delete[] privateTagTemp;
1267 }
1268
HWTEST_F(CameraLiteTest,PrfTest_SetVendorParameter_001,Level1)1269 HWTEST_F(CameraLiteTest, PrfTest_SetVendorParameter_001, Level1)
1270 {
1271 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1272 uint8_t *privateTag = new uint8_t[PRIVATE_TAG_LEN];
1273 privateTag[1] = 1;
1274 struct timespec tv1 = {0};
1275 struct timespec tv2 = {0};
1276 int64_t performanceTestTimes = 10;
1277 int64_t usecTimes = 1000000;
1278 int64_t totalTime = 0;
1279 for (int32_t i = 0; i < performanceTestTimes; i++) {
1280 clock_gettime(CLOCK_REALTIME, &tv1);
1281 frameConfig->SetVendorParameter(privateTag, PRIVATE_TAG_LEN);
1282 clock_gettime(CLOCK_REALTIME, &tv2);
1283 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1284 }
1285 int64_t expectTime = 1000000;
1286 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1287 delete[] privateTag;
1288 }
1289
HWTEST_F(CameraLiteTest,PrfTest_SetVendorParameter_002,Level1)1290 HWTEST_F(CameraLiteTest, PrfTest_SetVendorParameter_002, Level1)
1291 {
1292 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CAPTURE);
1293 uint8_t *privateTag = new uint8_t[PRIVATE_TAG_LEN];
1294 privateTag[2] = 2;
1295 struct timespec tv1 = {0};
1296 struct timespec tv2 = {0};
1297 int64_t performanceTestTimes = 10;
1298 int64_t usecTimes = 1000000;
1299 int64_t totalTime = 0;
1300 for (int32_t i = 0; i < performanceTestTimes; i++) {
1301 clock_gettime(CLOCK_REALTIME, &tv1);
1302 frameConfig->SetVendorParameter(privateTag, PRIVATE_TAG_LEN);
1303 clock_gettime(CLOCK_REALTIME, &tv2);
1304 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1305 }
1306 int64_t expectTime = 1000000;
1307 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1308 delete[] privateTag;
1309 }
1310
HWTEST_F(CameraLiteTest,PrfTest_SetVendorParameter_003,Level1)1311 HWTEST_F(CameraLiteTest, PrfTest_SetVendorParameter_003, Level1)
1312 {
1313 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_RECORD);
1314 uint8_t *privateTag = new uint8_t[PRIVATE_TAG_LEN];
1315 privateTag[3] = 3;
1316 struct timespec tv1 = {0};
1317 struct timespec tv2 = {0};
1318 int64_t performanceTestTimes = 10;
1319 int64_t usecTimes = 1000000;
1320 int64_t totalTime = 0;
1321 for (int32_t i = 0; i < performanceTestTimes; i++) {
1322 clock_gettime(CLOCK_REALTIME, &tv1);
1323 frameConfig->SetVendorParameter(privateTag, PRIVATE_TAG_LEN);
1324 clock_gettime(CLOCK_REALTIME, &tv2);
1325 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1326 }
1327 int64_t expectTime = 1000000;
1328 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1329 delete[] privateTag;
1330 }
1331
HWTEST_F(CameraLiteTest,PrfTest_SetVendorParameter_004,Level1)1332 HWTEST_F(CameraLiteTest, PrfTest_SetVendorParameter_004, Level1)
1333 {
1334 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CALLBACK);
1335 uint8_t *privateTag = new uint8_t[PRIVATE_TAG_LEN];
1336 privateTag[4] = 4;
1337 struct timespec tv1 = {0};
1338 struct timespec tv2 = {0};
1339 int64_t performanceTestTimes = 10;
1340 int64_t usecTimes = 1000000;
1341 int64_t totalTime = 0;
1342 for (int32_t i = 0; i < performanceTestTimes; i++) {
1343 clock_gettime(CLOCK_REALTIME, &tv1);
1344 frameConfig->SetVendorParameter(privateTag, PRIVATE_TAG_LEN);
1345 clock_gettime(CLOCK_REALTIME, &tv2);
1346 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1347 }
1348 int64_t expectTime = 1000000;
1349 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1350 delete[] privateTag;
1351 }
1352
HWTEST_F(CameraLiteTest,PrfTest_GetVendorParameter_001,Level1)1353 HWTEST_F(CameraLiteTest, PrfTest_GetVendorParameter_001, Level1)
1354 {
1355 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1356 uint8_t *privateTag = new uint8_t[PRIVATE_TAG_LEN];
1357 privateTag[1] = 1;
1358 frameConfig->SetVendorParameter(privateTag, PRIVATE_TAG_LEN);
1359 struct timespec tv1 = {0};
1360 struct timespec tv2 = {0};
1361 int64_t performanceTestTimes = 10;
1362 int64_t usecTimes = 1000000;
1363 int64_t totalTime = 0;
1364 uint8_t *privateTagTemp = new uint8_t[PRIVATE_TAG_LEN];
1365 for (int32_t i = 0; i < performanceTestTimes; i++) {
1366 clock_gettime(CLOCK_REALTIME, &tv1);
1367 frameConfig->GetVendorParameter(privateTagTemp, PRIVATE_TAG_LEN);
1368 clock_gettime(CLOCK_REALTIME, &tv2);
1369 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1370 }
1371 int64_t expectTime = 1000000;
1372 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1373 delete[] privateTag;
1374 delete[] privateTagTemp;
1375 }
1376
HWTEST_F(CameraLiteTest,PrfTest_GetVendorParameter_002,Level1)1377 HWTEST_F(CameraLiteTest, PrfTest_GetVendorParameter_002, Level1)
1378 {
1379 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CAPTURE);
1380 uint8_t *privateTag = new uint8_t[PRIVATE_TAG_LEN];
1381 privateTag[2] = 2;
1382 frameConfig->SetVendorParameter(privateTag, PRIVATE_TAG_LEN);
1383 struct timespec tv1 = {0};
1384 struct timespec tv2 = {0};
1385 int64_t performanceTestTimes = 10;
1386 int64_t usecTimes = 1000000;
1387 int64_t totalTime = 0;
1388 uint8_t *privateTagTemp = new uint8_t[PRIVATE_TAG_LEN];
1389 for (int32_t i = 0; i < performanceTestTimes; i++) {
1390 clock_gettime(CLOCK_REALTIME, &tv1);
1391 frameConfig->GetVendorParameter(privateTagTemp, PRIVATE_TAG_LEN);
1392 clock_gettime(CLOCK_REALTIME, &tv2);
1393 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1394 }
1395 int64_t expectTime = 1000000;
1396 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1397 delete[] privateTag;
1398 delete[] privateTagTemp;
1399 }
1400
HWTEST_F(CameraLiteTest,PrfTest_GetVendorParameter_003,Level1)1401 HWTEST_F(CameraLiteTest, PrfTest_GetVendorParameter_003, Level1)
1402 {
1403 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_RECORD);
1404 uint8_t *privateTag = new uint8_t[PRIVATE_TAG_LEN];
1405 privateTag[3] = 3;
1406 frameConfig->SetVendorParameter(privateTag, PRIVATE_TAG_LEN);
1407 struct timespec tv1 = {0};
1408 struct timespec tv2 = {0};
1409 int64_t performanceTestTimes = 10;
1410 int64_t usecTimes = 1000000;
1411 int64_t totalTime = 0;
1412 uint8_t *privateTagTemp = new uint8_t[PRIVATE_TAG_LEN];
1413 for (int32_t i = 0; i < performanceTestTimes; i++) {
1414 clock_gettime(CLOCK_REALTIME, &tv1);
1415 frameConfig->GetVendorParameter(privateTagTemp, PRIVATE_TAG_LEN);
1416 clock_gettime(CLOCK_REALTIME, &tv2);
1417 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1418 }
1419 int64_t expectTime = 1000000;
1420 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1421 delete[] privateTag;
1422 delete[] privateTagTemp;
1423 }
1424
HWTEST_F(CameraLiteTest,PrfTest_GetVendorParameter_004,Level1)1425 HWTEST_F(CameraLiteTest, PrfTest_GetVendorParameter_004, Level1)
1426 {
1427 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CALLBACK);
1428 uint8_t *privateTag = new uint8_t[PRIVATE_TAG_LEN];
1429 privateTag[4] = 4;
1430 frameConfig->SetVendorParameter(privateTag, PRIVATE_TAG_LEN);
1431 struct timespec tv1 = {0};
1432 struct timespec tv2 = {0};
1433 int64_t performanceTestTimes = 10;
1434 int64_t usecTimes = 1000000;
1435 int64_t totalTime = 0;
1436 uint8_t *privateTagTemp = new uint8_t[PRIVATE_TAG_LEN];
1437 for (int32_t i = 0; i < performanceTestTimes; i++) {
1438 clock_gettime(CLOCK_REALTIME, &tv1);
1439 frameConfig->GetVendorParameter(privateTagTemp, PRIVATE_TAG_LEN);
1440 clock_gettime(CLOCK_REALTIME, &tv2);
1441 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1442 }
1443 int64_t expectTime = 1000000;
1444 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1445 delete[] privateTag;
1446 delete[] privateTagTemp;
1447 }
1448
HWTEST_F(CameraLiteTest,Test_GetSurface_001,Level1)1449 HWTEST_F(CameraLiteTest, Test_GetSurface_001, Level1)
1450 {
1451 CameraKit *cameraKit = nullptr;
1452 list<string> cameraList;
1453 string cameraId;
1454 EventHandler eventHdlr;
1455 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1456 SampleCameraStateMng camStateMng(eventHdlr);
1457 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1458 sleep(2);
1459 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CAPTURE);
1460 Surface *surface = Surface::CreateSurface();
1461 surface->SetWidthAndHeight(1920, 1080);
1462 EXPECT_EQ(1920, surface->GetWidth());
1463 EXPECT_EQ(1080, surface->GetHeight());
1464 delete surface;
1465 }
1466
HWTEST_F(CameraLiteTest,Test_GetSurface_002,Level1)1467 HWTEST_F(CameraLiteTest, Test_GetSurface_002, Level1)
1468 {
1469 CameraKit *cameraKit = nullptr;
1470 list<string> cameraList;
1471 string cameraId;
1472 EventHandler eventHdlr;
1473 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1474 SampleCameraStateMng camStateMng(eventHdlr);
1475 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1476 sleep(2);
1477 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CAPTURE);
1478 Surface *surface = Surface::CreateSurface();
1479 surface->SetWidthAndHeight(480, 360);
1480 EXPECT_EQ(480, surface->GetWidth());
1481 EXPECT_EQ(360, surface->GetHeight());
1482 }
1483
HWTEST_F(CameraLiteTest,Test_GetSurface_003,Level1)1484 HWTEST_F(CameraLiteTest, Test_GetSurface_003, Level1)
1485 {
1486 CameraKit *cameraKit = nullptr;
1487 list<string> cameraList;
1488 string cameraId;
1489 EventHandler eventHdlr;
1490 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1491 SampleCameraStateMng camStateMng(eventHdlr);
1492 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1493 sleep(2);
1494 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CAPTURE);
1495 Surface *surface = Surface::CreateSurface();
1496 surface->SetWidthAndHeight(1920, 1080);
1497 frameConfig->AddSurface(*surface);
1498 EXPECT_FALSE(frameConfig->GetSurfaces().size() == 0);
1499 }
1500
HWTEST_F(CameraLiteTest,Test_GetSurface_004,Level1)1501 HWTEST_F(CameraLiteTest, Test_GetSurface_004, Level1)
1502 {
1503 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1504 Surface *surface = Surface::CreateSurface();
1505 frameConfig->AddSurface(*surface);
1506 frameConfig->RemoveSurface(*surface);
1507 list<Surface *> list = frameConfig->GetSurfaces();
1508 EXPECT_TRUE(list.size() == 0);
1509 }
1510
HWTEST_F(CameraLiteTest,Test_GetSurface_005,Level1)1511 HWTEST_F(CameraLiteTest, Test_GetSurface_005, Level1)
1512 {
1513 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_RECORD);
1514 Surface *surface = Surface::CreateSurface();
1515 frameConfig->AddSurface(*surface);
1516 list<Surface *> list = frameConfig->GetSurfaces();
1517 EXPECT_TRUE(list.size() == 1);
1518 }
1519
HWTEST_F(CameraLiteTest,Test_GetSurface_006,Level1)1520 HWTEST_F(CameraLiteTest, Test_GetSurface_006, Level1)
1521 {
1522 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CALLBACK);
1523 Surface *surface = Surface::CreateSurface();
1524 frameConfig->AddSurface(*surface);
1525 list<Surface *> list = frameConfig->GetSurfaces();
1526 EXPECT_TRUE(list.size() == 1);
1527 }
1528
HWTEST_F(CameraLiteTest,PrfTest_GetSurfaces_001,Level1)1529 HWTEST_F(CameraLiteTest, PrfTest_GetSurfaces_001, Level1)
1530 {
1531 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1532 Surface *surface = Surface::CreateSurface();
1533 frameConfig->AddSurface(*surface);
1534 struct timespec tv1 = {0};
1535 struct timespec tv2 = {0};
1536 int64_t performanceTestTimes = 10;
1537 int64_t usecTimes = 1000000;
1538 int64_t totalTime = 0;
1539 for (int32_t i = 0; i < performanceTestTimes; i++) {
1540 clock_gettime(CLOCK_REALTIME, &tv1);
1541 frameConfig->GetSurfaces();
1542 clock_gettime(CLOCK_REALTIME, &tv2);
1543 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1544 }
1545 int64_t expectTime = 1000000;
1546 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1547 }
1548
HWTEST_F(CameraLiteTest,PrfTest_GetSurfaces_002,Level1)1549 HWTEST_F(CameraLiteTest, PrfTest_GetSurfaces_002, Level1)
1550 {
1551 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CAPTURE);
1552 Surface *surface = Surface::CreateSurface();
1553 frameConfig->AddSurface(*surface);
1554 struct timespec tv1 = {0};
1555 struct timespec tv2 = {0};
1556 int64_t performanceTestTimes = 10;
1557 int64_t usecTimes = 1000000;
1558 int64_t totalTime = 0;
1559 for (int32_t i = 0; i < performanceTestTimes; i++) {
1560 clock_gettime(CLOCK_REALTIME, &tv1);
1561 frameConfig->GetSurfaces();
1562 clock_gettime(CLOCK_REALTIME, &tv2);
1563 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1564 }
1565 int64_t expectTime = 1000000;
1566 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1567 delete surface;
1568 }
1569
HWTEST_F(CameraLiteTest,PrfTest_GetSurfaces_003,Level1)1570 HWTEST_F(CameraLiteTest, PrfTest_GetSurfaces_003, Level1)
1571 {
1572 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_RECORD);
1573 Surface *surface = Surface::CreateSurface();
1574 frameConfig->AddSurface(*surface);
1575 struct timespec tv1 = {0};
1576 struct timespec tv2 = {0};
1577 int64_t performanceTestTimes = 10;
1578 int64_t usecTimes = 1000000;
1579 int64_t totalTime = 0;
1580 for (int32_t i = 0; i < performanceTestTimes; i++) {
1581 clock_gettime(CLOCK_REALTIME, &tv1);
1582 frameConfig->GetSurfaces();
1583 clock_gettime(CLOCK_REALTIME, &tv2);
1584 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1585 }
1586 int64_t expectTime = 1000000;
1587 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1588 }
1589
HWTEST_F(CameraLiteTest,PrfTest_GetSurfaces_004,Level1)1590 HWTEST_F(CameraLiteTest, PrfTest_GetSurfaces_004, Level1)
1591 {
1592 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_CALLBACK);
1593 Surface *surface = Surface::CreateSurface();
1594 frameConfig->AddSurface(*surface);
1595 struct timespec tv1 = {0};
1596 struct timespec tv2 = {0};
1597 int64_t performanceTestTimes = 10;
1598 int64_t usecTimes = 1000000;
1599 int64_t totalTime = 0;
1600 for (int32_t i = 0; i < performanceTestTimes; i++) {
1601 clock_gettime(CLOCK_REALTIME, &tv1);
1602 frameConfig->GetSurfaces();
1603 clock_gettime(CLOCK_REALTIME, &tv2);
1604 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1605 }
1606 int64_t expectTime = 1000000;
1607 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1608 }
1609
HWTEST_F(CameraLiteTest,Test_OnFrameProgressed_001,Level1)1610 HWTEST_F(CameraLiteTest, Test_OnFrameProgressed_001, Level1)
1611 {
1612 CameraKit *cameraKit = nullptr;
1613 list<string> cameraList;
1614 string cameraId;
1615 EventHandler eventHdlr;
1616 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1617 SampleCameraStateMng camStateMng(eventHdlr);
1618 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1619 sleep(2);
1620 camStateMng.Capture();
1621 sleep(2);
1622 EXPECT_EQ(g_onFrameStartedFlag, true);
1623 EXPECT_EQ(g_onFrameProgressedFlag, true);
1624 }
1625
HWTEST_F(CameraLiteTest,Test_OnFrameCompletedFlag_001,Level1)1626 HWTEST_F(CameraLiteTest, Test_OnFrameCompletedFlag_001, Level1)
1627 {
1628 CameraKit *cameraKit = nullptr;
1629 list<string> cameraList;
1630 string cameraId;
1631 EventHandler eventHdlr;
1632 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1633 SampleCameraStateMng camStateMng(eventHdlr);
1634 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1635 sleep(2);
1636 camStateMng.Capture();
1637 sleep(2);
1638 EXPECT_EQ(g_onFrameFinishedFlag, true);
1639 }
1640
HWTEST_F(CameraLiteTest,Test_OnFrameErrorFlag_001,Level1)1641 HWTEST_F(CameraLiteTest, Test_OnFrameErrorFlag_001, Level1)
1642 {
1643 CameraKit *cameraKit = nullptr;
1644 list<string> cameraList;
1645 string cameraId;
1646 EventHandler eventHdlr;
1647 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1648 SampleCameraStateMng camStateMng(eventHdlr);
1649 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1650 sleep(2);
1651 camStateMng.Capture();
1652 sleep(2);
1653 EXPECT_NE(g_onFrameErrorFlag, true);
1654 }
1655
HWTEST_F(CameraLiteTest,Test_AddSurface_001,Level1)1656 HWTEST_F(CameraLiteTest, Test_AddSurface_001, Level1)
1657 {
1658 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1659 Surface *surface = Surface::CreateSurface();
1660 frameConfig->AddSurface(*surface);
1661 list<Surface *> list = frameConfig->GetSurfaces();
1662 EXPECT_TRUE(list.size() == 1);
1663 }
1664
HWTEST_F(CameraLiteTest,Test_AddSurface_002,Level1)1665 HWTEST_F(CameraLiteTest, Test_AddSurface_002, Level1)
1666 {
1667 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1668 Surface *surface = Surface::CreateSurface();
1669 frameConfig->AddSurface(*surface);
1670 frameConfig->AddSurface(*surface);
1671 list<Surface *> list = frameConfig->GetSurfaces();
1672 EXPECT_TRUE(list.size() == 1);
1673 }
1674
HWTEST_F(CameraLiteTest,Test_AddSurface_003,Level1)1675 HWTEST_F(CameraLiteTest, Test_AddSurface_003, Level1)
1676 {
1677 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1678 Surface *surface = Surface::CreateSurface();
1679 frameConfig->AddSurface(*surface);
1680 frameConfig->AddSurface(*surface);
1681 frameConfig->AddSurface(*surface);
1682 list<Surface *> list = frameConfig->GetSurfaces();
1683 EXPECT_TRUE(list.size() == 1);
1684 }
1685
HWTEST_F(CameraLiteTest,PrfTest_AddSurface_001,Level1)1686 HWTEST_F(CameraLiteTest, PrfTest_AddSurface_001, Level1)
1687 {
1688 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1689 Surface *surface = Surface::CreateSurface();
1690 struct timespec tv1 = {0};
1691 struct timespec tv2 = {0};
1692 int64_t performanceTestTimes = 10;
1693 int64_t usecTimes = 1000000;
1694 int64_t totalTime = 0;
1695 for (int32_t i = 0; i < performanceTestTimes; i++) {
1696 clock_gettime(CLOCK_REALTIME, &tv1);
1697 frameConfig->AddSurface(*surface);
1698 clock_gettime(CLOCK_REALTIME, &tv2);
1699 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1700 }
1701 int64_t expectTime = 1000000;
1702 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1703 }
1704
HWTEST_F(CameraLiteTest,Test_RemoveSurface_001,Level1)1705 HWTEST_F(CameraLiteTest, Test_RemoveSurface_001, Level1)
1706 {
1707 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1708 Surface *surface = Surface::CreateSurface();
1709 frameConfig->AddSurface(*surface);
1710 frameConfig->RemoveSurface(*surface);
1711 list<Surface *> list = frameConfig->GetSurfaces();
1712 EXPECT_TRUE(list.size() == 0);
1713 }
1714
HWTEST_F(CameraLiteTest,Test_RemoveSurface_002,Level1)1715 HWTEST_F(CameraLiteTest, Test_RemoveSurface_002, Level1)
1716 {
1717 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1718 Surface *surface = Surface::CreateSurface();
1719 Surface *surface1 = Surface::CreateSurface();
1720 frameConfig->AddSurface(*surface);
1721 frameConfig->AddSurface(*surface1);
1722 frameConfig->RemoveSurface(*surface1);
1723 list<Surface *> list = frameConfig->GetSurfaces();
1724 EXPECT_TRUE(list.size() == 1);
1725 }
1726
HWTEST_F(CameraLiteTest,Test_RemoveSurface_003,Level1)1727 HWTEST_F(CameraLiteTest, Test_RemoveSurface_003, Level1)
1728 {
1729 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1730 Surface *surface = Surface::CreateSurface();
1731 Surface *surface1 = Surface::CreateSurface();
1732 frameConfig->AddSurface(*surface);
1733 frameConfig->AddSurface(*surface1);
1734 frameConfig->RemoveSurface(*surface);
1735 frameConfig->RemoveSurface(*surface1);
1736 list<Surface *> list = frameConfig->GetSurfaces();
1737 EXPECT_TRUE(list.size() == 0);
1738 }
1739
HWTEST_F(CameraLiteTest,PrfTest_RemoveSurface_001,Level1)1740 HWTEST_F(CameraLiteTest, PrfTest_RemoveSurface_001, Level1)
1741 {
1742 shared_ptr<FrameConfig> frameConfig = make_shared<FrameConfig>(FRAME_CONFIG_PREVIEW);
1743 Surface *surface = Surface::CreateSurface();
1744 struct timespec tv1 = {0};
1745 struct timespec tv2 = {0};
1746 int64_t performanceTestTimes = 10;
1747 int64_t usecTimes = 1000000;
1748 int64_t totalTime = 0;
1749 for (int32_t i = 0; i < performanceTestTimes; i++) {
1750 frameConfig->AddSurface(*surface);
1751 clock_gettime(CLOCK_REALTIME, &tv1);
1752 frameConfig->RemoveSurface(*surface);
1753 clock_gettime(CLOCK_REALTIME, &tv2);
1754 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
1755 }
1756 int64_t expectTime = 1000000;
1757 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
1758 }
1759
HWTEST_F(CameraLiteTest,Test_Capture_001,Level1)1760 HWTEST_F(CameraLiteTest, Test_Capture_001, Level1)
1761 {
1762 CameraKit *cameraKit = nullptr;
1763 list<string> cameraList;
1764 string cameraId;
1765 EventHandler eventHdlr;
1766 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1767 SampleCameraStateMng camStateMng(eventHdlr);
1768 g_onCaptureTriggerStartedFlag = false;
1769 g_onCaptureTriggerCompletedFlag = false;
1770 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1771 sleep(2);
1772 camStateMng.Capture();
1773 sleep(2);
1774 EXPECT_EQ(g_onCaptureTriggerStartedFlag, true);
1775 EXPECT_EQ(g_onCaptureTriggerCompletedFlag, true);
1776 }
1777
HWTEST_F(CameraLiteTest,Test_Capture_002,Level1)1778 HWTEST_F(CameraLiteTest, Test_Capture_002, Level1)
1779 {
1780 CameraKit *cameraKit = CameraKit::GetInstance();
1781 string cameraId = "0";
1782 EventHandler eventHdlr;
1783 SampleCameraStateMng camStateMng(eventHdlr);
1784 g_onCaptureTriggerStartedFlag = false;
1785 g_onCaptureTriggerCompletedFlag = false;
1786 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1787 sleep(2);
1788 camStateMng.StartPreview();
1789 sleep(2);
1790 camStateMng.Capture();
1791 sleep(2);
1792 camStateMng.Stop();
1793 sleep(2);
1794 EXPECT_EQ(g_onCaptureTriggerStartedFlag, true);
1795 EXPECT_EQ(g_onCaptureTriggerCompletedFlag, true);
1796 }
1797
HWTEST_F(CameraLiteTest,Test_Capture_003,Level1)1798 HWTEST_F(CameraLiteTest, Test_Capture_003, Level1)
1799 {
1800 CameraKit *cameraKit = CameraKit::GetInstance();
1801 string cameraId = "0";
1802 EventHandler eventHdlr;
1803 SampleCameraStateMng camStateMng(eventHdlr);
1804 g_onCaptureTriggerStartedFlag = false;
1805 g_onCaptureTriggerCompletedFlag = false;
1806 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1807 sleep(2);
1808 camStateMng.StartPreview();
1809 sleep(2);
1810 camStateMng.Stop();
1811 sleep(2);
1812 EXPECT_EQ(g_onCaptureTriggerStartedFlag, false);
1813 EXPECT_EQ(g_onCaptureTriggerCompletedFlag, false);
1814 }
1815
HWTEST_F(CameraLiteTest,Test_Capture_004,Level1)1816 HWTEST_F(CameraLiteTest, Test_Capture_004, Level1)
1817 {
1818 CameraKit *cameraKit = nullptr;
1819 list<string> cameraList;
1820 string cameraId;
1821 EventHandler eventHdlr;
1822 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1823 SampleCameraStateMng camStateMng(eventHdlr);
1824 g_onCaptureTriggerStartedFlag = false;
1825 g_onCaptureTriggerCompletedFlag = false;
1826 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1827 sleep(2);
1828 camStateMng.Capture();
1829 sleep(2);
1830 camStateMng.Stop();
1831 sleep(2);
1832 EXPECT_EQ(g_onCaptureTriggerStartedFlag, true);
1833 EXPECT_EQ(g_onCaptureTriggerCompletedFlag, true);
1834 }
1835
HWTEST_F(CameraLiteTest,Test_Capture_005,Level1)1836 HWTEST_F(CameraLiteTest, Test_Capture_005, Level1)
1837 {
1838 CameraKit *cameraKit = nullptr;
1839 list<string> cameraList;
1840 string cameraId;
1841 EventHandler eventHdlr;
1842 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1843 SampleCameraStateMng camStateMng(eventHdlr);
1844 g_onCaptureTriggerStartedFlag = false;
1845 g_onCaptureTriggerCompletedFlag = false;
1846 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1847 sleep(2);
1848 camStateMng.Capture();
1849 sleep(2);
1850 camStateMng.Capture();
1851 sleep(2);
1852 EXPECT_EQ(g_onCaptureTriggerStartedFlag, true);
1853 EXPECT_EQ(g_onCaptureTriggerCompletedFlag, true);
1854 }
1855
HWTEST_F(CameraLiteTest,Test_Capture_006,Level1)1856 HWTEST_F(CameraLiteTest, Test_Capture_006, Level1)
1857 {
1858 CameraKit *cameraKit = nullptr;
1859 list<string> cameraList;
1860 string cameraId;
1861 EventHandler eventHdlr;
1862 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1863 SampleCameraStateMng camStateMng(eventHdlr);
1864 g_onCaptureTriggerStartedFlag = false;
1865 g_onCaptureTriggerCompletedFlag = false;
1866 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1867 sleep(2);
1868 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1869 sleep(2);
1870 camStateMng.Capture();
1871 sleep(2);
1872 EXPECT_TRUE(g_onCaptureTriggerStartedFlag);
1873 EXPECT_TRUE(g_onCaptureTriggerCompletedFlag);
1874 }
1875
HWTEST_F(CameraLiteTest,Test_Capture_007,Level1)1876 HWTEST_F(CameraLiteTest, Test_Capture_007, Level1)
1877 {
1878 CameraKit *cameraKit = nullptr;
1879 list<string> cameraList;
1880 string cameraId;
1881 EventHandler eventHdlr;
1882 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1883 SampleCameraStateMng camStateMng(eventHdlr);
1884 g_onCaptureTriggerStartedFlag = false;
1885 g_onCaptureTriggerCompletedFlag = false;
1886 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1887 sleep(2);
1888 camStateMng.Stop();
1889 sleep(2);
1890 camStateMng.Capture();
1891 sleep(2);
1892 EXPECT_TRUE(g_onCaptureTriggerStartedFlag);
1893 EXPECT_TRUE(g_onCaptureTriggerCompletedFlag);
1894 }
1895
HWTEST_F(CameraLiteTest,Test_Capture_008,Level1)1896 HWTEST_F(CameraLiteTest, Test_Capture_008, Level1)
1897 {
1898 CameraKit *cameraKit = nullptr;
1899 list<string> cameraList;
1900 string cameraId;
1901 EventHandler eventHdlr;
1902 GetCameraId(cameraKit, cameraList, cameraId);
1903 SampleCameraStateMng camStateMng(eventHdlr);
1904 g_onCaptureTriggerStartedFlag = false;
1905 g_onCaptureTriggerCompletedFlag = false;
1906 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1907 sleep(2);
1908 camStateMng.StartPreview();
1909 sleep(2);
1910 camStateMng.Stop();
1911 sleep(2);
1912 camStateMng.Capture();
1913 sleep(2);
1914 EXPECT_EQ(g_onCaptureTriggerStartedFlag, true);
1915 EXPECT_EQ(g_onCaptureTriggerCompletedFlag, true);
1916 }
1917
HWTEST_F(CameraLiteTest,Test_Preview_001,Level1)1918 HWTEST_F(CameraLiteTest, Test_Preview_001, Level1)
1919 {
1920 CameraKit *cameraKit = nullptr;
1921 list<string> cameraList;
1922 string cameraId;
1923 EventHandler eventHdlr;
1924 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1925 SampleCameraStateMng camStateMng(eventHdlr);
1926 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1927 g_onPreviewFlag = false;
1928 camStateMng.StartPreview();
1929 sleep(2);
1930 EXPECT_TRUE(g_onPreviewFlag);
1931 camStateMng.Stop();
1932 }
1933
HWTEST_F(CameraLiteTest,Test_Preview_002,Level1)1934 HWTEST_F(CameraLiteTest, Test_Preview_002, Level1)
1935 {
1936 CameraKit *cameraKit = nullptr;
1937 list<string> cameraList;
1938 string cameraId;
1939 EventHandler eventHdlr;
1940 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1941 SampleCameraStateMng camStateMng(eventHdlr);
1942 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1943 g_onPreviewFlag = false;
1944 camStateMng.StartPreview();
1945 sleep(2);
1946 camStateMng.Stop();
1947 EXPECT_FALSE(g_onPreviewFlag);
1948 }
1949
HWTEST_F(CameraLiteTest,Test_Preview_003,Level1)1950 HWTEST_F(CameraLiteTest, Test_Preview_003, Level1)
1951 {
1952 CameraKit *cameraKit = nullptr;
1953 list<string> cameraList;
1954 string cameraId;
1955 EventHandler eventHdlr;
1956 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1957 SampleCameraStateMng camStateMng(eventHdlr);
1958 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1959 g_onPreviewFlag = false;
1960 camStateMng.StartPreview();
1961 sleep(2);
1962 camStateMng.Stop();
1963 camStateMng.StartPreview();
1964 sleep(2);
1965 EXPECT_TRUE(g_onPreviewFlag);
1966 }
1967
HWTEST_F(CameraLiteTest,Test_Preview_004,Level1)1968 HWTEST_F(CameraLiteTest, Test_Preview_004, Level1)
1969 {
1970 CameraKit *cameraKit = nullptr;
1971 list<string> cameraList;
1972 string cameraId;
1973 EventHandler eventHdlr;
1974 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1975 SampleCameraStateMng camStateMng(eventHdlr);
1976 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1977 g_onPreviewFlag = false;
1978 camStateMng.StartPreview();
1979 sleep(2);
1980 camStateMng.Stop();
1981 camStateMng.StartPreview();
1982 sleep(2);
1983 camStateMng.Stop();
1984 EXPECT_FALSE(g_onPreviewFlag);
1985 }
1986
HWTEST_F(CameraLiteTest,Test_Preview_005,Level1)1987 HWTEST_F(CameraLiteTest, Test_Preview_005, Level1)
1988 {
1989 CameraKit *cameraKit = nullptr;
1990 list<string> cameraList;
1991 string cameraId;
1992 EventHandler eventHdlr;
1993 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
1994 SampleCameraStateMng camStateMng(eventHdlr);
1995 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
1996 g_onPreviewFlag = false;
1997 camStateMng.Capture();
1998 sleep(2);
1999 camStateMng.Stop();
2000 sleep(2);
2001 camStateMng.StartPreview();
2002 sleep(2);
2003 EXPECT_TRUE(g_onPreviewFlag);
2004 camStateMng.Stop();
2005 }
2006
HWTEST_F(CameraLiteTest,Test_Preview_006,Level1)2007 HWTEST_F(CameraLiteTest, Test_Preview_006, Level1)
2008 {
2009 CameraKit *cameraKit = nullptr;
2010 list<string> cameraList;
2011 string cameraId;
2012 EventHandler eventHdlr;
2013 ASSERT_TRUE(GetCameraId(cameraKit, cameraList, cameraId));
2014 SampleCameraStateMng camStateMng(eventHdlr);
2015 cameraKit->CreateCamera(cameraId, camStateMng, eventHdlr);
2016 g_onPreviewFlag = false;
2017 camStateMng.Capture();
2018 sleep(2);
2019 camStateMng.StartPreview();
2020 sleep(2);
2021 camStateMng.Stop();
2022 EXPECT_FALSE(g_onPreviewFlag);
2023 } /* end frame config & frame state call back interface test */
2024
2025 /* start camera info interface test */
HWTEST_F(CameraLiteTest,Test_GetCameraType_001,Level1)2026 HWTEST_F(CameraLiteTest, Test_GetCameraType_001, Level1)
2027 {
2028 CameraKit *cameraKit = CameraKit::GetInstance();
2029 string cameraId = "0";
2030 const CameraInfo *cameraInfo = cameraKit->GetCameraInfo(cameraId);
2031 int32_t cameraType = cameraInfo->GetCameraType();
2032 EXPECT_TRUE(cameraType <= 3);
2033 EXPECT_TRUE(cameraType >= 0);
2034 }
2035
HWTEST_F(CameraLiteTest,PrfTest_GetCameraType_001,Level1)2036 HWTEST_F(CameraLiteTest, PrfTest_GetCameraType_001, Level1)
2037 {
2038 CameraKit *cameraKit = CameraKit::GetInstance();
2039 string cameraId = "0";
2040 const CameraInfo *cameraInfo = cameraKit->GetCameraInfo(cameraId);
2041 struct timespec tv1 = {0};
2042 struct timespec tv2 = {0};
2043 int64_t performanceTestTimes = 10;
2044 int64_t usecTimes = 1000000;
2045 int64_t totalTime = 0;
2046 for (int32_t i = 0; i < performanceTestTimes; i++) {
2047 clock_gettime(CLOCK_REALTIME, &tv1);
2048 cameraInfo->GetCameraType();
2049 clock_gettime(CLOCK_REALTIME, &tv2);
2050 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
2051 }
2052 int64_t expectTime = 1000000;
2053 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
2054 }
2055
HWTEST_F(CameraLiteTest,Test_GetCameraFacingType_001,Level1)2056 HWTEST_F(CameraLiteTest, Test_GetCameraFacingType_001, Level1)
2057 {
2058 CameraKit *cameraKit = CameraKit::GetInstance();
2059 string cameraId = "0";
2060 const CameraInfo *cameraInfo = cameraKit->GetCameraInfo(cameraId);
2061 int32_t cameraFacingType = cameraInfo->GetCameraFacingType();
2062 EXPECT_TRUE(cameraFacingType <= 2);
2063 EXPECT_TRUE(cameraFacingType >= 0);
2064 }
2065
HWTEST_F(CameraLiteTest,PrfTest_GetCameraFacingType_001,Level1)2066 HWTEST_F(CameraLiteTest, PrfTest_GetCameraFacingType_001, Level1)
2067 {
2068 CameraKit *cameraKit = CameraKit::GetInstance();
2069 string cameraId = "0";
2070 const CameraInfo *cameraInfo = cameraKit->GetCameraInfo(cameraId);
2071 struct timespec tv1 = {0};
2072 struct timespec tv2 = {0};
2073 int64_t performanceTestTimes = 10;
2074 int64_t usecTimes = 1000000;
2075 int64_t totalTime = 0;
2076 for (int32_t i = 0; i < performanceTestTimes; i++) {
2077 clock_gettime(CLOCK_REALTIME, &tv1);
2078 cameraInfo->GetCameraFacingType();
2079 clock_gettime(CLOCK_REALTIME, &tv2);
2080 totalTime += tv2.tv_sec * usecTimes + tv2.tv_nsec - (tv1.tv_sec * usecTimes + tv1.tv_nsec);
2081 }
2082 int64_t expectTime = 1000000;
2083 EXPECT_TRUE(totalTime <= expectTime * performanceTestTimes);
2084 } /* end camera info interface test */
2085 } // namespace OHOS
2086