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
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 device 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_PnpManager_0010
372 * @tc.name: Test service status listener update service info
373 * @tc.size: Medium
374 * @tc.level: level 1
375 */
376 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_PnpManager_0010, 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_PnpManager_0050
446 * @tc.name: Test service loadDevice
447 * @tc.size: Medium
448 * @tc.level: level 1
449 */
450 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_PnpManager_0050, 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_PnpManager_0020
472 * @tc.name: Test service status listener unregister
473 * @tc.size: Medium
474 * @tc.level: level 1
475 */
476 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_PnpManager_0020, Function | MediumTest | Level1)
477 {
478 constexpr int SLEEP_TIME = 10;
479 auto devmgr = IDeviceManager::Get();
480 ASSERT_TRUE(devmgr != nullptr);
481 devmgr->UnloadDevice(TEST_SERVICE_NAME);
482
483 auto servmgr = IServiceManager::Get();
484 ASSERT_TRUE(servmgr != nullptr);
485 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
486 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
487 ASSERT_TRUE(sampleService == nullptr);
488
489 std::string servInfo;
490 uint16_t devClass;
491 uint16_t servStatus;
492 bool callbacked = false;
493 ::OHOS::sptr<IServStatListener> listener
494 = new ServStatListener(
__anone7f868bb0302(const ServiceStatus &status) 495 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
496 HDF_LOGI("service status callback");
497 if (status.serviceName == std::string(TEST_SERVICE_NAME) &&
498 status.status == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) {
499 servInfo = status.info;
500 devClass = status.deviceClass;
501 servStatus = status.status;
502 callbacked = true;
503 }
504 }));
505
506 int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
507 ASSERT_EQ(status, HDF_SUCCESS);
508
509 int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
510 ASSERT_EQ(ret, HDF_SUCCESS);
511
512 constexpr int WAIT_COUNT = 300;
513 int count = WAIT_COUNT;
514 while (!callbacked && count > 0) {
515 OsalMSleep(1);
516 count--;
517 }
518 ASSERT_TRUE(callbacked);
519 ASSERT_EQ(devClass, DEVICE_CLASS_DEFAULT);
520 ASSERT_EQ(servInfo, std::string(TEST_SERVICE_NAME));
521 ASSERT_EQ(servStatus, OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
522
523 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
524 ASSERT_TRUE(sampleService != nullptr);
525
526 status = servmgr->UnregisterServiceStatusListener(listener);
527 ASSERT_EQ(status, HDF_SUCCESS);
528
529 callbacked = false;
530 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
531 ASSERT_EQ(ret, HDF_SUCCESS);
532
533 OsalMSleep(SLEEP_TIME);
534 ASSERT_FALSE(callbacked);
535
536 ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
537 ASSERT_EQ(ret, HDF_SUCCESS);
538 }
539
540 /**
541 * @tc.number: SUB_DriverSystem_MemoryHdi_0010
542 * @tc.name: smq test normal read/write
543 * @tc.size: Medium
544 * @tc.level: level 1
545 */
546 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_MemoryHdi_0010, Function | MediumTest | Level1)
547 {
548 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
549 auto servmgr = IServiceManager::Get();
550 ASSERT_TRUE(servmgr != nullptr);
551
552 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
553 ASSERT_TRUE(sampleService != nullptr);
554
555 OHOS::MessageParcel data;
556 OHOS::MessageParcel reply;
557 OHOS::MessageOption option;
558 std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
559 std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::SYNCED_SMQ);
560 ASSERT_TRUE(smq->IsGood());
561 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
562 ASSERT_EQ(ret, true);
563 ret = smq->GetMeta()->Marshalling(data);
564 ASSERT_TRUE(ret);
565 data.WriteUint32(1);
566
567 int status = sampleService->SendRequest(SAMPLE_TRANS_SMQ, data, reply, option);
568 ASSERT_EQ(status, 0);
569
570 constexpr int SEND_TIMES = 20;
571 for (size_t i = 0; i < SEND_TIMES; i++) {
572 SampleSmqElement t = { 0 };
573 t.data32 = i;
574 t.data64 = i + 1;
575
576 HDF_LOGI("%{public}s:write smq message %{public}zu", __func__, i);
577 auto status = smq->Write(&t, 1, OHOS::MillisecToNanosec(SMQ_TEST_WAIT_TIME));
578 ASSERT_EQ(status, 0);
579 }
580 }
581
582 /**
583 * @tc.number: SUB_DriverSystem_MemoryHdi_0020
584 * @tc.name: smq test with overflow wait
585 * @tc.size: Medium
586 * @tc.level: level 1
587 */
588 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_MemoryHdi_0020, Function | MediumTest | Level1)
589 {
590 auto servmgr = IServiceManager::Get();
591 ASSERT_TRUE(servmgr != nullptr);
592
593 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
594 ASSERT_TRUE(sampleService != nullptr);
595
596 OHOS::MessageParcel data;
597 OHOS::MessageParcel reply;
598 OHOS::MessageOption option;
599 std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
600 std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::SYNCED_SMQ);
601 ASSERT_TRUE(smq->IsGood());
602 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
603 ASSERT_EQ(ret, true);
604 constexpr uint32_t ELEMENT_SIZE = 2;
605 ret = smq->GetMeta()->Marshalling(data);
606 ASSERT_TRUE(ret);
607
608 data.WriteUint32(ELEMENT_SIZE);
609 int status = sampleService->SendRequest(SAMPLE_TRANS_SMQ, data, reply, option);
610 ASSERT_EQ(status, 0);
611
612 constexpr int SEND_TIMES = 20;
613 for (int i = 0; i < SEND_TIMES; i++) {
614 SampleSmqElement t[ELEMENT_SIZE] = {};
615 t[0].data32 = i;
616 t[0].data64 = i + 1;
617 t[1].data32 = i + 1;
618 t[1].data64 = i + 1;
619 HDF_LOGI("%{public}s:write smq message %{public}d", __func__, i);
620 auto status = smq->Write(&t[0], ELEMENT_SIZE, OHOS::MillisecToNanosec(SMQ_TEST_WAIT_TIME));
621 ASSERT_EQ(status, 0);
622 }
623 }
624
625 /**
626 * @tc.number: SUB_DriverSystem_MemoryHdi_0030
627 * @tc.name: smq test UNSYNC_SMQ
628 * @tc.size: Medium
629 * @tc.level: level 1
630 */
631 HWTEST_F(HdfServiceMangerHdiTest, SUB_DriverSystem_MemoryHdi_0030, Function | MediumTest | Level1)
632 {
633 auto servmgr = IServiceManager::Get();
634 ASSERT_TRUE(servmgr != nullptr);
635
636 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
637 ASSERT_TRUE(sampleService != nullptr);
638
639 OHOS::MessageParcel data;
640 OHOS::MessageParcel reply;
641 OHOS::MessageOption option;
642
643 std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
644 std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::UNSYNC_SMQ);
645 ASSERT_TRUE(smq->IsGood());
646 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
647 ASSERT_EQ(ret, true);
648 constexpr uint32_t ELEMENT_SIZE = 2;
649 ret = smq->GetMeta()->Marshalling(data);
650 ASSERT_TRUE(ret);
651 data.WriteUint32(ELEMENT_SIZE);
652 auto status = sampleService->SendRequest(SAMPLE_TRANS_SMQ, data, reply, option);
653 ASSERT_EQ(status, 0);
654
655 SampleSmqElement t[ELEMENT_SIZE] = {};
656 status = smq->Write(&t[0], ELEMENT_SIZE);
657 EXPECT_NE(status, 0);
658 constexpr int SEND_TIMES = 20;
659 for (int i = 0; i < SEND_TIMES; i++) {
660 t[0].data32 = i;
661 t[0].data64 = i + 1;
662 t[1].data32 = i + 1;
663 t[1].data64 = i + 1;
664 HDF_LOGI("%{public}s:write smq message %{public}d", __func__, i);
665 status = smq->WriteNonBlocking(&t[0], ELEMENT_SIZE);
666 ASSERT_EQ(status, 0);
667 }
668 }
669
670 /**
671 * @tc.number: SUB_DriverSystem_ManagerService_0130
672 * @tc.name: Test service status listener get serviec callback on register
673 * @tc.size: Medium
674 * @tc.level: level 1
675 */
676 HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest013, Function | MediumTest | Level1)
677 {
678 auto servmgr = IServiceManager::Get();
679 ASSERT_TRUE(servmgr != nullptr);
680
681 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
682 ASSERT_NE(sampleService, nullptr);
683
684 bool callbacked = false;
685 bool sampleServiceStarted = false;
686 uint16_t servStatus = 0;
687 ::OHOS::sptr<IServStatListener> listener
688 = new ServStatListener(
__anone7f868bb0402(const ServiceStatus &status) 689 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
690 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
691 callbacked = true;
692 if (status.serviceName == std::string(TEST_SERVICE_NAME)) {
693 sampleServiceStarted = true;
694 servStatus = status.status;
695 }
696 }));
697
698 int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
699 ASSERT_EQ(status, HDF_SUCCESS);
700 constexpr int WAIT_COUNT = 100;
701 int count = WAIT_COUNT;
702 while (!sampleServiceStarted && count > 0) {
703 OsalMSleep(1);
704 count--;
705 }
706 ASSERT_TRUE(callbacked);
707 ASSERT_TRUE(sampleServiceStarted);
708 ASSERT_EQ(servStatus, OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
709 status = servmgr->UnregisterServiceStatusListener(listener);
710 ASSERT_EQ(status, HDF_SUCCESS);
711 }