1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "mc_camera_tracking_controller_test.h"
16 #include "bluetooth_errorcode.h"
17 #include "c_header/ohos_bt_gatt.h"
18 #include "../mechbody_controller_log.h"
19 #include "../test_log.h"
20 #include "mechbody_controller_service.h"
21 #include <chrono>
22 #include <thread>
23 #include <atomic>
24
25 using namespace testing;
26 using namespace testing::ext;
27 using namespace OHOS;
28
29 namespace OHOS {
30 namespace MechBodyController {
31 namespace {
32 constexpr float LAYOUT_LEFT = 0.3;
33 constexpr float LAYOUT_MIDDLE = 0.5;
34 constexpr float LAYOUT_RIGHT = 0.7;
35 }
SetUpTestCase()36 void McCameraTrackingControllerTest::SetUpTestCase()
37 {
38 DTEST_LOG << "McCameraTrackingControllerTest::SetUpTestCase" << std::endl;
39 }
40
TearDownTestCase()41 void McCameraTrackingControllerTest::TearDownTestCase()
42 {
43 DTEST_LOG << "McCameraTrackingControllerTest::TearDownTestCase" << std::endl;
44 }
45
TearDown()46 void McCameraTrackingControllerTest::TearDown()
47 {
48 DTEST_LOG << "McCameraTrackingControllerTest::TearDown" << std::endl;
49 }
50
SetUp()51 void McCameraTrackingControllerTest::SetUp()
52 {
53 DTEST_LOG << "McCameraTrackingControllerTest::SetUp" << std::endl;
54 }
55
56
57 /**
58 * @tc.name : UpdateMotionManagers_001
59 * @tc.number: UpdateMotionManagers_001
60 * @tc.desc : Testing UpdateMotionManagers function.
61 */
62 HWTEST_F(McCameraTrackingControllerTest, UpdateMotionManagers_001, TestSize.Level1)
63 {
64 DTEST_LOG << "McCameraTrackingControllerTest UpdateMotionManagers_001 begin" << std::endl;
65
66 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
67
68 int32_t ret = mcCameraTrackingController.UpdateMotionManagers();
69 EXPECT_EQ(ret, ERR_OK);
70
71 int32_t mechId = 100;
72 std::shared_ptr<MotionManager> motionMgr =
73 std::make_shared<MotionManager>(std::make_shared<TransportSendAdapter>(), mechId);
74 MechBodyControllerService::GetInstance().motionManagers_[mechId] = motionMgr;
75 ret = mcCameraTrackingController.UpdateMotionManagers();
76 EXPECT_EQ(ret, DEVICE_NOT_PLACED_ON_MECH);
77
78 DTEST_LOG << "McCameraTrackingControllerTest UpdateMotionManagers_001 end" << std::endl;
79 }
80
81 /**
82 * @tc.name : OnFocusTracking_001
83 * @tc.number: OnFocusTracking_001
84 * @tc.desc : Testing OnFocusTracking function.
85 */
86 HWTEST_F(McCameraTrackingControllerTest, OnFocusTracking_001, TestSize.Level1)
87 {
88 DTEST_LOG << "McCameraTrackingControllerTest OnFocusTracking_001 begin" << std::endl;
89
90 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
91 CameraStandard::FocusTrackingMetaInfo info;
92 mcCameraTrackingController.currentCameraInfo_->currentTrackingEnable = false;
93
94 int32_t ret = mcCameraTrackingController.OnFocusTracking(info);
95 EXPECT_EQ(ret, ERR_OK);
96 DTEST_LOG << "McCameraTrackingControllerTest OnFocusTracking_001 end" << std::endl;
97 }
98
99 /**
100 * @tc.name : OnFocusTracking_002
101 * @tc.number: OnFocusTracking_002
102 * @tc.desc : Testing OnFocusTracking function.
103 */
104 HWTEST_F(McCameraTrackingControllerTest, OnFocusTracking_002, TestSize.Level1)
105 {
106 DTEST_LOG << "McCameraTrackingControllerTest OnFocusTracking_002 begin" << std::endl;
107
108 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
109 CameraStandard::FocusTrackingMetaInfo info;
110 mcCameraTrackingController.currentCameraInfo_->currentTrackingEnable = true;
111
112 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.OnFocusTracking(info));
113 DTEST_LOG << "McCameraTrackingControllerTest OnFocusTracking_002 end" << std::endl;
114 }
115
116 /**
117 * @tc.name : BuildTrackingParams_001
118 * @tc.number: BuildTrackingParams_001
119 * @tc.desc : Testing BuildTrackingParams function.
120 */
121 HWTEST_F(McCameraTrackingControllerTest, BuildTrackingParams_001, TestSize.Level1)
122 {
123 DTEST_LOG << "McCameraTrackingControllerTest BuildTrackingParams_001 begin" << std::endl;
124
125 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
126 CameraStandard::FocusTrackingMetaInfo info;
127
128 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.BuildTrackingParams(info));
129 DTEST_LOG << "McCameraTrackingControllerTest BuildTrackingParams_001 end" << std::endl;
130 }
131
132 /**
133 * @tc.name : UpdateROI_001
134 * @tc.number: UpdateROI_001
135 * @tc.desc : Testing UpdateROI function.
136 */
137 HWTEST_F(McCameraTrackingControllerTest, UpdateROI_001, TestSize.Level1)
138 {
139 DTEST_LOG << "McCameraTrackingControllerTest UpdateROI_001 begin" << std::endl;
140
141 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
142 std::shared_ptr<TrackingFrameParams> trackingFrameParams = std::make_shared<TrackingFrameParams>();
143 std::shared_ptr<TrackingFrameParams> trackingFrameParamsNull = nullptr;
144 CameraStandard::Rect rect;
145 mcCameraTrackingController.currentCameraInfo_->cameraType = CameraType::FRONT;
146 mcCameraTrackingController.sensorRotation_ = MobileRotation::UP;
147
148 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.UpdateROI(trackingFrameParamsNull, rect));
149 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.UpdateROI(trackingFrameParams, rect));
150
151 rect.width = 4;
152 rect.topLeftX = 2;
153 rect.height = 4;
154 rect.topLeftY = 2;
155 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.UpdateROI(trackingFrameParams, rect));
156 mcCameraTrackingController.sensorRotation_ = MobileRotation::LEFT;
157 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.UpdateROI(trackingFrameParams, rect));
158 DTEST_LOG << "McCameraTrackingControllerTest UpdateROI_001 end" << std::endl;
159 }
160
161 /**
162 * @tc.name : UpdateROI_002
163 * @tc.number: UpdateROI_002
164 * @tc.desc : Testing UpdateROI function.
165 */
166 HWTEST_F(McCameraTrackingControllerTest, UpdateROI_002, TestSize.Level1)
167 {
168 DTEST_LOG << "McCameraTrackingControllerTest UpdateROI_002 begin" << std::endl;
169
170 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
171 std::shared_ptr<TrackingFrameParams> trackingFrameParams = std::make_shared<TrackingFrameParams>();
172 CameraStandard::Rect rect;
173 rect.width = 4;
174 rect.topLeftX = 2;
175 rect.height = 4;
176 rect.topLeftY = 2;
177 mcCameraTrackingController.currentCameraInfo_->cameraType = CameraType::BACK;
178 mcCameraTrackingController.sensorRotation_ = MobileRotation::UP;
179
180 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.UpdateROI(trackingFrameParams, rect));
181 mcCameraTrackingController.sensorRotation_ = MobileRotation::LEFT;
182 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.UpdateROI(trackingFrameParams, rect));
183 DTEST_LOG << "McCameraTrackingControllerTest UpdateROI_002 end" << std::endl;
184 }
185
186 /**
187 * @tc.name : UpdateROI_003
188 * @tc.number: UpdateROI_003
189 * @tc.desc : Testing UpdateROI function.
190 */
191 HWTEST_F(McCameraTrackingControllerTest, UpdateROI_003, TestSize.Level1)
192 {
193 DTEST_LOG << "McCameraTrackingControllerTest UpdateROI_003 begin" << std::endl;
194
195 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
196 std::shared_ptr<TrackingFrameParams> trackingFrameParams = std::make_shared<TrackingFrameParams>();
197 CameraStandard::Rect rect;
198 rect.width = 4;
199 rect.topLeftX = 2;
200 rect.height = 4;
201 rect.topLeftY = 2;
202 mcCameraTrackingController.currentCameraInfo_->cameraType = CameraType::FRONT;
203 mcCameraTrackingController.sensorRotation_ = MobileRotation::RIGHT;
204
205 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.UpdateROI(trackingFrameParams, rect));
206 mcCameraTrackingController.sensorRotation_ = MobileRotation::DOWN;
207 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.UpdateROI(trackingFrameParams, rect));
208 DTEST_LOG << "McCameraTrackingControllerTest UpdateROI_003 end" << std::endl;
209 }
210
211 /**
212 * @tc.name : UpdateROI_004
213 * @tc.number: UpdateROI_004
214 * @tc.desc : Testing UpdateROI function.
215 */
216 HWTEST_F(McCameraTrackingControllerTest, UpdateROI_004, TestSize.Level1)
217 {
218 DTEST_LOG << "McCameraTrackingControllerTest UpdateROI_004 begin" << std::endl;
219
220 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
221 std::shared_ptr<TrackingFrameParams> trackingFrameParams = std::make_shared<TrackingFrameParams>();
222 CameraStandard::Rect rect;
223 rect.width = 4;
224 rect.topLeftX = 2;
225 rect.height = 4;
226 rect.topLeftY = 2;
227 mcCameraTrackingController.currentCameraInfo_->cameraType = CameraType::BACK;
228 mcCameraTrackingController.sensorRotation_ = MobileRotation::RIGHT;
229
230 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.UpdateROI(trackingFrameParams, rect));
231 mcCameraTrackingController.sensorRotation_ = MobileRotation::DOWN;
232 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.UpdateROI(trackingFrameParams, rect));
233 DTEST_LOG << "McCameraTrackingControllerTest UpdateROI_004 end" << std::endl;
234 }
235
236 /**
237 * @tc.name : UpdateMotionsWithTrackingData_001
238 * @tc.number: UpdateMotionsWithTrackingData_001
239 * @tc.desc : Testing UpdateMotionsWithTrackingData function.
240 */
241 HWTEST_F(McCameraTrackingControllerTest, UpdateMotionsWithTrackingData_001, TestSize.Level1)
242 {
243 DTEST_LOG << "McCameraTrackingControllerTest UpdateMotionsWithTrackingData_001 begin" << std::endl;
244
245 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
246 std::shared_ptr<TrackingFrameParams> trackingFrameParams = nullptr;
247 int32_t trackingObjectId = 100;
248
249 int32_t ret = mcCameraTrackingController.UpdateMotionsWithTrackingData(trackingFrameParams, trackingObjectId);
250 EXPECT_EQ(ret, ERR_OK);
251 DTEST_LOG << "McCameraTrackingControllerTest UpdateMotionsWithTrackingData_001 end" << std::endl;
252 }
253
254 /**
255 * @tc.name : UpdateMotionsWithTrackingData_002
256 * @tc.number: UpdateMotionsWithTrackingData_002
257 * @tc.desc : Testing UpdateMotionsWithTrackingData function.
258 */
259 HWTEST_F(McCameraTrackingControllerTest, UpdateMotionsWithTrackingData_002, TestSize.Level1)
260 {
261 DTEST_LOG << "McCameraTrackingControllerTest UpdateMotionsWithTrackingData_002 begin" << std::endl;
262
263 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
264 std::shared_ptr<TrackingFrameParams> trackingFrameParams = std::make_shared<TrackingFrameParams>();
265 int32_t trackingObjectId = 100;
266 int32_t mechId = 100;
267
268 int32_t ret = mcCameraTrackingController.UpdateMotionsWithTrackingData(trackingFrameParams, trackingObjectId);
269 EXPECT_EQ(ret, ERR_OK);
270
271 std::shared_ptr<MotionManager> motionMgr =
272 std::make_shared<MotionManager>(std::make_shared<TransportSendAdapter>(), mechId);
273 std::shared_ptr<MotionManager> motionMgrNull = nullptr;
274 MechBodyControllerService::GetInstance().motionManagers_[mechId] = motionMgrNull;
275 ret = mcCameraTrackingController.UpdateMotionsWithTrackingData(trackingFrameParams, trackingObjectId);
276 EXPECT_EQ(ret, ERR_OK);
277
278 MechBodyControllerService::GetInstance().motionManagers_[mechId] = motionMgr;
279 ret = mcCameraTrackingController.UpdateMotionsWithTrackingData(trackingFrameParams, trackingObjectId);
280 EXPECT_EQ(ret, ERR_OK);
281
282 DTEST_LOG << "McCameraTrackingControllerTest UpdateMotionsWithTrackingData_002 end" << std::endl;
283 }
284
285 /**
286 * @tc.name : RegisterTrackingEventCallback_001
287 * @tc.number: RegisterTrackingEventCallback_001
288 * @tc.desc : Testing RegisterTrackingEventCallback function.
289 */
290 HWTEST_F(McCameraTrackingControllerTest, RegisterTrackingEventCallback_001, TestSize.Level1)
291 {
292 DTEST_LOG << "McCameraTrackingControllerTest RegisterTrackingEventCallback_001 begin" << std::endl;
293
294 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
295 uint32_t tokenId = 100;
296 sptr <IRemoteObject> callback;
297
298 int32_t ret = mcCameraTrackingController.RegisterTrackingEventCallback(tokenId, callback);
299 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
300 DTEST_LOG << "McCameraTrackingControllerTest RegisterTrackingEventCallback_001 end" << std::endl;
301 }
302
303 /**
304 * @tc.name : GetCurrentCameraInfo_001
305 * @tc.number: GetCurrentCameraInfo_001
306 * @tc.desc : Testing GetCurrentCameraInfo function.
307 */
308 HWTEST_F(McCameraTrackingControllerTest, GetCurrentCameraInfo_001, TestSize.Level1)
309 {
310 DTEST_LOG << "McCameraTrackingControllerTest GetCurrentCameraInfo_001 begin" << std::endl;
311
312 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
313
314 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.GetCurrentCameraInfo());
315 DTEST_LOG << "McCameraTrackingControllerTest GetCurrentCameraInfo_001 end" << std::endl;
316 }
317
318 /**
319 * @tc.name : SensorCallback_001
320 * @tc.number: SensorCallback_001
321 * @tc.desc : Testing SensorCallback function.
322 */
323 HWTEST_F(McCameraTrackingControllerTest, SensorCallback_001, TestSize.Level1)
324 {
325 DTEST_LOG << "McCameraTrackingControllerTest SensorCallback_001 begin" << std::endl;
326
327 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
328 SensorEvent sensorEvent;
329 SensorEvent* event = &sensorEvent;
330 SensorEvent* eventNull = nullptr;
331
332 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.SensorCallback(event));
333 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.SensorCallback(eventNull));
334 DTEST_LOG << "McCameraTrackingControllerTest SensorCallback_001 end" << std::endl;
335 }
336
337 /**
338 * @tc.name : CalculateSensorRotation_001
339 * @tc.number: CalculateSensorRotation_001
340 * @tc.desc : Testing CalculateSensorRotation function.
341 */
342 HWTEST_F(McCameraTrackingControllerTest, CalculateSensorRotation_001, TestSize.Level1)
343 {
344 DTEST_LOG << "McCameraTrackingControllerTest CalculateSensorRotation_001 begin" << std::endl;
345
346 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
347 GravityData gravityData;
348 gravityData.x = 1;
349 gravityData.y = 1;
350 gravityData.z = 1;
351 GravityData* data = &gravityData;
352
353 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.CalculateSensorRotation(data));
354
355 gravityData.z = 5;
356 GravityData* dataInvaild = &gravityData;
357 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.CalculateSensorRotation(dataInvaild));
358 DTEST_LOG << "McCameraTrackingControllerTest CalculateSensorRotation_001 end" << std::endl;
359 }
360
361 /**
362 * @tc.name : ConvertObjectType_001
363 * @tc.number: ConvertObjectType_001
364 * @tc.desc : Testing ConvertObjectType function.
365 */
366 HWTEST_F(McCameraTrackingControllerTest, ConvertObjectType_001, TestSize.Level1)
367 {
368 DTEST_LOG << "McCameraTrackingControllerTest ConvertObjectType_001 begin" << std::endl;
369
370 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
371 uint8_t mechObjectType = 0;
372 CameraStandard::MetadataObjectType cameraObjectType = CameraStandard::MetadataObjectType::INVALID;
373 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.ConvertObjectType(cameraObjectType, mechObjectType));
374
375 cameraObjectType = CameraStandard::MetadataObjectType::FACE;
376 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.ConvertObjectType(cameraObjectType, mechObjectType));
377
378 cameraObjectType = CameraStandard::MetadataObjectType::HUMAN_BODY;
379 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.ConvertObjectType(cameraObjectType, mechObjectType));
380
381 cameraObjectType = CameraStandard::MetadataObjectType::CAT_FACE;
382 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.ConvertObjectType(cameraObjectType, mechObjectType));
383
384 cameraObjectType = CameraStandard::MetadataObjectType::CAT_BODY;
385 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.ConvertObjectType(cameraObjectType, mechObjectType));
386
387 cameraObjectType = CameraStandard::MetadataObjectType::DOG_FACE;
388 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.ConvertObjectType(cameraObjectType, mechObjectType));
389
390 cameraObjectType = CameraStandard::MetadataObjectType::DOG_BODY;
391 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.ConvertObjectType(cameraObjectType, mechObjectType));
392
393 cameraObjectType = CameraStandard::MetadataObjectType::SALIENT_DETECTION;
394 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.ConvertObjectType(cameraObjectType, mechObjectType));
395
396 cameraObjectType = CameraStandard::MetadataObjectType::BAR_CODE_DETECTION;
397 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.ConvertObjectType(cameraObjectType, mechObjectType));
398
399 cameraObjectType = CameraStandard::MetadataObjectType::BASE_FACE_DETECTION;
400 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.ConvertObjectType(cameraObjectType, mechObjectType));
401 DTEST_LOG << "McCameraTrackingControllerTest ConvertObjectType_001 end" << std::endl;
402 }
403
404 /**
405 * @tc.name : ParseReverseLayout_001
406 * @tc.number: ParseReverseLayout_001
407 * @tc.desc : Testing ParseReverseLayout function.
408 */
409 HWTEST_F(McCameraTrackingControllerTest, ParseReverseLayout_001, TestSize.Level1)
410 {
411 DTEST_LOG << "McCameraTrackingControllerTest ParseReverseLayout_001 begin" << std::endl;
412
413 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
414 CameraTrackingLayout cameraTrackingLayout = CameraTrackingLayout::LEFT;
415 EXPECT_EQ(mcCameraTrackingController.ParseReverseLayout(cameraTrackingLayout), LAYOUT_RIGHT);
416
417 cameraTrackingLayout = CameraTrackingLayout::MIDDLE;
418 EXPECT_EQ(mcCameraTrackingController.ParseReverseLayout(cameraTrackingLayout), LAYOUT_MIDDLE);
419
420 cameraTrackingLayout = CameraTrackingLayout::RIGHT;
421 EXPECT_EQ(mcCameraTrackingController.ParseReverseLayout(cameraTrackingLayout), LAYOUT_LEFT);
422
423 DTEST_LOG << "McCameraTrackingControllerTest ParseReverseLayout_001 end" << std::endl;
424 }
425
426 /**
427 * @tc.name : OnMechConnect_001
428 * @tc.number: OnMechConnect_001
429 * @tc.desc : Testing OnMechConnect function.
430 */
431 HWTEST_F(McCameraTrackingControllerTest, OnMechConnect_001, TestSize.Level1)
432 {
433 DTEST_LOG << "McCameraTrackingControllerTest OnMechConnect_001 begin" << std::endl;
434
435 auto listener = std::make_shared<MechConnectListenerImpl>();
436 MechInfo mechInfo;
437 EXPECT_NO_FATAL_FAILURE(listener->OnMechConnect(mechInfo));
438
439 DTEST_LOG << "McCameraTrackingControllerTest OnMechConnect_001 end" << std::endl;
440 }
441
442 /**
443 * @tc.name : OnMechDisconnect_001
444 * @tc.number: OnMechDisconnect_001
445 * @tc.desc : Testing OnMechDisconnect function.
446 */
447 HWTEST_F(McCameraTrackingControllerTest, OnMechDisconnect_001, TestSize.Level1)
448 {
449 DTEST_LOG << "McCameraTrackingControllerTest OnMechDisconnect_001 begin" << std::endl;
450
451 auto listener = std::make_shared<MechConnectListenerImpl>();
452 MechInfo mechInfo;
453 EXPECT_NO_FATAL_FAILURE(listener->OnMechDisconnect(mechInfo));
454
455 DTEST_LOG << "McCameraTrackingControllerTest OnMechDisconnect_001 end" << std::endl;
456 }
457
458 /**
459 * @tc.name : SetTrackingEnabled_001
460 * @tc.number: SetTrackingEnabled_001
461 * @tc.desc : Testing SetTrackingEnabled function.
462 */
463 HWTEST_F(McCameraTrackingControllerTest, SetTrackingEnabled_001, TestSize.Level1)
464 {
465 DTEST_LOG << "McCameraTrackingControllerTest SetTrackingEnabled_001 begin" << std::endl;
466
467 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
468 uint32_t tokenId = 100;
469 bool isEnabled = true;
470 int32_t mechId = 100;
471 std::shared_ptr<MotionManager> motionMgr =
472 std::make_shared<MotionManager>(std::make_shared<TransportSendAdapter>(), mechId);
473
474 std::shared_ptr<MotionManager> motionMgrNull = nullptr;
475 MechBodyControllerService::GetInstance().motionManagers_[mechId] = motionMgrNull;
476 EXPECT_EQ(mcCameraTrackingController.SetTrackingEnabled(tokenId, isEnabled), ERR_OK);
477
478 MechBodyControllerService::GetInstance().motionManagers_[mechId] = motionMgr;
479 EXPECT_EQ(mcCameraTrackingController.SetTrackingEnabled(tokenId, isEnabled), ERR_OK);
480
481 DTEST_LOG << "McCameraTrackingControllerTest SetTrackingEnabled_001 end" << std::endl;
482 }
483
484 /**
485 * @tc.name : SetTrackingLayout_001
486 * @tc.number: SetTrackingLayout_001
487 * @tc.desc : Testing SetTrackingLayout function.
488 */
489 HWTEST_F(McCameraTrackingControllerTest, SetTrackingLayout_001, TestSize.Level1)
490 {
491 DTEST_LOG << "McCameraTrackingControllerTest SetTrackingLayout_001 begin" << std::endl;
492
493 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
494 CameraTrackingLayout cameraTrackingLayout;
495 int32_t mechId = 100;
496 std::shared_ptr<MotionManager> motionMgr =
497 std::make_shared<MotionManager>(std::make_shared<TransportSendAdapter>(), mechId);
498
499 std::shared_ptr<MotionManager> motionMgrNull = nullptr;
500 MechBodyControllerService::GetInstance().motionManagers_[mechId] = motionMgrNull;
501 EXPECT_EQ(mcCameraTrackingController.SetTrackingLayout(cameraTrackingLayout), INVALID_TRACKING_LAYOUT);
502
503 MechBodyControllerService::GetInstance().motionManagers_[mechId] = motionMgr;
504 EXPECT_EQ(mcCameraTrackingController.SetTrackingLayout(cameraTrackingLayout), INVALID_TRACKING_LAYOUT);
505
506 mcCameraTrackingController.sensorRotation_ = MobileRotation::DOWN;
507 EXPECT_EQ(mcCameraTrackingController.SetTrackingLayout(cameraTrackingLayout), INVALID_TRACKING_LAYOUT);
508
509 mcCameraTrackingController.sensorRotation_ = MobileRotation::LEFT;
510 EXPECT_EQ(mcCameraTrackingController.SetTrackingLayout(cameraTrackingLayout), INVALID_TRACKING_LAYOUT);
511
512 mcCameraTrackingController.sensorRotation_ = MobileRotation::RIGHT;
513 EXPECT_EQ(mcCameraTrackingController.SetTrackingLayout(cameraTrackingLayout), INVALID_TRACKING_LAYOUT);
514
515 DTEST_LOG << "McCameraTrackingControllerTest SetTrackingLayout_001 end" << std::endl;
516 }
517
518 /**
519 * @tc.name : SetTrackingLayout_002
520 * @tc.number: SetTrackingLayout_002
521 * @tc.desc : Testing SetTrackingLayout function.
522 */
523 HWTEST_F(McCameraTrackingControllerTest, SetTrackingLayout_002, TestSize.Level1)
524 {
525 DTEST_LOG << "McCameraTrackingControllerTest SetTrackingLayout_002 begin" << std::endl;
526
527 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
528 uint32_t tokenId = 1;
529 CameraTrackingLayout cameraTrackingLayout;
530 int32_t mechId = 100;
531 std::shared_ptr<MotionManager> motionMgr =
532 std::make_shared<MotionManager>(std::make_shared<TransportSendAdapter>(), mechId);
533 MechBodyControllerService::GetInstance().motionManagers_[mechId] = motionMgr;
534 std::shared_ptr<AppSetting> setting = std::make_shared<AppSetting>();
535 std::shared_ptr<AppSetting> settingNull = nullptr;
536 mcCameraTrackingController.appSettings[tokenId] = setting;
537 EXPECT_EQ(mcCameraTrackingController.SetTrackingLayout(tokenId, cameraTrackingLayout), ERR_OK);
538
539 mcCameraTrackingController.appSettings[tokenId] = settingNull;
540 EXPECT_EQ(mcCameraTrackingController.SetTrackingLayout(tokenId, cameraTrackingLayout), ERR_OK);
541
542 DTEST_LOG << "McCameraTrackingControllerTest SetTrackingLayout_002 end" << std::endl;
543 }
544
545 /**
546 * @tc.name : ParseLayout_001
547 * @tc.number: ParseLayout_001
548 * @tc.desc : Testing ParseLayout function.
549 */
550 HWTEST_F(McCameraTrackingControllerTest, ParseLayout_001, TestSize.Level1)
551 {
552 DTEST_LOG << "McCameraTrackingControllerTest ParseLayout_001 begin" << std::endl;
553
554 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
555 CameraTrackingLayout cameraTrackingLayout;
556 cameraTrackingLayout = CameraTrackingLayout::LEFT;
557 EXPECT_EQ(mcCameraTrackingController.ParseLayout(cameraTrackingLayout), LAYOUT_LEFT);
558
559 cameraTrackingLayout = CameraTrackingLayout::MIDDLE;
560 EXPECT_EQ(mcCameraTrackingController.ParseLayout(cameraTrackingLayout), LAYOUT_MIDDLE);
561
562 cameraTrackingLayout = CameraTrackingLayout::RIGHT;
563 EXPECT_EQ(mcCameraTrackingController.ParseLayout(cameraTrackingLayout), LAYOUT_RIGHT);
564
565 DTEST_LOG << "McCameraTrackingControllerTest ParseLayout_001 end" << std::endl;
566 }
567
568 /**
569 * @tc.name : GetTrackingEnabled_001
570 * @tc.number: GetTrackingEnabled_001
571 * @tc.desc : Testing GetTrackingEnabled function.
572 */
573 HWTEST_F(McCameraTrackingControllerTest, GetTrackingEnabled_001, TestSize.Level1)
574 {
575 DTEST_LOG << "McCameraTrackingControllerTest GetTrackingEnabled_001 begin" << std::endl;
576
577 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
578 uint32_t tokenId = 100;
579 bool isEnabled = true;
580 std::shared_ptr<AppSetting> setting = std::make_shared<AppSetting>();
581 mcCameraTrackingController.appSettings[tokenId] = setting;
582 EXPECT_EQ(mcCameraTrackingController.GetTrackingEnabled(tokenId, isEnabled), ERR_OK);
583
584 DTEST_LOG << "McCameraTrackingControllerTest GetTrackingEnabled_001 end" << std::endl;
585 }
586
587 /**
588 * @tc.name : UnRegisterSensorListener_001
589 * @tc.number: UnRegisterSensorListener_001
590 * @tc.desc : Testing UnRegisterSensorListener function.
591 */
592 HWTEST_F(McCameraTrackingControllerTest, UnRegisterSensorListener_001, TestSize.Level1)
593 {
594 DTEST_LOG << "McCameraTrackingControllerTest UnRegisterSensorListener_001 begin" << std::endl;
595
596 McCameraTrackingController& mcCameraTrackingController = McCameraTrackingController::GetInstance();
597 mcCameraTrackingController.user.callback = nullptr;
598 EXPECT_NO_FATAL_FAILURE(mcCameraTrackingController.UnRegisterSensorListener());
599
600 DTEST_LOG << "McCameraTrackingControllerTest UnRegisterSensorListener_001 end" << std::endl;
601 }
602 }
603 }