1 /*
2 * Copyright (c) 2021 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 <base/hdi_smq.h>
17 #include <functional>
18 #include <gtest/gtest.h>
19 #include <hdf_io_service_if.h>
20 #include <hdf_core_log.h>
21 #include <hdf_service_status_inner.h>
22 #include <idevmgr_hdi.h>
23 #include <iostream>
24 #include <ipc_object_stub.h>
25 #include <iservice_registry.h>
26 #include <iservmgr_hdi.h>
27 #include <iservstat_listener_hdi.h>
28 #include <osal_time.h>
29 #include <string>
30
31 #include "sample_hdi.h"
32
33 #define HDF_LOG_TAG service_manager_test_cpp
34
35 namespace OHOS {
36 using namespace testing::ext;
37 using OHOS::IRemoteObject;
38 using OHOS::sptr;
39 using OHOS::HDI::Base::SharedMemQueue;
40 using OHOS::HDI::Base::SharedMemQueueMeta;
41 using OHOS::HDI::Base::SmqType;
42 using OHOS::HDI::DeviceManager::V1_0::IDeviceManager;
43 using OHOS::HDI::ServiceManager::V1_0::IServiceManager;
44 using OHOS::HDI::ServiceManager::V1_0::IServStatListener;
45 using OHOS::HDI::ServiceManager::V1_0::ServiceStatus;
46 using OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub;
47 using OHOS::HDI::DeviceManager::V1_0::HdiDevHostInfo;
48 using OHOS::HDI::ServiceManager::V1_0::HdiServiceInfo;
49 #ifdef SAMPLE_DRIVER
50 static constexpr const char *TEST_SERVICE_NAME = "sample_driver_service";
51 static constexpr const char *TEST1_SERVICE_NAME = "sample1_driver_service";
52 static constexpr const char16_t *TEST_SERVICE_INTERFACE_DESC = u"hdf.test.sampele_service";
53 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_N = "hdf.test.sampele_service";
54 #endif
55 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_INVALID = "___";
56 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_VOID = "";
57 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_NULL = nullptr;
58 #ifdef SAMPLE_DRIVER
59 static constexpr int PAYLOAD_NUM = 1234;
60 static constexpr int SMQ_TEST_QUEUE_SIZE = 10;
61 static constexpr int SMQ_TEST_WAIT_TIME = 100;
62 static constexpr int WAIT_LOAD_UNLOAD_TIME = 300;
63 #endif
64 static constexpr int DEVICE_SERVICE_MANAGER_SA_ID = 5100;
65 static constexpr int INVALID_CODE = 100;
66 static constexpr int ERROR_CODE_WITH_INVALID_CODE = 305;
67
68 class HdfServiceMangerHdiTest : public testing::Test {
69 public:
SetUpTestCase()70 static void SetUpTestCase()
71 {
72 #ifdef SAMPLE_DRIVER
73 auto devmgr = IDeviceManager::Get();
74 if (devmgr != nullptr) {
75 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
76 devmgr->LoadDevice(TEST_SERVICE_NAME);
77 }
78 #endif
79 }
TearDownTestCase()80 static void TearDownTestCase()
81 {
82 #ifdef SAMPLE_DRIVER
83 auto devmgr = IDeviceManager::Get();
84 if (devmgr != nullptr) {
85 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
86 devmgr->UnloadDevice(TEST_SERVICE_NAME);
87 }
88 #endif
89 }
90 void TestServiceListenerStop(const sptr<IDeviceManager>& devmgr, const sptr<IServiceManager>& servmgr);
91 void TestSampleService(sptr<IRemoteObject>& sampleService, const sptr<IDeviceManager>& devmgr,
92 const sptr<IServiceManager>& servmgr);
SetUp()93 void SetUp() {};
TearDown()94 void TearDown() {};
95 };
96
97 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest001, TestSize.Level1)
98 {
99 auto servmgr = IServiceManager::Get();
100 ASSERT_TRUE(servmgr != nullptr);
101 }
102
103 #ifdef SAMPLE_DRIVER
104 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest002, TestSize.Level1)
105 {
106 auto servmgr = IServiceManager::Get();
107 ASSERT_TRUE(servmgr != nullptr);
108
109 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
110
111 ASSERT_TRUE(sampleService != nullptr);
112
113 OHOS::MessageParcel data;
114 OHOS::MessageParcel reply;
115 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
116 ASSERT_EQ(ret, true);
117 data.WriteCString("sample_service test call");
118
119 OHOS::MessageOption option;
120 int status = sampleService->SendRequest(SAMPLE_SERVICE_PING, data, reply, option);
121 ASSERT_EQ(status, 0);
122 }
123
124 class IPCObjectStubTest : public OHOS::IPCObjectStub {
125 public:
IPCObjectStubTest()126 explicit IPCObjectStubTest() : OHOS::IPCObjectStub(u"") {};
127 virtual ~IPCObjectStubTest() = default;
OnRemoteRequest(uint32_t code,OHOS::MessageParcel & data,OHOS::MessageParcel & reply,OHOS::MessageOption & option)128 int OnRemoteRequest(
129 uint32_t code, OHOS::MessageParcel &data, OHOS::MessageParcel &reply, OHOS::MessageOption &option) override
130 {
131 HDF_LOGI("IPCObjectStubTest::OnRemoteRequest called, code = %{public}d", code);
132 payload = data.ReadInt32();
133
134 return HDF_SUCCESS;
135 }
136
137 static int32_t payload;
138 };
139
140 int32_t IPCObjectStubTest::payload = 0;
141
142 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest003, TestSize.Level1)
143 {
144 auto servmgr = IServiceManager::Get();
145 ASSERT_TRUE(servmgr != nullptr);
146
147 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
148 ASSERT_TRUE(sampleService != nullptr);
149
150 sptr<IRemoteObject> callback = new IPCObjectStubTest();
151 OHOS::MessageParcel data;
152 OHOS::MessageParcel reply;
153 int32_t payload = PAYLOAD_NUM;
154 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
155 ASSERT_EQ(ret, true);
156 data.WriteInt32(payload);
157 data.WriteRemoteObject(callback);
158
159 OHOS::MessageOption option;
160 int status = sampleService->SendRequest(SAMPLE_SERVICE_CALLBACK, data, reply, option);
161 ASSERT_EQ(status, 0);
162 ASSERT_EQ(IPCObjectStubTest::payload, payload);
163 }
164
165 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest004, TestSize.Level1)
166 {
167 auto servmgr = IServiceManager::Get();
168 ASSERT_TRUE(servmgr != nullptr);
169
170 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
171 ASSERT_TRUE(sampleService != nullptr);
172
173 OHOS::MessageParcel data;
174 OHOS::MessageParcel reply;
175 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
176 ASSERT_EQ(ret, true);
177 data.WriteInt32(PAYLOAD_NUM);
178 data.WriteInt32(PAYLOAD_NUM);
179
180 OHOS::MessageOption option;
181 int status = sampleService->SendRequest(SAMPLE_SERVICE_SUM, data, reply, option);
182 ASSERT_EQ(status, 0);
183 int32_t result = reply.ReadInt32();
184 int32_t expRes = PAYLOAD_NUM + PAYLOAD_NUM;
185 ASSERT_EQ(result, expRes);
186 }
187
188 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest006, TestSize.Level1)
189 {
190 auto servmgr = IServiceManager::Get();
191 ASSERT_TRUE(servmgr != nullptr);
192
193 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
194 ASSERT_TRUE(sampleService != nullptr);
195
196 OHOS::MessageParcel data;
197 OHOS::MessageParcel reply;
198
199 constexpr int buffersize = 10;
200 uint8_t dataBuffer[buffersize];
201 for (int i = 0; i < buffersize; i++) {
202 dataBuffer[i] = i;
203 }
204 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
205 ASSERT_EQ(ret, true);
206 ret = data.WriteUnpadBuffer(dataBuffer, sizeof(dataBuffer));
207 ASSERT_TRUE(ret);
208
209 OHOS::MessageOption option;
210 int status = sampleService->SendRequest(SAMPLE_BUFFER_TRANS, data, reply, option);
211 ASSERT_EQ(status, 0);
212
213 const uint8_t *retBuffer = reply.ReadUnpadBuffer(buffersize);
214 ASSERT_TRUE(retBuffer != nullptr);
215
216 for (int i = 0; i < buffersize; i++) {
217 ASSERT_EQ(retBuffer[i], i);
218 }
219 }
220
221 /*
222 * Test device manager Load/UnLoad device and driver dynamic register device
223 */
224 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest007, TestSize.Level1)
225 {
226 auto devmgr = IDeviceManager::Get();
227 ASSERT_TRUE(devmgr != nullptr);
228 devmgr->UnloadDevice(TEST_SERVICE_NAME);
229
230 auto servmgr = IServiceManager::Get();
231 ASSERT_TRUE(servmgr != nullptr);
232 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
233 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
234 ASSERT_TRUE(sampleService == nullptr);
235
236 int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
237 ASSERT_EQ(ret, HDF_SUCCESS);
238 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
239 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
240 ASSERT_TRUE(sampleService != nullptr);
241
242 OHOS::MessageParcel data;
243 OHOS::MessageParcel reply;
244 OHOS::MessageOption option;
245 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
246 ASSERT_EQ(ret, true);
247 const char *newServName = "sample_driver_service2";
248 ret = data.WriteCString(newServName);
249 ASSERT_TRUE(ret);
250
251 int status = sampleService->SendRequest(SAMPLE_REGISTER_DEVICE, data, reply, option);
252 ASSERT_EQ(status, HDF_SUCCESS);
253
254 auto sampleService2 = servmgr->GetService(newServName);
255 ASSERT_TRUE(sampleService != nullptr);
256
257 data.FlushBuffer();
258 reply.FlushBuffer();
259 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
260 ASSERT_EQ(ret, true);
261 data.WriteInt32(PAYLOAD_NUM);
262 data.WriteInt32(PAYLOAD_NUM);
263
264 status = sampleService2->SendRequest(SAMPLE_SERVICE_SUM, data, reply, option);
265 ASSERT_EQ(status, 0);
266 int32_t result = reply.ReadInt32();
267
268 int32_t expRes = PAYLOAD_NUM + PAYLOAD_NUM;
269 ASSERT_EQ(result, expRes);
270 sampleService2 = nullptr;
271
272 data.FlushBuffer();
273 reply.FlushBuffer();
274 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
275 ASSERT_EQ(ret, true);
276 data.WriteCString(newServName);
277
278 status = sampleService->SendRequest(SAMPLE_UNREGISTER_DEVICE, data, reply, option);
279 ASSERT_EQ(status, HDF_SUCCESS);
280
281 sampleService2 = servmgr->GetService(newServName);
282 ASSERT_TRUE(sampleService2 == nullptr);
283
284 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
285 ASSERT_EQ(ret, HDF_SUCCESS);
286 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
287 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
288 ASSERT_TRUE(sampleService == nullptr);
289 }
290 #endif
291
292 class ServStatListener : public OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub {
293 public:
294 using StatusCallback = std::function<void(const ServiceStatus &)>;
ServStatListener(StatusCallback callback)295 explicit ServStatListener(StatusCallback callback) : callback_(std::move(callback)) {}
296 ~ServStatListener() = default;
OnReceive(const ServiceStatus & status)297 void OnReceive(const ServiceStatus &status) override
298 {
299 callback_(status);
300 }
301
302 private:
303 StatusCallback callback_;
304 };
305
306 #ifdef SAMPLE_DRIVER
307 /*
308 * Test service start status listener
309 */
TestServiceListenerStop(const sptr<IDeviceManager> & devmgr,const sptr<IServiceManager> & servmgr)310 void HdfServiceMangerHdiTest::TestServiceListenerStop(const sptr<IDeviceManager>& devmgr,
311 const sptr<IServiceManager>& servmgr)
312 {
313 std::string servInfo;
314 uint16_t devClass;
315 uint16_t servStatus;
316 bool callbacked = false;
317 ::OHOS::sptr<IServStatListener> listener
318 = new ServStatListener(ServStatListener::StatusCallback([&](const ServiceStatus &status) {
319 HDF_LOGI("service status callback");
320 if (status.serviceName == std::string(TEST_SERVICE_NAME)) {
321 servInfo = status.info;
322 devClass = status.deviceClass;
323 servStatus = status.status;
324 callbacked = true;
325 }
326 }));
327
328 int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
329 ASSERT_EQ(status, HDF_SUCCESS);
330
331 int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
332 ASSERT_EQ(ret, HDF_SUCCESS);
333 constexpr int waitCount = 300;
334 int count = waitCount;
335 while (!callbacked && count > 0) {
336 OsalMSleep(1);
337 count--;
338 }
339 ASSERT_TRUE(callbacked);
340 ASSERT_EQ(devClass, DEVICE_CLASS_DEFAULT);
341 ASSERT_EQ(servInfo, std::string(TEST_SERVICE_NAME));
342 ASSERT_EQ(servStatus, OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
343
344 callbacked = false;
345 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
346 ASSERT_EQ(ret, HDF_SUCCESS);
347
348 count = waitCount;
349 while (!callbacked && count > 0) {
350 OsalMSleep(1);
351 count--;
352 }
353 ASSERT_TRUE(callbacked);
354 ASSERT_EQ(devClass, DEVICE_CLASS_DEFAULT);
355 ASSERT_EQ(servInfo, std::string(TEST_SERVICE_NAME));
356 ASSERT_EQ(servStatus, OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP);
357
358 status = servmgr->UnregisterServiceStatusListener(listener);
359 ASSERT_EQ(status, HDF_SUCCESS);
360 }
361
362 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest008, TestSize.Level1)
363 {
364 auto devmgr = IDeviceManager::Get();
365 ASSERT_TRUE(devmgr != nullptr);
366 devmgr->UnloadDevice(TEST_SERVICE_NAME);
367
368 auto servmgr = IServiceManager::Get();
369 ASSERT_TRUE(servmgr != nullptr);
370 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
371 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
372 ASSERT_TRUE(sampleService == nullptr);
373
374 TestServiceListenerStop(devmgr, servmgr);
375 }
376
377 /*
378 * Test service status listener update service info
379 */
TestSampleService(sptr<IRemoteObject> & sampleService,const sptr<IDeviceManager> & devmgr,const sptr<IServiceManager> & servmgr)380 void HdfServiceMangerHdiTest::TestSampleService(sptr<IRemoteObject>& sampleService,
381 const sptr<IDeviceManager>& devmgr, const sptr<IServiceManager>& servmgr)
382 {
383 std::string servInfo;
384 uint16_t devClass;
385 uint16_t servStatus;
386 bool callbacked = false;
387 ::OHOS::sptr<IServStatListener> listener
388 = new ServStatListener(
389 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
390 if (status.serviceName == std::string(TEST_SERVICE_NAME) &&
391 status.status == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_CHANGE) {
392 HDF_LOGI("sample service status callback");
393 servInfo = status.info;
394 devClass = status.deviceClass;
395 servStatus = status.status;
396 callbacked = true;
397 }
398 }));
399
400 int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
401 ASSERT_EQ(status, HDF_SUCCESS);
402 constexpr int FIRST_WAIT = 20;
403 OsalMSleep(FIRST_WAIT); // skip callback on register
404 OHOS::MessageParcel data;
405 OHOS::MessageParcel reply;
406 OHOS::MessageOption option;
407 bool res = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
408 ASSERT_EQ(res, true);
409 std::string info = "foo";
410 data.WriteCString(info.data());
411 callbacked = false;
412 status = sampleService->SendRequest(SAMPLE_UPDATE_SERVIE, data, reply, option);
413 ASSERT_EQ(status, HDF_SUCCESS);
414 constexpr int waitCount = 300;
415 int count = waitCount;
416 while (!callbacked && count > 0) {
417 OsalMSleep(1);
418 count--;
419 }
420 ASSERT_TRUE(callbacked);
421 ASSERT_EQ(devClass, DEVICE_CLASS_DEFAULT);
422 ASSERT_EQ(servInfo, info);
423 int ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
424 ASSERT_EQ(ret, HDF_SUCCESS);
425
426 status = servmgr->UnregisterServiceStatusListener(listener);
427 ASSERT_EQ(status, HDF_SUCCESS);
428 }
429
430 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest009, TestSize.Level1)
431 {
432 auto devmgr = IDeviceManager::Get();
433 ASSERT_TRUE(devmgr != nullptr);
434 devmgr->UnloadDevice(TEST_SERVICE_NAME);
435
436 auto servmgr = IServiceManager::Get();
437 ASSERT_TRUE(servmgr != nullptr);
438 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
439 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
440 ASSERT_TRUE(sampleService == nullptr);
441
442 int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
443 ASSERT_EQ(ret, HDF_SUCCESS);
444 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
445 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
446 ASSERT_TRUE(sampleService != nullptr);
447
448 TestSampleService(sampleService, devmgr, servmgr);
449 }
450
451 /*
452 * Test service status listener unregister
453 */
454 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest010, TestSize.Level1)
455 {
456 auto devmgr = IDeviceManager::Get();
457 ASSERT_TRUE(devmgr != nullptr);
458 devmgr->UnloadDevice(TEST_SERVICE_NAME);
459
460 auto servmgr = IServiceManager::Get();
461 ASSERT_TRUE(servmgr != nullptr);
462 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
463 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
464 ASSERT_TRUE(sampleService == nullptr);
465
466 std::string servInfo;
467 uint16_t devClass;
468 uint16_t servStatus;
469 bool callbacked = false;
470 ::OHOS::sptr<IServStatListener> listener
471 = new ServStatListener(
__anon8a9022f10302(const ServiceStatus &status) 472 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
473 HDF_LOGI("service status callback");
474 if (status.serviceName == std::string(TEST_SERVICE_NAME) &&
475 status.status == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) {
476 servInfo = status.info;
477 devClass = status.deviceClass;
478 servStatus = status.status;
479 callbacked = true;
480 }
481 }));
482
483 int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
484 ASSERT_EQ(status, HDF_SUCCESS);
485
486 int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
487 ASSERT_EQ(ret, HDF_SUCCESS);
488
489 constexpr int waitCount = 300;
490 int count = waitCount;
491 while (!callbacked && count > 0) {
492 OsalMSleep(1);
493 count--;
494 }
495 ASSERT_TRUE(callbacked);
496 ASSERT_EQ(devClass, DEVICE_CLASS_DEFAULT);
497 ASSERT_EQ(servInfo, std::string(TEST_SERVICE_NAME));
498
499 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
500 ASSERT_TRUE(sampleService != nullptr);
501
502 status = servmgr->UnregisterServiceStatusListener(listener);
503 ASSERT_EQ(status, HDF_SUCCESS);
504
505 callbacked = false;
506 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
507 ASSERT_EQ(ret, HDF_SUCCESS);
508
509 OsalMSleep(10);
510 ASSERT_FALSE(callbacked);
511
512 ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
513 ASSERT_EQ(ret, HDF_SUCCESS);
514 }
515
516 /*
517 * smq test normal read/write
518 */
519 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest011, TestSize.Level1)
520 {
521 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
522 auto servmgr = IServiceManager::Get();
523 ASSERT_TRUE(servmgr != nullptr);
524
525 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
526 ASSERT_TRUE(sampleService != nullptr);
527
528 OHOS::MessageParcel data;
529 OHOS::MessageParcel reply;
530 OHOS::MessageOption option;
531 std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
532 std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::SYNCED_SMQ);
533 ASSERT_TRUE(smq->IsGood());
534 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
535 ASSERT_EQ(ret, true);
536 ret = smq->GetMeta()->Marshalling(data);
537 ASSERT_TRUE(ret);
538 data.WriteUint32(1);
539
540 int status = sampleService->SendRequest(SAMPLE_TRANS_SMQ, data, reply, option);
541 ASSERT_EQ(status, 0);
542
543 constexpr int SEND_TIMES = 20;
544 for (size_t i = 0; i < SEND_TIMES; i++) {
545 SampleSmqElement t = {0};
546 t.data32 = i;
547 t.data64 = i + 1;
548
549 HDF_LOGI("%{public}s:write smq message %{public}zu", __func__, i);
550 auto status = smq->Write(&t, 1, OHOS::MillisecToNanosec(SMQ_TEST_WAIT_TIME));
551 ASSERT_EQ(status, 0);
552 }
553 }
554
555 /*
556 * smq test with overflow wait
557 */
558 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest012, TestSize.Level1)
559 {
560 auto servmgr = IServiceManager::Get();
561 ASSERT_TRUE(servmgr != nullptr);
562
563 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
564 ASSERT_TRUE(sampleService != nullptr);
565
566 OHOS::MessageParcel data;
567 OHOS::MessageParcel reply;
568 OHOS::MessageOption option;
569 std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
570 std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::SYNCED_SMQ);
571 ASSERT_TRUE(smq->IsGood());
572 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
573 ASSERT_EQ(ret, true);
574 constexpr uint32_t ELEMENT_SIZE = 2;
575 ret = smq->GetMeta()->Marshalling(data);
576 ASSERT_TRUE(ret);
577
578 data.WriteUint32(ELEMENT_SIZE);
579 int status = sampleService->SendRequest(SAMPLE_TRANS_SMQ, data, reply, option);
580 ASSERT_EQ(status, 0);
581
582 constexpr int SEND_TIMES = 20;
583 for (int i = 0; i < SEND_TIMES; i++) {
584 SampleSmqElement t[ELEMENT_SIZE] = {};
585 t[0].data32 = i;
586 t[0].data64 = i + 1;
587 t[1].data32 = i + 1;
588 t[1].data64 = i + 1;
589 HDF_LOGI("%{public}s:write smq message %{public}d", __func__, i);
590 auto status = smq->Write(&t[0], ELEMENT_SIZE, OHOS::MillisecToNanosec(SMQ_TEST_WAIT_TIME));
591 ASSERT_EQ(status, 0);
592 }
593 }
594
595 /*
596 * smq test UNSYNC_SMQ
597 */
598 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest013, TestSize.Level1)
599 {
600 auto servmgr = IServiceManager::Get();
601 ASSERT_TRUE(servmgr != nullptr);
602
603 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
604 ASSERT_TRUE(sampleService != nullptr);
605
606 OHOS::MessageParcel data;
607 OHOS::MessageParcel reply;
608 OHOS::MessageOption option;
609
610 std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
611 std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::UNSYNC_SMQ);
612 ASSERT_TRUE(smq->IsGood());
613 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
614 ASSERT_EQ(ret, true);
615 constexpr uint32_t ELEMENT_SIZE = 2;
616 ret = smq->GetMeta()->Marshalling(data);
617 ASSERT_TRUE(ret);
618 data.WriteUint32(ELEMENT_SIZE);
619 auto status = sampleService->SendRequest(SAMPLE_TRANS_SMQ, data, reply, option);
620 ASSERT_EQ(status, 0);
621
622 SampleSmqElement t[ELEMENT_SIZE] = {};
623 status = smq->Write(&t[0], ELEMENT_SIZE);
624 EXPECT_NE(status, 0);
625 constexpr int SEND_TIMES = 20;
626 for (int i = 0; i < SEND_TIMES; i++) {
627 t[0].data32 = i;
628 t[0].data64 = i + 1;
629 t[1].data32 = i + 1;
630 t[1].data64 = i + 1;
631 HDF_LOGI("%{public}s:write smq message %{public}d", __func__, i);
632 status = smq->WriteNonBlocking(&t[0], ELEMENT_SIZE);
633 ASSERT_EQ(status, 0);
634 }
635 }
636
637 /*
638 * Test service status listener get serviec callback on register
639 */
640 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest014, TestSize.Level1)
641 {
642 auto servmgr = IServiceManager::Get();
643 ASSERT_TRUE(servmgr != nullptr);
644
645 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
646 ASSERT_NE(sampleService, nullptr);
647
648 bool callbacked = false;
649 bool sampleServiceStarted = false;
650 uint16_t servStatus = 0;
651 ::OHOS::sptr<IServStatListener> listener
652 = new ServStatListener(
__anon8a9022f10402(const ServiceStatus &status) 653 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
654 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
655 callbacked = true;
656 if (status.serviceName == std::string(TEST_SERVICE_NAME)) {
657 sampleServiceStarted = true;
658 servStatus = status.status;
659 }
660 }));
661
662 int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
663 ASSERT_EQ(status, HDF_SUCCESS);
664 constexpr int waitCount = 100;
665 int count = waitCount;
666 while (!sampleServiceStarted && count > 0) {
667 OsalMSleep(1);
668 count--;
669 }
670 ASSERT_TRUE(callbacked);
671 ASSERT_TRUE(sampleServiceStarted);
672 ASSERT_EQ(servStatus, OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
673 status = servmgr->UnregisterServiceStatusListener(listener);
674 ASSERT_EQ(status, HDF_SUCCESS);
675 }
676
677 /*
678 * Test get service set by interfacedesc
679 */
680 HWTEST_F(HdfServiceMangerHdiTest, ListServiceByInterfaceDescTest001, TestSize.Level1)
681 {
682 auto servmgr = IServiceManager::Get();
683 ASSERT_TRUE(servmgr != nullptr);
684 std::vector<std::string> serviceNames;
685 int ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_N);
686 ASSERT_TRUE(ret == HDF_SUCCESS);
687 ASSERT_FALSE(serviceNames.empty());
688 ASSERT_TRUE(serviceNames.front().compare(TEST_SERVICE_NAME) == 0);
689 }
690 #endif
691
692 HWTEST_F(HdfServiceMangerHdiTest, ListServiceByInterfaceDescTest002, TestSize.Level1)
693 {
694 auto servmgr = IServiceManager::Get();
695 ASSERT_TRUE(servmgr != nullptr);
696 std::vector<std::string> serviceNames;
697 int ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_INVALID);
698 ASSERT_TRUE(ret == HDF_SUCCESS);
699 ASSERT_TRUE(serviceNames.empty());
700 }
701
702 HWTEST_F(HdfServiceMangerHdiTest, ListServiceByInterfaceDescTest003, TestSize.Level1)
703 {
704 auto servmgr = IServiceManager::Get();
705 ASSERT_TRUE(servmgr != nullptr);
706 std::vector<std::string> serviceNames;
707 int ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_VOID);
708 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM);
709 ASSERT_TRUE(serviceNames.empty());
710 }
711
712 HWTEST_F(HdfServiceMangerHdiTest, ListServiceByInterfaceDescTest004, TestSize.Level1)
713 {
714 auto servmgr = IServiceManager::Get();
715 ASSERT_TRUE(servmgr != nullptr);
716 std::vector<std::string> serviceNames;
717 int ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_NULL);
718 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM);
719 ASSERT_TRUE(serviceNames.empty());
720 }
721
722 #ifdef SAMPLE_DRIVER
723 HWTEST_F(HdfServiceMangerHdiTest, ListServiceByInterfaceDescTest005, TestSize.Level1)
724 {
725 auto devmgr = IDeviceManager::Get();
726 ASSERT_TRUE(devmgr != nullptr);
727 int ret = devmgr->LoadDevice(TEST1_SERVICE_NAME);
728 ASSERT_TRUE(ret == HDF_SUCCESS);
729 auto servmgr = IServiceManager::Get();
730 ASSERT_TRUE(servmgr != nullptr);
731 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
732 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
733 ASSERT_TRUE(sampleService != nullptr);
734 auto sample1Service = servmgr->GetService(TEST1_SERVICE_NAME);
735 ASSERT_TRUE(sample1Service != nullptr);
736
737 std::vector<std::string> serviceNames;
738 ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_N);
739 ASSERT_TRUE(ret == HDF_SUCCESS);
740 constexpr int sampleServiceCount = 2;
741 ASSERT_TRUE(serviceNames.size() == sampleServiceCount);
742 ASSERT_TRUE(serviceNames[0].compare(TEST_SERVICE_NAME) == 0);
743 ASSERT_TRUE(serviceNames[1].compare(TEST1_SERVICE_NAME) == 0);
744 ret = devmgr->UnloadDevice(TEST1_SERVICE_NAME);
745 ASSERT_EQ(ret, HDF_SUCCESS);
746 }
747 #endif
748
749 HWTEST_F(HdfServiceMangerHdiTest, ListAllServiceTest, TestSize.Level1)
750 {
751 auto servmgr = IServiceManager::Get();
752 ASSERT_TRUE(servmgr != nullptr);
753
754 std::vector<HdiServiceInfo> serviceInfos;
755 int ret = servmgr->ListAllService(serviceInfos);
756 ASSERT_TRUE(ret == HDF_SUCCESS);
757 ASSERT_TRUE(serviceInfos.size() != 0);
758 }
759
760 HWTEST_F(HdfServiceMangerHdiTest, ListAllDeviceTest, TestSize.Level1)
761 {
762 auto devmgr = IDeviceManager::Get();
763 ASSERT_TRUE(devmgr != nullptr);
764
765 std::vector<HdiDevHostInfo> deviceInfos;
766 int ret = devmgr->ListAllDevice(deviceInfos);
767 ASSERT_TRUE(ret == HDF_SUCCESS);
768 ASSERT_TRUE(deviceInfos.size() != 0);
769 }
770
771 HWTEST_F(HdfServiceMangerHdiTest, ListAllHostTest, TestSize.Level1)
772 {
773 auto devmgr = IDeviceManager::Get();
774 ASSERT_TRUE(devmgr != nullptr);
775
776 int32_t ret;
777 constexpr int loop = 100;
778 for (int i = 0; i < loop; i++) {
779 std::vector<int> pidList;
780 ret = devmgr->ListAllHost(pidList);
781 ASSERT_TRUE(ret == HDF_SUCCESS);
782 ASSERT_TRUE(pidList.size() != 0);
783 pidList.clear();
784 }
785 }
786
787 #ifdef SAMPLE_DRIVER
788 HWTEST_F(HdfServiceMangerHdiTest, EndSampleHostTest, TestSize.Level1)
789 {
790 auto servmgr = IServiceManager::Get();
791 ASSERT_TRUE(servmgr != nullptr);
792
793 auto devmgr = IDeviceManager::Get();
794 ASSERT_TRUE(devmgr != nullptr);
795
796 int ret = devmgr->LoadDevice(TEST1_SERVICE_NAME);
797 ASSERT_TRUE(ret == HDF_SUCCESS);
798 auto sample1Service = servmgr->GetService(TEST1_SERVICE_NAME);
799 constexpr int waitCount = 1000;
800 constexpr int msleepTime = 10;
801 constexpr int waitHostStart = 100;
802 uint32_t cnt = 0;
803 while (sample1Service == nullptr && cnt < waitCount) {
804 OsalMSleep(msleepTime);
805 sample1Service = servmgr->GetService(TEST1_SERVICE_NAME);
806 cnt++;
807 }
808 ASSERT_TRUE(sample1Service != nullptr);
809 ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
810 ASSERT_TRUE(ret == HDF_SUCCESS);
811 cnt = 0;
812 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
813 while (sampleService == nullptr && cnt < waitCount) {
814 OsalMSleep(msleepTime);
815 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
816 cnt++;
817 }
818 ASSERT_TRUE(sampleService != nullptr);
819
820 ret = devmgr->UnloadDevice(TEST1_SERVICE_NAME);
821 ASSERT_TRUE(ret == HDF_SUCCESS);
822 sample1Service = servmgr->GetService(TEST1_SERVICE_NAME);
823 OsalMSleep(msleepTime);
824
825 OHOS::MessageParcel data;
826 OHOS::MessageParcel reply;
827 OHOS::MessageOption option;
828 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
829 ASSERT_EQ(ret, true);
830
831 ret = sampleService->SendRequest(SAMPLE_END_HOST, data, reply, option);
832 ASSERT_TRUE(ret == HDF_SUCCESS);
833 OsalMSleep(waitHostStart);
834
835 ret = devmgr->UnloadDevice(TEST1_SERVICE_NAME);
836 ASSERT_TRUE(ret == HDF_SUCCESS);
837 OsalMSleep(msleepTime);
838 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
839 ASSERT_TRUE(ret == HDF_SUCCESS);
840 }
841
842 HWTEST_F(HdfServiceMangerHdiTest, InjectPmTest, TestSize.Level1)
843 {
844 auto servmgr = IServiceManager::Get();
845 ASSERT_TRUE(servmgr != nullptr);
846
847 auto devmgr = IDeviceManager::Get();
848 ASSERT_TRUE(devmgr != nullptr);
849
850 int ret = devmgr->LoadDevice(TEST1_SERVICE_NAME);
851 ASSERT_TRUE(ret == HDF_SUCCESS);
852 auto sample1Service = servmgr->GetService(TEST1_SERVICE_NAME);
853 constexpr int waitCount = 1000;
854 constexpr int waitHostStart = 100;
855 constexpr int msleepTime = 10;
856 uint32_t cnt = 0;
857 while (sample1Service == nullptr && cnt < waitCount) {
858 OsalMSleep(msleepTime);
859 sample1Service = servmgr->GetService(TEST1_SERVICE_NAME);
860 cnt++;
861 }
862 ASSERT_TRUE(sample1Service != nullptr);
863 ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
864 ASSERT_TRUE(ret == HDF_SUCCESS);
865 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
866 cnt = 0;
867 while (sampleService == nullptr && cnt < waitCount) {
868 OsalMSleep(msleepTime);
869 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
870 cnt++;
871 }
872 ASSERT_TRUE(sampleService != nullptr);
873
874 OHOS::MessageParcel data;
875 OHOS::MessageParcel reply;
876 OHOS::MessageOption option;
877 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
878 ASSERT_EQ(ret, true);
879
880 ret = sampleService->SendRequest(SAMPLE_INJECT_PM, data, reply, option);
881 ASSERT_TRUE(ret == HDF_SUCCESS);
882 OsalMSleep(msleepTime);
883 ret = sampleService->SendRequest(SAMPLE_END_HOST, data, reply, option);
884 ASSERT_TRUE(ret == HDF_SUCCESS);
885 OsalMSleep(waitHostStart);
886
887 ret = devmgr->UnloadDevice(TEST1_SERVICE_NAME);
888 ASSERT_TRUE(ret == HDF_SUCCESS);
889 OsalMSleep(msleepTime);
890 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
891 ASSERT_TRUE(ret == HDF_SUCCESS);
892 }
893 #endif
894
895 HWTEST_F(HdfServiceMangerHdiTest, ListenerTest001, TestSize.Level1)
896 {
897 ::OHOS::sptr<ServStatListener> listener
898 = new ServStatListener(
__anon8a9022f10502(const ::OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) 899 ServStatListener::StatusCallback([&](const ::OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) {
900 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
901 }));
902
903 MessageParcel data;
904 MessageParcel reply;
905 MessageOption option;
906
907 // invalid code
908 int32_t ret = listener->OnRemoteRequest(SERVIE_STATUS_LISTENER_MAX, data, reply, option);
909 ASSERT_NE(ret, HDF_SUCCESS);
910
911 // empty data
912 ret = listener->OnRemoteRequest(SERVIE_STATUS_LISTENER_NOTIFY, data, reply, option);
913 ASSERT_NE(ret, HDF_SUCCESS);
914 }
915
916 HWTEST_F(HdfServiceMangerHdiTest, ListenerTest002, TestSize.Level1)
917 {
918 ::OHOS::sptr<ServStatListener> listener
919 = new ServStatListener(
__anon8a9022f10602(const ::OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) 920 ServStatListener::StatusCallback([&](const ::OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) {
921 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
922 }));
923
924 MessageParcel data;
925 MessageParcel reply;
926 MessageOption option;
927
928 bool ret = data.WriteInterfaceToken(IServStatListener::GetDescriptor());
929 ASSERT_TRUE(ret);
930 int32_t reqRet = listener->OnRemoteRequest(SERVIE_STATUS_LISTENER_NOTIFY, data, reply, option);
931 ASSERT_NE(reqRet, HDF_SUCCESS);
932 }
933
934 HWTEST_F(HdfServiceMangerHdiTest, ListenerTest003, TestSize.Level1)
935 {
936 ::OHOS::sptr<ServStatListener> listener
937 = new ServStatListener(
__anon8a9022f10702(const ::OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) 938 ServStatListener::StatusCallback([&](const ::OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) {
939 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
940 }));
941
942 MessageParcel data;
943 MessageParcel reply;
944 MessageOption option;
945
946 bool ret = data.WriteInterfaceToken(IServStatListener::GetDescriptor());
947 ASSERT_TRUE(ret);
948 ret = data.WriteCString("");
949 ASSERT_TRUE(ret);
950
951 int32_t reqRet = listener->OnRemoteRequest(SERVIE_STATUS_LISTENER_NOTIFY, data, reply, option);
952 ASSERT_NE(reqRet, HDF_SUCCESS);
953 }
954
955 HWTEST_F(HdfServiceMangerHdiTest, ListenerTest004, TestSize.Level1)
956 {
957 ::OHOS::sptr<ServStatListener> listener
958 = new ServStatListener(
__anon8a9022f10802(const ::OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) 959 ServStatListener::StatusCallback([&](const ::OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) {
960 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
961 }));
962
963 MessageParcel data;
964 MessageParcel reply;
965 MessageOption option;
966
967 bool ret = data.WriteInterfaceToken(IServStatListener::GetDescriptor());
968 ASSERT_TRUE(ret);
969 ret = data.WriteCString("test_service");
970 ASSERT_TRUE(ret);
971
972 int32_t reqRet = listener->OnRemoteRequest(SERVIE_STATUS_LISTENER_NOTIFY, data, reply, option);
973 ASSERT_NE(reqRet, HDF_SUCCESS);
974 }
975
976 HWTEST_F(HdfServiceMangerHdiTest, ListenerTest005, TestSize.Level1)
977 {
978 ::OHOS::sptr<ServStatListener> listener
979 = new ServStatListener(
__anon8a9022f10902(const ::OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) 980 ServStatListener::StatusCallback([&](const ::OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) {
981 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
982 }));
983
984 MessageParcel data;
985 MessageParcel reply;
986 MessageOption option;
987
988 bool ret = data.WriteInterfaceToken(IServStatListener::GetDescriptor());
989 ASSERT_TRUE(ret);
990 ret = data.WriteCString("test_service");
991 ASSERT_TRUE(ret);
992 // write deviceClass
993 ret = data.WriteUint16(DeviceClass::DEVICE_CLASS_DEFAULT);
994 ASSERT_TRUE(ret);
995
996 int32_t reqRet = listener->OnRemoteRequest(SERVIE_STATUS_LISTENER_NOTIFY, data, reply, option);
997 ASSERT_NE(reqRet, HDF_SUCCESS);
998 }
999
1000 HWTEST_F(HdfServiceMangerHdiTest, ListenerTest006, TestSize.Level1)
1001 {
1002 ::OHOS::sptr<ServStatListener> listener
1003 = new ServStatListener(
__anon8a9022f10a02(const ::OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) 1004 ServStatListener::StatusCallback([&](const ::OHOS::HDI::ServiceManager::V1_0::ServiceStatus &status) {
1005 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
1006 }));
1007
1008 MessageParcel data;
1009 MessageParcel reply;
1010 MessageOption option;
1011
1012 bool ret = data.WriteInterfaceToken(IServStatListener::GetDescriptor());
1013 ASSERT_TRUE(ret);
1014 ret = data.WriteCString("test_service");
1015 ASSERT_TRUE(ret);
1016 // write deviceClass
1017 ret = data.WriteUint16(DeviceClass::DEVICE_CLASS_DEFAULT);
1018 ASSERT_TRUE(ret);
1019 // write status
1020 ret = data.WriteUint16(ServiceStatusType::SERVIE_STATUS_START);
1021 ASSERT_TRUE(ret);
1022
1023 int32_t reqRet = listener->OnRemoteRequest(SERVIE_STATUS_LISTENER_NOTIFY, data, reply, option);
1024 ASSERT_EQ(reqRet, HDF_SUCCESS);
1025 }
1026
1027 HWTEST_F(HdfServiceMangerHdiTest, InvalidCodeTest001, TestSize.Level1)
1028 {
1029 auto servmgr = OHOS::HDI::ServiceManager::V1_0::IServiceManager::Get();
1030 ASSERT_NE(servmgr, nullptr);
1031
1032 sptr<IRemoteObject> remote = servmgr->GetService("hdf_device_manager");
1033 ASSERT_NE(remote, nullptr);
1034
1035 MessageParcel data;
1036 MessageParcel reply;
1037 MessageOption option;
1038
1039 ASSERT_TRUE(data.WriteInterfaceToken(IDeviceManager::GetDescriptor()));
1040 int ret = remote->SendRequest(INVALID_CODE, data, reply, option);
1041 EXPECT_EQ(ret, ERROR_CODE_WITH_INVALID_CODE);
1042 }
1043
1044 HWTEST_F(HdfServiceMangerHdiTest, InvalidCodeTest002, TestSize.Level1)
1045 {
1046 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1047 ASSERT_NE(saManager, nullptr);
1048 sptr<IRemoteObject> remote = saManager->GetSystemAbility(DEVICE_SERVICE_MANAGER_SA_ID);
1049 ASSERT_NE(remote, nullptr);
1050
1051 MessageParcel data;
1052 MessageParcel reply;
1053 MessageOption option;
1054
1055 ASSERT_TRUE(data.WriteInterfaceToken(OHOS::HDI::ServiceManager::V1_0::IServiceManager::GetDescriptor()));
1056 int ret = remote->SendRequest(INVALID_CODE, data, reply, option);
1057 ASSERT_EQ(ret, ERROR_CODE_WITH_INVALID_CODE);
1058 }
1059 } // namespace OHOS
1060