1 /*
2 * Copyright (c) 2021-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 <functional>
17 #include <gtest/gtest.h>
18 #include <hdf_io_service_if.h>
19 #include <hdf_log.h>
20 #include <base/hdi_smq.h>
21 #include <idevmgr_hdi.h>
22 #include <iostream>
23 #include <ipc_object_stub.h>
24 #include <iservmgr_hdi.h>
25 #include <osal_time.h>
26 #include <string>
27 #include <iservstat_listener_hdi.h>
28
29 #include "sample_hdi.h"
30
31 #define HDF_LOG_TAG service_manager_test_cpp
32
33 using namespace testing::ext;
34 using OHOS::IRemoteObject;
35 using OHOS::sptr;
36 using OHOS::HDI::Base::SharedMemQueue;
37 using OHOS::HDI::Base::SharedMemQueueMeta;
38 using OHOS::HDI::Base::SmqType;
39 using OHOS::HDI::DeviceManager::V1_0::IDeviceManager;
40 using OHOS::HDI::ServiceManager::V1_0::IServiceManager;
41 using OHOS::HDI::ServiceManager::V1_0::IServStatListener;
42 using OHOS::HDI::ServiceManager::V1_0::ServiceStatus;
43 using OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub;
44 using OHOS::HDI::DeviceManager::V1_0::HdiDevHostInfo;
45 using OHOS::HDI::ServiceManager::V1_0::HdiServiceInfo;
46 static constexpr const char *TEST_SERVICE_NAME = "sample_driver_service";
47 static constexpr const char *TEST1_SERVICE_NAME = "sample1_driver_service";
48 static constexpr const char16_t *TEST_SERVICE_INTERFACE_DESC = u"hdf.test.sampele_service";
49 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_N = "hdf.test.sampele_service";
50 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_INVALID = "___";
51 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_VOID = "";
52 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_NULL = nullptr;
53 static constexpr int PAYLOAD_NUM = 1234;
54 static constexpr int SMQ_TEST_QUEUE_SIZE = 10;
55 static constexpr int SMQ_TEST_WAIT_TIME = 100;
56 static constexpr int WAIT_LOAD_UNLOAD_TIME = 300;
57
58 class HdfServiceMangerHdiTest : public testing::Test {
59 public:
SetUpTestCase()60 static void SetUpTestCase()
61 {
62 auto devmgr = IDeviceManager::Get();
63 if (devmgr != nullptr) {
64 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
65 devmgr->LoadDevice(TEST_SERVICE_NAME);
66 }
67 }
TearDownTestCase()68 static void TearDownTestCase()
69 {
70 auto devmgr = IDeviceManager::Get();
71 if (devmgr != nullptr) {
72 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
73 devmgr->UnloadDevice(TEST_SERVICE_NAME);
74 }
75 }
76 void TestServiceListenerStop(const sptr<IDeviceManager>& devmgr, const sptr<IServiceManager>& servmgr);
77 void TestSampleService(sptr<IRemoteObject>& sampleService, const sptr<IDeviceManager>& devmgr,
78 const sptr<IServiceManager>& servmgr);
SetUp()79 void SetUp() {};
TearDown()80 void TearDown() {};
81 };
82
83 class IPCObjectStubTest : public OHOS::IPCObjectStub {
84 public:
IPCObjectStubTest()85 explicit IPCObjectStubTest() : OHOS::IPCObjectStub(u"") {};
86 virtual ~IPCObjectStubTest() = default;
OnRemoteRequest(uint32_t code,OHOS::MessageParcel & data,OHOS::MessageParcel & reply,OHOS::MessageOption & option)87 int OnRemoteRequest(
88 uint32_t code, OHOS::MessageParcel &data, OHOS::MessageParcel &reply, OHOS::MessageOption &option) override
89 {
90 HDF_LOGI("IPCObjectStubTest::OnRemoteRequest called, code = %{public}d", code);
91 payload = data.ReadInt32();
92
93 return HDF_SUCCESS;
94 }
95
96 static int32_t payload;
97 };
98
99 int32_t IPCObjectStubTest::payload = 0;
100
101 /**
102 * @tc.number: SUB_DriverSystem_ManagerService_0010
103 * @tc.name: open input device test
104 * @tc.size: Medium
105 * @tc.level: level 1
106 */
107 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest001, Function | MediumTest | Level1)
108 {
109 auto servmgr = IServiceManager::Get();
110 ASSERT_TRUE(servmgr != nullptr);
111 }
112
113 /**
114 * @tc.number: SUB_DriverSystem_ManagerService_0020
115 * @tc.name: open input device test
116 * @tc.size: Medium
117 * @tc.level: level 1
118 */
119 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest002, Function | MediumTest | Level1)
120 {
121 auto servmgr = IServiceManager::Get();
122 ASSERT_TRUE(servmgr != nullptr);
123
124 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
125
126 ASSERT_TRUE(sampleService != nullptr);
127
128 OHOS::MessageParcel data;
129 OHOS::MessageParcel reply;
130 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
131 ASSERT_EQ(ret, true);
132 data.WriteCString("sample_service test call");
133
134 OHOS::MessageOption option;
135 int status = sampleService->SendRequest(SAMPLE_SERVICE_PING, data, reply, option);
136 ASSERT_EQ(status, 0);
137 }
138
139 /**
140 * @tc.number: SUB_DriverSystem_ManagerService_0030
141 * @tc.name: open input device test
142 * @tc.size: Medium
143 * @tc.level: level 1
144 */
145 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest003, Function | MediumTest | Level1)
146 {
147 auto servmgr = IServiceManager::Get();
148 ASSERT_TRUE(servmgr != nullptr);
149
150 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
151 ASSERT_TRUE(sampleService != nullptr);
152
153 sptr<IRemoteObject> callback = new IPCObjectStubTest();
154 OHOS::MessageParcel data;
155 OHOS::MessageParcel reply;
156 int32_t payload = PAYLOAD_NUM;
157 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
158 ASSERT_EQ(ret, true);
159 data.WriteInt32(payload);
160 data.WriteRemoteObject(callback);
161
162 OHOS::MessageOption option;
163 int status = sampleService->SendRequest(SAMPLE_SERVICE_CALLBACK, data, reply, option);
164 ASSERT_EQ(status, 0);
165 ASSERT_EQ(IPCObjectStubTest::payload, payload);
166 }
167
168 /**
169 * @tc.number: SUB_DriverSystem_ManagerService_0040
170 * @tc.name: open input device test
171 * @tc.size: Medium
172 * @tc.level: level 1
173 */
174 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest004, Function | MediumTest | Level1)
175 {
176 auto servmgr = IServiceManager::Get();
177 ASSERT_TRUE(servmgr != nullptr);
178
179 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
180 ASSERT_TRUE(sampleService != nullptr);
181
182 OHOS::MessageParcel data;
183 OHOS::MessageParcel reply;
184 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
185 ASSERT_EQ(ret, true);
186 data.WriteInt32(PAYLOAD_NUM);
187 data.WriteInt32(PAYLOAD_NUM);
188
189 OHOS::MessageOption option;
190 int status = sampleService->SendRequest(SAMPLE_SERVICE_SUM, data, reply, option);
191 ASSERT_EQ(status, 0);
192 int32_t result = reply.ReadInt32();
193 int32_t expRes = PAYLOAD_NUM + PAYLOAD_NUM;
194 ASSERT_EQ(result, expRes);
195 }
196
197 /**
198 * @tc.number: SUB_DriverSystem_ManagerService_0050
199 * @tc.name: open input device test
200 * @tc.size: Medium
201 * @tc.level: level 1
202 */
203 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest005, Function | MediumTest | Level1)
204 {
205 auto servmgr = IServiceManager::Get();
206 ASSERT_TRUE(servmgr != nullptr);
207
208 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
209 ASSERT_TRUE(sampleService != nullptr);
210
211 OHOS::MessageParcel data;
212 OHOS::MessageParcel reply;
213
214 constexpr int buffersize = 10;
215 uint8_t dataBuffer[buffersize];
216 for (int i = 0; i < buffersize; i++) {
217 dataBuffer[i] = i;
218 }
219 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
220 ASSERT_EQ(ret, true);
221 ret = data.WriteUnpadBuffer(dataBuffer, sizeof(dataBuffer));
222 ASSERT_TRUE(ret);
223
224 OHOS::MessageOption option;
225 int status = sampleService->SendRequest(SAMPLE_BUFFER_TRANS, data, reply, option);
226 ASSERT_EQ(status, 0);
227
228 const uint8_t *retBuffer = reply.ReadUnpadBuffer(buffersize);
229 ASSERT_TRUE(retBuffer != nullptr);
230
231 for (int i = 0; i < buffersize; i++) {
232 ASSERT_EQ(retBuffer[i], i);
233 }
234 }
235
236 /**
237 * @tc.number: SUB_DriverSystem_ManagerService_0060
238 * @tc.name: Test device manager Load/UnLoad device and driver dynamic register device
239 * @tc.size: Medium
240 * @tc.level: level 1
241 */
242 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest006, Function | MediumTest | Level1)
243 {
244 auto devmgr = IDeviceManager::Get();
245 ASSERT_TRUE(devmgr != nullptr);
246 devmgr->UnloadDevice(TEST_SERVICE_NAME);
247
248 auto servmgr = IServiceManager::Get();
249 ASSERT_TRUE(servmgr != nullptr);
250 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
251 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
252 ASSERT_TRUE(sampleService == nullptr);
253
254 int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
255 ASSERT_EQ(ret, HDF_SUCCESS);
256 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
257 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
258 ASSERT_TRUE(sampleService != nullptr);
259
260 OHOS::MessageParcel data;
261 OHOS::MessageParcel reply;
262 OHOS::MessageOption option;
263 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
264 ASSERT_EQ(ret, true);
265 const char *newServName = "sample_driver_service2";
266 ret = data.WriteCString(newServName);
267 ASSERT_TRUE(ret);
268
269 int status = sampleService->SendRequest(SAMPLE_REGISTER_DEVICE, data, reply, option);
270 ASSERT_EQ(status, HDF_SUCCESS);
271
272 auto sampleService2 = servmgr->GetService(newServName);
273 ASSERT_TRUE(sampleService != nullptr);
274
275 data.FlushBuffer();
276 reply.FlushBuffer();
277 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
278 ASSERT_EQ(ret, true);
279 data.WriteInt32(PAYLOAD_NUM);
280 data.WriteInt32(PAYLOAD_NUM);
281
282 status = sampleService2->SendRequest(SAMPLE_SERVICE_SUM, data, reply, option);
283 ASSERT_EQ(status, 0);
284 int32_t result = reply.ReadInt32();
285
286 int32_t expRes = PAYLOAD_NUM + PAYLOAD_NUM;
287 ASSERT_EQ(result, expRes);
288 sampleService2 = nullptr;
289
290 data.FlushBuffer();
291 reply.FlushBuffer();
292 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
293 ASSERT_EQ(ret, true);
294 data.WriteCString(newServName);
295
296 status = sampleService->SendRequest(SAMPLE_UNREGISTER_DEVICE, data, reply, option);
297 ASSERT_EQ(status, HDF_SUCCESS);
298
299 sampleService2 = servmgr->GetService(newServName);
300 ASSERT_TRUE(sampleService2 == nullptr);
301
302 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
303 ASSERT_EQ(ret, HDF_SUCCESS);
304 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
305 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
306 ASSERT_TRUE(sampleService == nullptr);
307 }
308
309 class ServStatListener : public OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub {
310 public:
311 using StatusCallback = std::function<void(const ServiceStatus &)>;
ServStatListener(StatusCallback callback)312 explicit ServStatListener(StatusCallback callback) : callback_(std::move(callback)) {}
313 ~ServStatListener() = default;
OnReceive(const ServiceStatus & status)314 void OnReceive(const ServiceStatus &status) override
315 {
316 callback_(status);
317 }
318
319 private:
320 StatusCallback callback_;
321 };
322
323 /*
324 * Test service start status listener
325 */
TestServiceListenerStop(const sptr<IDeviceManager> & devmgr,const sptr<IServiceManager> & servmgr)326 void HdfServiceMangerHdiTest::TestServiceListenerStop(const sptr<IDeviceManager>& devmgr,
327 const sptr<IServiceManager>& servmgr)
328 {
329 std::string servInfo;
330 uint16_t devClass;
331 uint16_t servStatus;
332 bool callbacked = false;
333 ::OHOS::sptr<IServStatListener> listener
334 = new ServStatListener(ServStatListener::StatusCallback([&](const ServiceStatus &status) {
335 HDF_LOGI("service status callback");
336 if (status.serviceName == std::string(TEST_SERVICE_NAME)) {
337 servInfo = status.info;
338 devClass = status.deviceClass;
339 servStatus = status.status;
340 callbacked = true;
341 }
342 }));
343
344 int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
345 ASSERT_EQ(status, HDF_SUCCESS);
346
347 int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
348 ASSERT_EQ(ret, HDF_SUCCESS);
349 constexpr int WAIT_COUNT = 300;
350 int count = WAIT_COUNT;
351 while (!callbacked && count > 0) {
352 OsalMSleep(1);
353 count--;
354 }
355 ASSERT_TRUE(callbacked);
356 ASSERT_EQ(devClass, DEVICE_CLASS_DEFAULT);
357 ASSERT_EQ(servInfo, std::string(TEST_SERVICE_NAME));
358 ASSERT_EQ(servStatus, OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
359
360 callbacked = false;
361 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
362 ASSERT_EQ(ret, HDF_SUCCESS);
363
364 count = WAIT_COUNT;
365 while (!callbacked && count > 0) {
366 OsalMSleep(1);
367 count--;
368 }
369 ASSERT_TRUE(callbacked);
370 ASSERT_EQ(devClass, DEVICE_CLASS_DEFAULT);
371 ASSERT_EQ(servInfo, std::string(TEST_SERVICE_NAME));
372 ASSERT_EQ(servStatus, OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP);
373
374 status = servmgr->UnregisterServiceStatusListener(listener);
375 ASSERT_EQ(status, HDF_SUCCESS);
376 }
377
378 /**
379 * @tc.number: SUB_DriverSystem_PnpManager_0010
380 * @tc.name: Test service status listener update service info
381 * @tc.size: Medium
382 * @tc.level: level 1
383 */
384 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_PnpManager_0010, Function | MediumTest | Level1)
385 {
386 auto devmgr = IDeviceManager::Get();
387 ASSERT_TRUE(devmgr != nullptr);
388 devmgr->UnloadDevice(TEST_SERVICE_NAME);
389
390 auto servmgr = IServiceManager::Get();
391 ASSERT_TRUE(servmgr != nullptr);
392 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
393 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
394 ASSERT_TRUE(sampleService == nullptr);
395
396 TestServiceListenerStop(devmgr, servmgr);
397 }
398
399 /*
400 * Test service status listener update service info
401 */
TestSampleService(sptr<IRemoteObject> & sampleService,const sptr<IDeviceManager> & devmgr,const sptr<IServiceManager> & servmgr)402 void HdfServiceMangerHdiTest::TestSampleService(sptr<IRemoteObject>& sampleService,
403 const sptr<IDeviceManager>& devmgr, const sptr<IServiceManager>& servmgr)
404 {
405 std::string servInfo;
406 uint16_t devClass;
407 uint16_t servStatus;
408 bool callbacked = false;
409 ::OHOS::sptr<IServStatListener> listener
410 = new ServStatListener(
411 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
412 if (status.serviceName == std::string(TEST_SERVICE_NAME) &&
413 status.status == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_CHANGE) {
414 HDF_LOGI("sample service status callback");
415 servInfo = status.info;
416 devClass = status.deviceClass;
417 servStatus = status.status;
418 callbacked = true;
419 }
420 }));
421
422 int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
423 ASSERT_EQ(status, HDF_SUCCESS);
424 constexpr int FIRST_WAIT = 20;
425 OsalMSleep(FIRST_WAIT); // skip callback on register
426 OHOS::MessageParcel data;
427 OHOS::MessageParcel reply;
428 OHOS::MessageOption option;
429 bool res = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
430 ASSERT_EQ(res, true);
431 std::string info = "foo";
432 data.WriteCString(info.data());
433 callbacked = false;
434 status = sampleService->SendRequest(SAMPLE_UPDATE_SERVIE, data, reply, option);
435 ASSERT_EQ(status, HDF_SUCCESS);
436 constexpr int WAIT_COUNT = 300;
437 int count = WAIT_COUNT;
438 while (!callbacked && count > 0) {
439 OsalMSleep(1);
440 count--;
441 }
442 ASSERT_TRUE(callbacked);
443 ASSERT_EQ(devClass, DEVICE_CLASS_DEFAULT);
444 ASSERT_EQ(servInfo, info);
445 int ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
446 ASSERT_EQ(ret, HDF_SUCCESS);
447
448 status = servmgr->UnregisterServiceStatusListener(listener);
449 ASSERT_EQ(status, HDF_SUCCESS);
450 }
451
452 /**
453 * @tc.number: SUB_DriverSystem_PnpManager_0050
454 * @tc.name: Test service loadDevice
455 * @tc.size: Medium
456 * @tc.level: level 1
457 */
458 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_PnpManager_0050, Function | MediumTest | Level1)
459 {
460 auto devmgr = IDeviceManager::Get();
461 ASSERT_TRUE(devmgr != nullptr);
462 devmgr->UnloadDevice(TEST_SERVICE_NAME);
463
464 auto servmgr = IServiceManager::Get();
465 ASSERT_TRUE(servmgr != nullptr);
466 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
467 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
468 ASSERT_TRUE(sampleService == nullptr);
469
470 int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
471 ASSERT_EQ(ret, HDF_SUCCESS);
472 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
473 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
474 ASSERT_TRUE(sampleService != nullptr);
475
476 TestSampleService(sampleService, devmgr, servmgr);
477 }
478 /**
479 * @tc.number: SUB_DriverSystem_PnpManager_0020
480 * @tc.name: Test service status listener unregister
481 * @tc.size: Medium
482 * @tc.level: level 1
483 */
484 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_PnpManager_0020, Function | MediumTest | Level1)
485 {
486 constexpr int SLEEP_TIME = 10;
487 auto devmgr = IDeviceManager::Get();
488 ASSERT_TRUE(devmgr != nullptr);
489 devmgr->UnloadDevice(TEST_SERVICE_NAME);
490
491 auto servmgr = IServiceManager::Get();
492 ASSERT_TRUE(servmgr != nullptr);
493 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
494 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
495 ASSERT_TRUE(sampleService == nullptr);
496
497 std::string servInfo;
498 uint16_t devClass;
499 uint16_t servStatus;
500 bool callbacked = false;
501 ::OHOS::sptr<IServStatListener> listener
502 = new ServStatListener(
__anonb4cf49990302(const ServiceStatus &status) 503 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
504 HDF_LOGI("service status callback");
505 if (status.serviceName == std::string(TEST_SERVICE_NAME) &&
506 status.status == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) {
507 servInfo = status.info;
508 devClass = status.deviceClass;
509 servStatus = status.status;
510 callbacked = true;
511 }
512 }));
513
514 int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
515 ASSERT_EQ(status, HDF_SUCCESS);
516
517 int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
518 ASSERT_EQ(ret, HDF_SUCCESS);
519
520 constexpr int WAIT_COUNT = 300;
521 int count = WAIT_COUNT;
522 while (!callbacked && count > 0) {
523 OsalMSleep(1);
524 count--;
525 }
526 ASSERT_TRUE(callbacked);
527 ASSERT_EQ(devClass, DEVICE_CLASS_DEFAULT);
528 ASSERT_EQ(servInfo, std::string(TEST_SERVICE_NAME));
529 ASSERT_EQ(servStatus, OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
530
531 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
532 ASSERT_TRUE(sampleService != nullptr);
533
534 status = servmgr->UnregisterServiceStatusListener(listener);
535 ASSERT_EQ(status, HDF_SUCCESS);
536
537 callbacked = false;
538 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
539 ASSERT_EQ(ret, HDF_SUCCESS);
540
541 OsalMSleep(SLEEP_TIME);
542 ASSERT_FALSE(callbacked);
543
544 ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
545 ASSERT_EQ(ret, HDF_SUCCESS);
546 }
547
548 /**
549 * @tc.number: SUB_DriverSystem_MemoryHdi_0010
550 * @tc.name: smq test normal read/write
551 * @tc.size: Medium
552 * @tc.level: level 1
553 */
554 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_MemoryHdi_0010, Function | MediumTest | Level1)
555 {
556 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
557 auto servmgr = IServiceManager::Get();
558 ASSERT_TRUE(servmgr != nullptr);
559
560 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
561 ASSERT_TRUE(sampleService != nullptr);
562
563 OHOS::MessageParcel data;
564 OHOS::MessageParcel reply;
565 OHOS::MessageOption option;
566 std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
567 std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::SYNCED_SMQ);
568 ASSERT_TRUE(smq->IsGood());
569 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
570 ASSERT_EQ(ret, true);
571 ret = smq->GetMeta()->Marshalling(data);
572 ASSERT_TRUE(ret);
573 data.WriteUint32(1);
574
575 int status = sampleService->SendRequest(SAMPLE_TRANS_SMQ, data, reply, option);
576 ASSERT_EQ(status, 0);
577
578 constexpr int SEND_TIMES = 20;
579 for (size_t i = 0; i < SEND_TIMES; i++) {
580 SampleSmqElement t = { 0 };
581 t.data32 = i;
582 t.data64 = i + 1;
583
584 HDF_LOGI("%{public}s:write smq message %{public}zu", __func__, i);
585 auto status = smq->Write(&t, 1, OHOS::MillisecToNanosec(SMQ_TEST_WAIT_TIME));
586 ASSERT_EQ(status, 0);
587 }
588 }
589
590 /**
591 * @tc.number: SUB_DriverSystem_MemoryHdi_0020
592 * @tc.name: smq test with overflow wait
593 * @tc.size: Medium
594 * @tc.level: level 1
595 */
596 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_MemoryHdi_0020, Function | MediumTest | Level1)
597 {
598 auto servmgr = IServiceManager::Get();
599 ASSERT_TRUE(servmgr != nullptr);
600
601 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
602 ASSERT_TRUE(sampleService != nullptr);
603
604 OHOS::MessageParcel data;
605 OHOS::MessageParcel reply;
606 OHOS::MessageOption option;
607 std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
608 std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::SYNCED_SMQ);
609 ASSERT_TRUE(smq->IsGood());
610 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
611 ASSERT_EQ(ret, true);
612 constexpr uint32_t ELEMENT_SIZE = 2;
613 ret = smq->GetMeta()->Marshalling(data);
614 ASSERT_TRUE(ret);
615
616 data.WriteUint32(ELEMENT_SIZE);
617 int status = sampleService->SendRequest(SAMPLE_TRANS_SMQ, data, reply, option);
618 ASSERT_EQ(status, 0);
619
620 constexpr int SEND_TIMES = 20;
621 for (int i = 0; i < SEND_TIMES; i++) {
622 SampleSmqElement t[ELEMENT_SIZE] = {};
623 t[0].data32 = i;
624 t[0].data64 = i + 1;
625 t[1].data32 = i + 1;
626 t[1].data64 = i + 1;
627 HDF_LOGI("%{public}s:write smq message %{public}d", __func__, i);
628 auto status = smq->Write(&t[0], ELEMENT_SIZE, OHOS::MillisecToNanosec(SMQ_TEST_WAIT_TIME));
629 ASSERT_EQ(status, 0);
630 }
631 }
632
633 /**
634 * @tc.number: SUB_DriverSystem_MemoryHdi_0030
635 * @tc.name: smq test UNSYNC_SMQ
636 * @tc.size: Medium
637 * @tc.level: level 1
638 */
639 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_MemoryHdi_0030, Function | MediumTest | Level1)
640 {
641 auto servmgr = IServiceManager::Get();
642 ASSERT_TRUE(servmgr != nullptr);
643
644 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
645 ASSERT_TRUE(sampleService != nullptr);
646
647 OHOS::MessageParcel data;
648 OHOS::MessageParcel reply;
649 OHOS::MessageOption option;
650
651 std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
652 std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::UNSYNC_SMQ);
653 ASSERT_TRUE(smq->IsGood());
654 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
655 ASSERT_EQ(ret, true);
656 constexpr uint32_t ELEMENT_SIZE = 2;
657 ret = smq->GetMeta()->Marshalling(data);
658 ASSERT_TRUE(ret);
659 data.WriteUint32(ELEMENT_SIZE);
660 auto status = sampleService->SendRequest(SAMPLE_TRANS_SMQ, data, reply, option);
661 ASSERT_EQ(status, 0);
662
663 SampleSmqElement t[ELEMENT_SIZE] = {};
664 status = smq->Write(&t[0], ELEMENT_SIZE);
665 EXPECT_NE(status, 0);
666 constexpr int SEND_TIMES = 20;
667 for (int i = 0; i < SEND_TIMES; i++) {
668 t[0].data32 = i;
669 t[0].data64 = i + 1;
670 t[1].data32 = i + 1;
671 t[1].data64 = i + 1;
672 HDF_LOGI("%{public}s:write smq message %{public}d", __func__, i);
673 status = smq->WriteNonBlocking(&t[0], ELEMENT_SIZE);
674 ASSERT_EQ(status, 0);
675 }
676 }
677
678 /**
679 * @tc.number: SUB_DriverSystem_ManagerService_0130
680 * @tc.name: Test service status listener get serviec callback on register
681 * @tc.size: Medium
682 * @tc.level: level 1
683 */
684 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest013, Function | MediumTest | Level1)
685 {
686 auto servmgr = IServiceManager::Get();
687 ASSERT_TRUE(servmgr != nullptr);
688
689 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
690 ASSERT_NE(sampleService, nullptr);
691
692 bool callbacked = false;
693 bool sampleServiceStarted = false;
694 uint16_t servStatus = 0;
695 ::OHOS::sptr<IServStatListener> listener
696 = new ServStatListener(
__anonb4cf49990402(const ServiceStatus &status) 697 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
698 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
699 callbacked = true;
700 if (status.serviceName == std::string(TEST_SERVICE_NAME)) {
701 sampleServiceStarted = true;
702 servStatus = status.status;
703 }
704 }));
705
706 int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
707 ASSERT_EQ(status, HDF_SUCCESS);
708 constexpr int WAIT_COUNT = 100;
709 int count = WAIT_COUNT;
710 while (!sampleServiceStarted && count > 0) {
711 OsalMSleep(1);
712 count--;
713 }
714 ASSERT_TRUE(callbacked);
715 ASSERT_TRUE(sampleServiceStarted);
716 ASSERT_EQ(servStatus, OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
717 status = servmgr->UnregisterServiceStatusListener(listener);
718 ASSERT_EQ(status, HDF_SUCCESS);
719 }
720
721 /**
722 * @tc.number: SUB_DriverSystem_InterfaceQuery_0010
723 * @tc.name: Test get service set by interfacedesc
724 * @tc.size: Medium
725 * @tc.level: level 1
726 */
727 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_InterfaceQuery_0010, Function | MediumTest | Level1)
728 {
729 auto servmgr = IServiceManager::Get();
730 ASSERT_TRUE(servmgr != nullptr);
731 std::vector<std::string> serviceNames;
732 int ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_N);
733 ASSERT_TRUE(ret == HDF_SUCCESS);
734 ASSERT_FALSE(serviceNames.empty());
735 ASSERT_TRUE(serviceNames.front().compare(TEST_SERVICE_NAME) == 0);
736 }
737
738
739 /**
740 * @tc.number: SUB_DriverSystem_InterfaceQuery_0020
741 * @tc.name: Test get service set by interfacedesc
742 * @tc.size: Medium
743 * @tc.level: level 1
744 */
745 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_InterfaceQuery_0020, Function | MediumTest | Level1)
746 {
747 auto servmgr = IServiceManager::Get();
748 ASSERT_TRUE(servmgr != nullptr);
749 std::vector<std::string> serviceNames;
750 int ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_INVALID);
751 ASSERT_TRUE(ret == HDF_SUCCESS);
752 ASSERT_TRUE(serviceNames.empty());
753 }
754
755 /**
756 * @tc.number: SUB_DriverSystem_InterfaceQuery_0030
757 * @tc.name: Test get service set by interfacedesc
758 * @tc.size: Medium
759 * @tc.level: level 1
760 */
761 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_InterfaceQuery_0030, Function | MediumTest | Level1)
762 {
763 auto servmgr = IServiceManager::Get();
764 ASSERT_TRUE(servmgr != nullptr);
765 std::vector<std::string> serviceNames;
766 int ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_VOID);
767 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM);
768 ASSERT_TRUE(serviceNames.empty());
769 }
770
771 /**
772 * @tc.number: SUB_DriverSystem_InterfaceQuery_0040
773 * @tc.name: Test get service set by interfacedesc
774 * @tc.size: Medium
775 * @tc.level: level 1
776 */
777 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_InterfaceQuery_0040, Function | MediumTest | Level1)
778 {
779 auto servmgr = IServiceManager::Get();
780 ASSERT_TRUE(servmgr != nullptr);
781 std::vector<std::string> serviceNames;
782 int ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_NULL);
783 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM);
784 ASSERT_TRUE(serviceNames.empty());
785 }
786
787 /**
788 * @tc.number: SUB_DriverSystem_InterfaceQuery_0050
789 * @tc.name: Test get service set by interfacedesc
790 * @tc.size: Medium
791 * @tc.level: level 1
792 */
793 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_InterfaceQuery_0050, Function | MediumTest | Level1)
794 {
795 auto devmgr = IDeviceManager::Get();
796 ASSERT_TRUE(devmgr != nullptr);
797 int ret = devmgr->LoadDevice(TEST1_SERVICE_NAME);
798 ASSERT_TRUE(ret == HDF_SUCCESS);
799 auto servmgr = IServiceManager::Get();
800 ASSERT_TRUE(servmgr != nullptr);
801 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
802 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
803 ASSERT_TRUE(sampleService != nullptr);
804 auto sample1Service = servmgr->GetService(TEST1_SERVICE_NAME);
805 ASSERT_TRUE(sample1Service != nullptr);
806
807 std::vector<std::string> serviceNames;
808 ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_N);
809 ASSERT_TRUE(ret == HDF_SUCCESS);
810 constexpr int sampleServiceCount = 2;
811 ASSERT_TRUE(serviceNames.size() == sampleServiceCount);
812 ASSERT_TRUE(serviceNames[0].compare(TEST_SERVICE_NAME) == 0);
813 ASSERT_TRUE(serviceNames[1].compare(TEST1_SERVICE_NAME) == 0);
814 ret = devmgr->UnloadDevice(TEST1_SERVICE_NAME);
815 ASSERT_EQ(ret, HDF_SUCCESS);
816 }