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