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 "mechbody_controller_stub_test.h"
16 #include "bluetooth_errorcode.h"
17 #include "mechbody_controller_log.h"
18 #include "test_log.h"
19 #include <chrono>
20 #include <thread>
21 #include <atomic>
22
23 using namespace testing;
24 using namespace testing::ext;
25 using namespace OHOS;
26
27 namespace OHOS {
28 namespace MechBodyController {
29 namespace {
30 MechBodyControllerService& mechBodyControllerService_ = MechBodyControllerService::GetInstance();
31 uint8_t g_staticData[] = {1, 2, 3, 4};
32 uint8_t *g_data = g_staticData;
33 constexpr size_t DATA_SIZE = 1024;
34 }
35
SetUpTestCase()36 void MechBodyControllerStubTest::SetUpTestCase()
37 {
38 DTEST_LOG << "MechBodyControllerStubTest::SetUpTestCase" << std::endl;
39 }
40
TearDownTestCase()41 void MechBodyControllerStubTest::TearDownTestCase()
42 {
43 DTEST_LOG << "MechBodyControllerStubTest::TearDownTestCase" << std::endl;
44 }
45
TearDown()46 void MechBodyControllerStubTest::TearDown()
47 {
48 DTEST_LOG << "MechBodyControllerStubTest::TearDown" << std::endl;
49 }
50
SetUp()51 void MechBodyControllerStubTest::SetUp()
52 {
53 DTEST_LOG << "MechBodyControllerStubTest::SetUp" << std::endl;
54 }
55
56 /**
57 * @tc.name : AttachStateChangeListenOnInner_001
58 * @tc.number: AttachStateChangeListenOnInner_001
59 * @tc.desc : Test AttachStateChangeListenOnInner function.
60 */
61 HWTEST_F(MechBodyControllerStubTest, AttachStateChangeListenOnInner_001, TestSize.Level1)
62 {
63 DTEST_LOG << "MechBodyControllerStubTest AttachStateChangeListenOnInner_001 begin" << std::endl;
64
65 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::ATTACH_STATE_CHANGE_LISTEN_ON);
66 MessageParcel datas;
67 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
68 datas.WriteBuffer(g_data, DATA_SIZE);
69 datas.RewindRead(0);
70 MessageParcel reply;
71 MessageOption option;
72
73 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
74 EXPECT_EQ(ret, ERR_OK);
75 DTEST_LOG << "MechBodyControllerStubTest AttachStateChangeListenOnInner_001 end" << std::endl;
76 }
77
78 /**
79 * @tc.name : AttachStateChangeListenOffInner_001
80 * @tc.number: AttachStateChangeListenOffInner_001
81 * @tc.desc : Test AttachStateChangeListenOffInner function.
82 */
83 HWTEST_F(MechBodyControllerStubTest, AttachStateChangeListenOffInner_001, TestSize.Level1)
84 {
85 DTEST_LOG << "MechBodyControllerStubTest AttachStateChangeListenOffInner_001 begin" << std::endl;
86
87 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::ATTACH_STATE_CHANGE_LISTEN_OFF);
88 MessageParcel datas;
89 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
90 datas.WriteBuffer(g_data, DATA_SIZE);
91 datas.RewindRead(0);
92 MessageParcel reply;
93 MessageOption option;
94
95 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
96 EXPECT_EQ(ret, ERR_OK);
97 DTEST_LOG << "MechBodyControllerStubTest AttachStateChangeListenOffInner_001 end" << std::endl;
98 }
99
100 /**
101 * @tc.name : GetAttachedDevicesInnerr_001
102 * @tc.number: GetAttachedDevicesInner_001
103 * @tc.desc : Test GetAttachedDevicesInner function.
104 */
105 HWTEST_F(MechBodyControllerStubTest, GetAttachedDevicesInner_001, TestSize.Level1)
106 {
107 DTEST_LOG << "MechBodyControllerStubTest GetAttachedDevicesInner_001 begin" << std::endl;
108
109 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::GET_ATTACHED_DEVICES);
110 MessageParcel datas;
111 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
112 datas.WriteBuffer(g_data, DATA_SIZE);
113 datas.RewindRead(0);
114 MessageParcel reply;
115 MessageOption option;
116
117 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
118 EXPECT_EQ(ret, ERR_OK);
119 DTEST_LOG << "MechBodyControllerStubTest GetAttachedDevicesInner_001 end" << std::endl;
120 }
121
122 /**
123 * @tc.name : SetUserOperationInner_001
124 * @tc.number: SetUserOperationInner_001
125 * @tc.desc : Test SetUserOperationInner function.
126 */
127 HWTEST_F(MechBodyControllerStubTest, SetUserOperationInner_001, TestSize.Level1)
128 {
129 DTEST_LOG << "MechBodyControllerStubTest SetUserOperationInner_001 begin" << std::endl;
130
131 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::SET_USER_OPERATION);
132 MessageParcel datas;
133 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
134 datas.WriteBuffer(g_data, DATA_SIZE);
135 datas.RewindRead(0);
136 MessageParcel reply;
137 MessageOption option;
138
139 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
140 EXPECT_EQ(ret, ERR_OK);
141 DTEST_LOG << "MechBodyControllerStubTest SetUserOperationInner_001 end" << std::endl;
142 }
143
144 /**
145 * @tc.name : SetCameraTrackingEnabledInner_001
146 * @tc.number: SetCameraTrackingEnabledInner_001
147 * @tc.desc : Test SetCameraTrackingEnabledInner function.
148 */
149 HWTEST_F(MechBodyControllerStubTest, SetCameraTrackingEnabledInner_001, TestSize.Level1)
150 {
151 DTEST_LOG << "MechBodyControllerStubTest SetCameraTrackingEnabledInner_001 begin" << std::endl;
152
153 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::SET_CAMERA_TRACKING_ENABLED);
154 MessageParcel datas;
155 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
156 datas.WriteBuffer(g_data, DATA_SIZE);
157 datas.RewindRead(0);
158 MessageParcel reply;
159 MessageOption option;
160
161 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
162 EXPECT_EQ(ret, ERR_OK);
163 DTEST_LOG << "MechBodyControllerStubTest SetCameraTrackingEnabledInner_001 end" << std::endl;
164 }
165
166 /**
167 * @tc.name : GetCameraTrackingEnabledInner_001
168 * @tc.number: GetCameraTrackingEnabledInner_001
169 * @tc.desc : Test GetCameraTrackingEnabledInner function.
170 */
171 HWTEST_F(MechBodyControllerStubTest, GetCameraTrackingEnabledInner_001, TestSize.Level1)
172 {
173 DTEST_LOG << "MechBodyControllerStubTest GetCameraTrackingEnabledInner_001 begin" << std::endl;
174
175 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::GET_CAMERA_TRACKING_ENABLED);
176 MessageParcel datas;
177 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
178 datas.WriteBuffer(g_data, DATA_SIZE);
179 datas.RewindRead(0);
180 MessageParcel reply;
181 MessageOption option;
182
183 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
184 EXPECT_EQ(ret, ERR_OK);
185 DTEST_LOG << "MechBodyControllerStubTest GetCameraTrackingEnabledInner_001 end" << std::endl;
186 }
187
188 /**
189 * @tc.name : TrackingEventListenOnInner_001
190 * @tc.number: TrackingEventListenOnInner_001
191 * @tc.desc : Test TrackingEventListenOnInner function.
192 */
193 HWTEST_F(MechBodyControllerStubTest, TrackingEventListenOnInner_001, TestSize.Level1)
194 {
195 DTEST_LOG << "MechBodyControllerStubTest TrackingEventListenOnInner_001 begin" << std::endl;
196
197 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::TRACKING_EVENT_LISTEN_ON);
198 MessageParcel datas;
199 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
200 datas.WriteBuffer(g_data, DATA_SIZE);
201 datas.RewindRead(0);
202 MessageParcel reply;
203 MessageOption option;
204
205 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
206 EXPECT_EQ(ret, ERR_OK);
207 DTEST_LOG << "MechBodyControllerStubTest TrackingEventListenOnInner_001 end" << std::endl;
208 }
209
210 /**
211 * @tc.name : TrackingEventListenOffInner_001
212 * @tc.number: TrackingEventListenOffInner_001
213 * @tc.desc : Test TrackingEventListenOffInner function.
214 */
215 HWTEST_F(MechBodyControllerStubTest, TrackingEventListenOffInner_001, TestSize.Level1)
216 {
217 DTEST_LOG << "MechBodyControllerStubTest TrackingEventListenOffInner_001 begin" << std::endl;
218
219 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::TRACKING_EVENT_LISTEN_OFF);
220 MessageParcel datas;
221 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
222 datas.WriteBuffer(g_data, DATA_SIZE);
223 datas.RewindRead(0);
224 MessageParcel reply;
225 MessageOption option;
226
227 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
228 EXPECT_EQ(ret, ERR_OK);
229 DTEST_LOG << "MechBodyControllerStubTest TrackingEventListenOffInner_001 end" << std::endl;
230 }
231
232 /**
233 * @tc.name : SetCameraTrackingLayoutInner_001
234 * @tc.number: SetCameraTrackingLayoutInner_001
235 * @tc.desc : Test SetCameraTrackingLayoutInner function.
236 */
237 HWTEST_F(MechBodyControllerStubTest, SetCameraTrackingLayoutInner_001, TestSize.Level1)
238 {
239 DTEST_LOG << "MechBodyControllerStubTest SetCameraTrackingLayoutInner_001 begin" << std::endl;
240
241 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::SET_CAMERA_TRACKING_LAYOUT);
242 MessageParcel datas;
243 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
244 datas.WriteBuffer(g_data, DATA_SIZE);
245 datas.RewindRead(0);
246 MessageParcel reply;
247 MessageOption option;
248
249 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
250 EXPECT_EQ(ret, ERR_OK);
251 DTEST_LOG << "MechBodyControllerStubTest SetCameraTrackingLayoutInner_001 end" << std::endl;
252 }
253
254 /**
255 * @tc.name : GetCameraTrackingLayoutInner_001
256 * @tc.number: GetCameraTrackingLayoutInner_001
257 * @tc.desc : Test GetCameraTrackingLayoutInner function.
258 */
259 HWTEST_F(MechBodyControllerStubTest, GetCameraTrackingLayoutInner_001, TestSize.Level1)
260 {
261 DTEST_LOG << "MechBodyControllerStubTest GetCameraTrackingLayoutInner_001 begin" << std::endl;
262
263 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::GET_CAMERA_TRACKING_LAYOUT);
264 MessageParcel datas;
265 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
266 datas.WriteBuffer(g_data, DATA_SIZE);
267 datas.RewindRead(0);
268 MessageParcel reply;
269 MessageOption option;
270
271 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
272 EXPECT_EQ(ret, ERR_OK);
273 DTEST_LOG << "MechBodyControllerStubTest GetCameraTrackingLayoutInner_001 end" << std::endl;
274 }
275
276 /**
277 * @tc.name : RegisterCmdChannelInner_001
278 * @tc.number: RegisterCmdChannelInner_001
279 * @tc.desc : Test RegisterCmdChannelInner function.
280 */
281 HWTEST_F(MechBodyControllerStubTest, RegisterCmdChannelInner_001, TestSize.Level1)
282 {
283 DTEST_LOG << "MechBodyControllerStubTest RegisterCmdChannelInner_001 begin" << std::endl;
284
285 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::REGISTER_CMD_CHANNEL);
286 MessageParcel datas;
287 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
288 datas.WriteBuffer(g_data, DATA_SIZE);
289 datas.RewindRead(0);
290 MessageParcel reply;
291 MessageOption option;
292
293 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
294 EXPECT_EQ(ret, ERR_OK);
295 DTEST_LOG << "MechBodyControllerStubTest RegisterCmdChannelInner_001 end" << std::endl;
296 }
297
298 /**
299 * @tc.name : RotateByDegreeInner_001
300 * @tc.number: RotateByDegreeInner_001
301 * @tc.desc : Test RotateByDegreeInner function.
302 */
303 HWTEST_F(MechBodyControllerStubTest, RotateByDegreeInner_001, TestSize.Level1)
304 {
305 DTEST_LOG << "MechBodyControllerStubTest RotateByDegreeInner_001 begin" << std::endl;
306
307 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::ROTATE_BY_DEGREE);
308 MessageParcel datas;
309 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
310 datas.WriteBuffer(g_data, DATA_SIZE);
311 datas.RewindRead(0);
312 MessageParcel reply;
313 MessageOption option;
314
315 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
316 EXPECT_EQ(ret, ERR_OK);
317 DTEST_LOG << "MechBodyControllerStubTest RotateByDegreeInner_001 end" << std::endl;
318 }
319
320 /**
321 * @tc.name : GetMaxRotationTimeInner_001
322 * @tc.number: GetMaxRotationTimeInner_001
323 * @tc.desc : Test GetMaxRotationTimeInner function.
324 */
325 HWTEST_F(MechBodyControllerStubTest, GetMaxRotationTimeInner_001, TestSize.Level1)
326 {
327 DTEST_LOG << "MechBodyControllerStubTest GetMaxRotationTimeInner_001 begin" << std::endl;
328
329 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::GET_MAX_ROTATION_TIME);
330 MessageParcel datas;
331 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
332 datas.WriteBuffer(g_data, DATA_SIZE);
333 datas.RewindRead(0);
334 MessageParcel reply;
335 MessageOption option;
336
337 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
338 EXPECT_EQ(ret, ERR_OK);
339 DTEST_LOG << "MechBodyControllerStubTest GetMaxRotationTimeInner_001 end" << std::endl;
340 }
341
342 /**
343 * @tc.name : GetMaxRotationSpeedInner_001
344 * @tc.number: GetMaxRotationSpeedInner_001
345 * @tc.desc : Test GetMaxRotationSpeedInner function.
346 */
347 HWTEST_F(MechBodyControllerStubTest, GetMaxRotationSpeedInner_001, TestSize.Level1)
348 {
349 DTEST_LOG << "MechBodyControllerStubTest GetMaxRotationSpeedInner_001 begin" << std::endl;
350
351 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::GET_MAX_ROTATION_SPEED);
352 MessageParcel datas;
353 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
354 datas.WriteBuffer(g_data, DATA_SIZE);
355 datas.RewindRead(0);
356 MessageParcel reply;
357 MessageOption option;
358
359 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
360 EXPECT_EQ(ret, ERR_OK);
361 DTEST_LOG << "MechBodyControllerStubTest GetMaxRotationSpeedInner_001 end" << std::endl;
362 }
363
364 /**
365 * @tc.name : RotateBySpeedInner_001
366 * @tc.number: RotateBySpeedInner_001
367 * @tc.desc : Test RotateBySpeedInner function.
368 */
369 HWTEST_F(MechBodyControllerStubTest, RotateBySpeedInner_001, TestSize.Level1)
370 {
371 DTEST_LOG << "MechBodyControllerStubTest RotateBySpeedInner_001 begin" << std::endl;
372
373 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::ROTATE_BY_SPEED);
374 MessageParcel datas;
375 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
376 datas.WriteBuffer(g_data, DATA_SIZE);
377 datas.RewindRead(0);
378 MessageParcel reply;
379 MessageOption option;
380
381 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
382 EXPECT_EQ(ret, ERR_OK);
383 DTEST_LOG << "MechBodyControllerStubTest RotateBySpeedInner_001 end" << std::endl;
384 }
385
386 /**
387 * @tc.name : StopMovingInner_001
388 * @tc.number: StopMovingInner_001
389 * @tc.desc : Test StopMovingInner function.
390 */
391 HWTEST_F(MechBodyControllerStubTest, StopMovingInner_001, TestSize.Level1)
392 {
393 DTEST_LOG << "MechBodyControllerStubTest StopMovingInner_001 begin" << std::endl;
394
395 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::STOP_MOVING);
396 MessageParcel datas;
397 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
398 datas.WriteBuffer(g_data, DATA_SIZE);
399 datas.RewindRead(0);
400 MessageParcel reply;
401 MessageOption option;
402
403 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
404 EXPECT_EQ(ret, ERR_OK);
405 DTEST_LOG << "MechBodyControllerStubTest StopMovingInner_001 end" << std::endl;
406 }
407
408 /**
409 * @tc.name : GetRotationAnglesInner_001
410 * @tc.number: GetRotationAnglesInner_001
411 * @tc.desc : Test GetRotationAnglesInner function.
412 */
413 HWTEST_F(MechBodyControllerStubTest, GetRotationAnglesInner_001, TestSize.Level1)
414 {
415 DTEST_LOG << "MechBodyControllerStubTest GetRotationAnglesInner_001 begin" << std::endl;
416
417 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::GET_ROTATION_ANGLES);
418 MessageParcel datas;
419 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
420 datas.WriteBuffer(g_data, DATA_SIZE);
421 datas.RewindRead(0);
422 MessageParcel reply;
423 MessageOption option;
424
425 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
426 EXPECT_EQ(ret, ERR_OK);
427 DTEST_LOG << "MechBodyControllerStubTest GetRotationAnglesInner_001 end" << std::endl;
428 }
429
430 /**
431 * @tc.name : GetRotationDegreeLimitsInner_001
432 * @tc.number: GetRotationDegreeLimitsInner_001
433 * @tc.desc : Test GetRotationDegreeLimitsInner function.
434 */
435 HWTEST_F(MechBodyControllerStubTest, GetRotationDegreeLimitsInner_001, TestSize.Level1)
436 {
437 DTEST_LOG << "MechBodyControllerStubTest GetRotationDegreeLimitsInner_001 begin" << std::endl;
438
439 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::GET_ROTATION_DEGREE_LIMITS);
440 MessageParcel datas;
441 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
442 datas.WriteBuffer(g_data, DATA_SIZE);
443 datas.RewindRead(0);
444 MessageParcel reply;
445 MessageOption option;
446
447 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
448 EXPECT_EQ(ret, ERR_OK);
449 DTEST_LOG << "MechBodyControllerStubTest GetRotationDegreeLimitsInner_001 end" << std::endl;
450 }
451
452 /**
453 * @tc.name : GetRotationAxesStatusInner_001
454 * @tc.number: GetRotationAxesStatusInner_001
455 * @tc.desc : Test GetRotationAxesStatusInner function.
456 */
457 HWTEST_F(MechBodyControllerStubTest, GetRotationAxesStatusInner_001, TestSize.Level1)
458 {
459 DTEST_LOG << "MechBodyControllerStubTest GetRotationAxesStatusInner_001 begin" << std::endl;
460
461 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::GET_ROTATION_AXES_STATUS);
462 MessageParcel datas;
463 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
464 datas.WriteBuffer(g_data, DATA_SIZE);
465 datas.RewindRead(0);
466 MessageParcel reply;
467 MessageOption option;
468
469 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
470 EXPECT_EQ(ret, ERR_OK);
471 DTEST_LOG << "MechBodyControllerStubTest GetRotationAxesStatusInner_001 end" << std::endl;
472 }
473
474 /**
475 * @tc.name : RotationAxesStatusChangeListenOnInner_001
476 * @tc.number: RotationAxesStatusChangeListenOnInner_001
477 * @tc.desc : Test RotationAxesStatusChangeListenOnInner function.
478 */
479 HWTEST_F(MechBodyControllerStubTest, RotationAxesStatusChangeListenOnInner_001, TestSize.Level1)
480 {
481 DTEST_LOG << "MechBodyControllerStubTest RotationAxesStatusChangeListenOnInner_001 begin" << std::endl;
482
483 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::ROTATION_AXES_STATUS_CHANGE_LISTEN_ON);
484 MessageParcel datas;
485 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
486 datas.WriteBuffer(g_data, DATA_SIZE);
487 datas.RewindRead(0);
488 MessageParcel reply;
489 MessageOption option;
490
491 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
492 EXPECT_EQ(ret, ERR_OK);
493 DTEST_LOG << "MechBodyControllerStubTest RotationAxesStatusChangeListenOnInner_001 end" << std::endl;
494 }
495
496 /**
497 * @tc.name : RotationAxesStatusChangeListenOffInner_001
498 * @tc.number: RotationAxesStatusChangeListenOffInner_001
499 * @tc.desc : Test RotationAxesStatusChangeListenOffInner function.
500 */
501 HWTEST_F(MechBodyControllerStubTest, RotationAxesStatusChangeListenOffInner_001, TestSize.Level1)
502 {
503 DTEST_LOG << "MechBodyControllerStubTest RotationAxesStatusChangeListenOffInner_001 begin" << std::endl;
504
505 uint32_t code = static_cast<uint32_t>(IMechBodyControllerCode::ROTATION_AXES_STATUS_CHANGE_LISTEN_OFF);
506 MessageParcel datas;
507 datas.WriteInterfaceToken(MECH_SERVICE_IPC_TOKEN);
508
509 datas.WriteBuffer(g_data, DATA_SIZE);
510 datas.RewindRead(0);
511 MessageParcel reply;
512 MessageOption option;
513
514 int32_t ret = mechBodyControllerService_.OnRemoteRequest(code, datas, reply, option);
515 EXPECT_EQ(ret, ERR_OK);
516 DTEST_LOG << "MechBodyControllerStubTest RotationAxesStatusChangeListenOffInner_001 end" << std::endl;
517 }
518 }
519 }
520