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