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