1 /*
2 * Copyright (c) 2021-2024 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 <base/hdi_smq.h>
17 #include <functional>
18 #include <gtest/gtest.h>
19 #include <hdf_io_service_if.h>
20 #include <hdf_log.h>
21 #include <hdf_service_status_inner.h>
22 #include <idevmgr_hdi.h>
23 #include <iostream>
24 #include <ipc_object_stub.h>
25 #include <iservice_registry.h>
26 #include <iservmgr_hdi.h>
27 #include <iservstat_listener_hdi.h>
28 #include <osal_time.h>
29 #include <string>
30
31 #include "sample_hdi.h"
32
33 #define HDF_LOG_TAG service_manager_test_cpp
34 namespace OHOS {
35 using namespace testing::ext;
36 using OHOS::IRemoteObject;
37 using OHOS::sptr;
38 using OHOS::HDI::Base::SharedMemQueue;
39 using OHOS::HDI::Base::SharedMemQueueMeta;
40 using OHOS::HDI::Base::SmqType;
41 using OHOS::HDI::DeviceManager::V1_0::IDeviceManager;
42 using OHOS::HDI::ServiceManager::V1_0::IServiceManager;
43 using OHOS::HDI::ServiceManager::V1_0::IServStatListener;
44 using OHOS::HDI::ServiceManager::V1_0::ServiceStatus;
45 using OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub;
46 using OHOS::HDI::DeviceManager::V1_0::HdiDevHostInfo;
47 using OHOS::HDI::ServiceManager::V1_0::HdiServiceInfo;
48 static constexpr const char *TEST_SERVICE_NAME = "sample_driver_service";
49 static constexpr const char *TEST1_SERVICE_NAME = "sample1_driver_service";
50 static constexpr const char16_t *TEST_SERVICE_INTERFACE_DESC = u"hdf.test.sampele_service";
51 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_N = "hdf.test.sampele_service";
52 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_INVALID = "___";
53 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_VOID = "";
54 static constexpr const char *TEST_SERVICE_INTERFACE_DESC_NULL = nullptr;
55 static constexpr int PAYLOAD_NUM = 1234;
56 static constexpr int SMQ_TEST_QUEUE_SIZE = 10;
57 static constexpr int SMQ_TEST_WAIT_TIME = 100;
58 static constexpr int WAIT_LOAD_UNLOAD_TIME = 300;
59 static constexpr int DEVICE_SERVICE_MANAGER_SA_ID = 5100;
60 static constexpr int INVALID_CODE = 100;
61 static constexpr int ERROR_CODE_WITH_INVALID_CODE = 305;
62
63 class HdfServiceMangerHdiTest : public testing::Test {
64 public:
SetUpTestCase()65 static void SetUpTestCase()
66 {
67 (void)TEST_SERVICE_NAME;
68 (void)TEST1_SERVICE_NAME;
69 (void)PAYLOAD_NUM;
70 (void)WAIT_LOAD_UNLOAD_TIME;
71 (void)TEST_SERVICE_INTERFACE_DESC;
72 (void)TEST_SERVICE_INTERFACE_DESC_N;
73 (void)SMQ_TEST_QUEUE_SIZE;
74 (void)SMQ_TEST_WAIT_TIME;
75
76 #ifdef SAMPLE_SHIELD
77 auto devmgr = IDeviceManager::Get();
78 if (devmgr != nullptr) {
79 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
80 devmgr->LoadDevice(TEST_SERVICE_NAME);
81 }
82 #endif
83 }
TearDownTestCase()84 static void TearDownTestCase()
85 {
86 #ifdef SAMPLE_SHIELD
87 auto devmgr = IDeviceManager::Get();
88 if (devmgr != nullptr) {
89 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
90 devmgr->UnloadDevice(TEST_SERVICE_NAME);
91 }
92 #endif
93 }
94
95 void TestServiceListenerStop(const sptr<IDeviceManager>& devmgr, const sptr<IServiceManager>& servmgr);
96 void TestSampleService(sptr<IRemoteObject>& sampleService, const sptr<IDeviceManager>& devmgr,
97 const sptr<IServiceManager>& servmgr);
SetUp()98 void SetUp() {};
TearDown()99 void TearDown() {};
100 };
101
102 class IPCObjectStubTest : public OHOS::IPCObjectStub {
103 public:
IPCObjectStubTest()104 explicit IPCObjectStubTest() : OHOS::IPCObjectStub(u"") {};
105 virtual ~IPCObjectStubTest() = default;
106 int OnRemoteRequest(
107 uint32_t code, OHOS::MessageParcel &data, OHOS::MessageParcel &reply, OHOS::MessageOption &option) override
108 {
109 HDF_LOGI("IPCObjectStubTest::OnRemoteRequest called, code = %{public}d", code);
110 payload = data.ReadInt32();
111
112 return HDF_SUCCESS;
113 }
114
115 static int32_t payload;
116 };
117
118 int32_t IPCObjectStubTest::payload = 0;
119
120 /**
121 * @tc.number: SUB_Driver_Manager_HdiCC_0100
122 * @tc.name: ServMgrTest001
123 * @tc.size: Medium
124 * @tc.level: level 1
125 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0100, Function | MediumTest | Level1)126 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0100, Function | MediumTest | Level1)
127 {
128 auto servmgr = IServiceManager::Get();
129 ASSERT_TRUE(servmgr != nullptr);
130 }
131
132 #ifdef SAMPLE_SHIELD
133 /**
134 * @tc.number: SUB_Driver_Manager_HdiCC_0200
135 * @tc.name: ServMgrTest002
136 * @tc.size: Medium
137 * @tc.level: level 1
138 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0200, Function | MediumTest | Level1)139 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0200, Function | MediumTest | Level1)
140 {
141 auto servmgr = IServiceManager::Get();
142 ASSERT_TRUE(servmgr != nullptr);
143
144 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
145
146 ASSERT_TRUE(sampleService != nullptr);
147
148 OHOS::MessageParcel data;
149 OHOS::MessageParcel reply;
150 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
151 ASSERT_EQ(ret, true);
152 data.WriteCString("sample_service test call");
153
154 OHOS::MessageOption option;
155 int status = sampleService->SendRequest(SAMPLE_SERVICE_PING, data, reply, option);
156 ASSERT_EQ(status, 0);
157 }
158
159 /**
160 * @tc.number: SUB_Driver_Manager_HdiCC_0300
161 * @tc.name: ServMgrTest003
162 * @tc.size: Medium
163 * @tc.level: level 1
164 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0300, Function | MediumTest | Level1)165 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0300, Function | MediumTest | 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 sptr<IRemoteObject> callback = new IPCObjectStubTest();
174 OHOS::MessageParcel data;
175 OHOS::MessageParcel reply;
176 int32_t payload = PAYLOAD_NUM;
177 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
178 ASSERT_EQ(ret, true);
179 data.WriteInt32(payload);
180 data.WriteRemoteObject(callback);
181
182 OHOS::MessageOption option;
183 int status = sampleService->SendRequest(SAMPLE_SERVICE_CALLBACK, data, reply, option);
184 ASSERT_EQ(status, 0);
185 ASSERT_EQ(IPCObjectStubTest::payload, payload);
186 }
187
188 /**
189 * @tc.number: SUB_Driver_Manager_HdiCC_0400
190 * @tc.name: ServMgrTest004
191 * @tc.size: Medium
192 * @tc.level: level 1
193 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0400, Function | MediumTest | Level1)194 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0400, Function | MediumTest | Level1)
195 {
196 auto servmgr = IServiceManager::Get();
197 ASSERT_TRUE(servmgr != nullptr);
198
199 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
200 ASSERT_TRUE(sampleService != nullptr);
201
202 OHOS::MessageParcel data;
203 OHOS::MessageParcel reply;
204 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
205 ASSERT_EQ(ret, true);
206 data.WriteInt32(PAYLOAD_NUM);
207 data.WriteInt32(PAYLOAD_NUM);
208
209 OHOS::MessageOption option;
210 int status = sampleService->SendRequest(SAMPLE_SERVICE_SUM, data, reply, option);
211 ASSERT_EQ(status, 0);
212 int32_t result = reply.ReadInt32();
213 int32_t expRes = PAYLOAD_NUM + PAYLOAD_NUM;
214 ASSERT_EQ(result, expRes);
215 }
216
217 /**
218 * @tc.number: SUB_Driver_Manager_HdiCC_0500
219 * @tc.name: ServMgrTest006
220 * @tc.size: Medium
221 * @tc.level: level 1
222 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0500, Function | MediumTest | Level1)223 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0500, Function | MediumTest | Level1)
224 {
225 auto servmgr = IServiceManager::Get();
226 ASSERT_TRUE(servmgr != nullptr);
227
228 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
229 ASSERT_TRUE(sampleService != nullptr);
230
231 OHOS::MessageParcel data;
232 OHOS::MessageParcel reply;
233
234 constexpr int buffersize = 10;
235 uint8_t dataBuffer[buffersize];
236 for (int i = 0; i < buffersize; i++) {
237 dataBuffer[i] = i;
238 }
239 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
240 ASSERT_EQ(ret, true);
241 ret = data.WriteUnpadBuffer(dataBuffer, sizeof(dataBuffer));
242 ASSERT_TRUE(ret);
243
244 OHOS::MessageOption option;
245 int status = sampleService->SendRequest(SAMPLE_BUFFER_TRANS, data, reply, option);
246 ASSERT_EQ(status, 0);
247
248 const uint8_t *retBuffer = reply.ReadUnpadBuffer(buffersize);
249 ASSERT_TRUE(retBuffer != nullptr);
250
251 for (int i = 0; i < buffersize; i++) {
252 ASSERT_EQ(retBuffer[i], i);
253 }
254 }
255
256 /**
257 * @tc.number: SUB_Driver_Manager_HdiCC_0600
258 * @tc.name: Test device manager Load/UnLoad device and driver dynamic register device
259 * @tc.size: Medium
260 * @tc.level: level 1
261 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0600, Function | MediumTest | Level1)262 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0600, Function | MediumTest | Level1)
263 {
264 auto devmgr = IDeviceManager::Get();
265 ASSERT_TRUE(devmgr != nullptr);
266 devmgr->UnloadDevice(TEST_SERVICE_NAME);
267
268 auto servmgr = IServiceManager::Get();
269 ASSERT_TRUE(servmgr != nullptr);
270 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
271 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
272 ASSERT_TRUE(sampleService == nullptr);
273
274 int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
275 ASSERT_EQ(ret, HDF_SUCCESS);
276 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
277 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
278 ASSERT_TRUE(sampleService != nullptr);
279
280 OHOS::MessageParcel data;
281 OHOS::MessageParcel reply;
282 OHOS::MessageOption option;
283 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
284 ASSERT_EQ(ret, true);
285 const char *newServName = "sample_driver_service2";
286 ret = data.WriteCString(newServName);
287 ASSERT_TRUE(ret);
288
289 int status = sampleService->SendRequest(SAMPLE_REGISTER_DEVICE, data, reply, option);
290 ASSERT_EQ(status, HDF_SUCCESS);
291
292 auto sampleService2 = servmgr->GetService(newServName);
293 ASSERT_TRUE(sampleService != nullptr);
294
295 data.FlushBuffer();
296 reply.FlushBuffer();
297 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
298 ASSERT_EQ(ret, true);
299 data.WriteInt32(PAYLOAD_NUM);
300 data.WriteInt32(PAYLOAD_NUM);
301
302 status = sampleService2->SendRequest(SAMPLE_SERVICE_SUM, data, reply, option);
303 ASSERT_EQ(status, 0);
304 int32_t result = reply.ReadInt32();
305
306 int32_t expRes = PAYLOAD_NUM + PAYLOAD_NUM;
307 ASSERT_EQ(result, expRes);
308 sampleService2 = nullptr;
309
310 data.FlushBuffer();
311 reply.FlushBuffer();
312 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
313 ASSERT_EQ(ret, true);
314 data.WriteCString(newServName);
315
316 status = sampleService->SendRequest(SAMPLE_UNREGISTER_DEVICE, data, reply, option);
317 ASSERT_EQ(status, HDF_SUCCESS);
318
319 sampleService2 = servmgr->GetService(newServName);
320 ASSERT_TRUE(sampleService2 == nullptr);
321
322 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
323 ASSERT_EQ(ret, HDF_SUCCESS);
324 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
325 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
326 ASSERT_TRUE(sampleService == nullptr);
327 }
328 #endif
329
330 class ServStatListener : public OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub {
331 public:
332 using StatusCallback = std::function<void(const ServiceStatus &)>;
ServStatListener(StatusCallback callback)333 explicit ServStatListener(StatusCallback callback) : callback_(std::move(callback)) {}
334 ~ServStatListener() = default;
335 void OnReceive(const ServiceStatus &status) override
336 {
337 callback_(status);
338 }
339
340 private:
341 StatusCallback callback_;
342 };
343
344 #ifdef SAMPLE_SHIELD
345 /*
346 * Test service start status listener
347 */
TestServiceListenerStop(const sptr<IDeviceManager>& devmgr, const sptr<IServiceManager>& servmgr)348 void HdfServiceMangerHdiTest::TestServiceListenerStop(const sptr<IDeviceManager>& devmgr,
349 const sptr<IServiceManager>& servmgr)
350 {
351 std::string servInfo;
352 uint16_t devClass;
353 uint16_t servStatus;
354 bool callbacked = false;
355 ::OHOS::sptr<IServStatListener> listener
356 = new ServStatListener(ServStatListener::StatusCallback([&](const ServiceStatus &status) {
357 HDF_LOGI("service status callback");
358 if (status.serviceName == std::string(TEST_SERVICE_NAME)) {
359 servInfo = status.info;
360 devClass = status.deviceClass;
361 servStatus = status.status;
362 callbacked = true;
363 }
364 }));
365
366 int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
367 ASSERT_EQ(status, HDF_SUCCESS);
368
369 int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
370 ASSERT_EQ(ret, HDF_SUCCESS);
371 constexpr int WAIT_COUNT = 300;
372 int count = WAIT_COUNT;
373 while (!callbacked && count > 0) {
374 OsalMSleep(1);
375 count--;
376 }
377 ASSERT_TRUE(callbacked);
378 ASSERT_EQ(devClass, DEVICE_CLASS_DEFAULT);
379 ASSERT_EQ(servInfo, std::string(TEST_SERVICE_NAME));
380 ASSERT_EQ(servStatus, OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
381
382 callbacked = false;
383 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
384 ASSERT_EQ(ret, HDF_SUCCESS);
385
386 count = WAIT_COUNT;
387 while (!callbacked && count > 0) {
388 OsalMSleep(1);
389 count--;
390 }
391 ASSERT_TRUE(callbacked);
392 ASSERT_EQ(devClass, DEVICE_CLASS_DEFAULT);
393 ASSERT_EQ(servInfo, std::string(TEST_SERVICE_NAME));
394 ASSERT_EQ(servStatus, OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP);
395
396 status = servmgr->UnregisterServiceStatusListener(listener);
397 ASSERT_EQ(status, HDF_SUCCESS);
398 }
399
400 /**
401 * @tc.number: SUB_Driver_Manager_Pnp_0100
402 * @tc.name: Test service status listener update service info
403 * @tc.size: Medium
404 * @tc.level: level 1
405 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_Pnp_0100, Function | MediumTest | Level1)406 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_Pnp_0100, Function | MediumTest | Level1)
407 {
408 auto devmgr = IDeviceManager::Get();
409 ASSERT_TRUE(devmgr != nullptr);
410 devmgr->UnloadDevice(TEST_SERVICE_NAME);
411
412 auto servmgr = IServiceManager::Get();
413 ASSERT_TRUE(servmgr != nullptr);
414 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
415 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
416 ASSERT_TRUE(sampleService == nullptr);
417
418 TestServiceListenerStop(devmgr, servmgr);
419 }
420
421 /*
422 * Test service status listener update service info
423 */
TestSampleService(sptr<IRemoteObject>& sampleService, const sptr<IDeviceManager>& devmgr, const sptr<IServiceManager>& servmgr)424 void HdfServiceMangerHdiTest::TestSampleService(sptr<IRemoteObject>& sampleService,
425 const sptr<IDeviceManager>& devmgr, const sptr<IServiceManager>& servmgr)
426 {
427 std::string servInfo;
428 uint16_t devClass;
429 uint16_t servStatus;
430 bool callbacked = false;
431 ::OHOS::sptr<IServStatListener> listener
432 = new ServStatListener(
433 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
434 if (status.serviceName == std::string(TEST_SERVICE_NAME) &&
435 status.status == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_CHANGE) {
436 HDF_LOGI("sample service status callback");
437 servInfo = status.info;
438 devClass = status.deviceClass;
439 servStatus = status.status;
440 callbacked = true;
441 }
442 }));
443
444 int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
445 ASSERT_EQ(status, HDF_SUCCESS);
446 constexpr int FIRST_WAIT = 20;
447 OsalMSleep(FIRST_WAIT); // skip callback on register
448 OHOS::MessageParcel data;
449 OHOS::MessageParcel reply;
450 OHOS::MessageOption option;
451 bool res = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
452 ASSERT_EQ(res, true);
453 std::string info = "foo";
454 data.WriteCString(info.data());
455 callbacked = false;
456 status = sampleService->SendRequest(SAMPLE_UPDATE_SERVIE, data, reply, option);
457 ASSERT_EQ(status, HDF_SUCCESS);
458 constexpr int WAIT_COUNT = 300;
459 int count = WAIT_COUNT;
460 while (!callbacked && count > 0) {
461 OsalMSleep(1);
462 count--;
463 }
464 ASSERT_TRUE(callbacked);
465 ASSERT_EQ(devClass, DEVICE_CLASS_DEFAULT);
466 ASSERT_EQ(servInfo, info);
467 int ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
468 ASSERT_EQ(ret, HDF_SUCCESS);
469
470 status = servmgr->UnregisterServiceStatusListener(listener);
471 ASSERT_EQ(status, HDF_SUCCESS);
472 }
473
474 /**
475 * @tc.number: SUB_Driver_Manager_Pnp_0500
476 * @tc.name: Test service loadDevice
477 * @tc.size: Medium
478 * @tc.level: level 1
479 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_Pnp_0500, Function | MediumTest | Level1)480 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_Pnp_0500, Function | MediumTest | Level1)
481 {
482 auto devmgr = IDeviceManager::Get();
483 ASSERT_TRUE(devmgr != nullptr);
484 devmgr->UnloadDevice(TEST_SERVICE_NAME);
485
486 auto servmgr = IServiceManager::Get();
487 ASSERT_TRUE(servmgr != nullptr);
488 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
489 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
490 ASSERT_TRUE(sampleService == nullptr);
491
492 int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
493 ASSERT_EQ(ret, HDF_SUCCESS);
494 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
495 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
496 ASSERT_TRUE(sampleService != nullptr);
497
498 TestSampleService(sampleService, devmgr, servmgr);
499 }
500 /**
501 * @tc.number: SUB_Driver_Manager_Pnp_0200
502 * @tc.name: Test service status listener unregister
503 * @tc.size: Medium
504 * @tc.level: level 1
505 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_Pnp_0200, Function | MediumTest | Level1)506 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_Pnp_0200, Function | MediumTest | Level1)
507 {
508 constexpr int SLEEP_TIME = 10;
509 auto devmgr = IDeviceManager::Get();
510 ASSERT_TRUE(devmgr != nullptr);
511 devmgr->UnloadDevice(TEST_SERVICE_NAME);
512
513 auto servmgr = IServiceManager::Get();
514 ASSERT_TRUE(servmgr != nullptr);
515 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
516 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
517 ASSERT_TRUE(sampleService == nullptr);
518
519 std::string servInfo;
520 uint16_t devClass;
521 uint16_t servStatus;
522 bool callbacked = false;
523 ::OHOS::sptr<IServStatListener> listener
524 = new ServStatListener(
525 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
526 HDF_LOGI("service status callback");
527 if (status.serviceName == std::string(TEST_SERVICE_NAME) &&
528 status.status == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) {
529 servInfo = status.info;
530 devClass = status.deviceClass;
531 servStatus = status.status;
532 callbacked = true;
533 }
534 }));
535
536 int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
537 ASSERT_EQ(status, HDF_SUCCESS);
538
539 int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
540 ASSERT_EQ(ret, HDF_SUCCESS);
541
542 constexpr int WAIT_COUNT = 300;
543 int count = WAIT_COUNT;
544 while (!callbacked && count > 0) {
545 OsalMSleep(1);
546 count--;
547 }
548 ASSERT_TRUE(callbacked);
549 ASSERT_EQ(devClass, DEVICE_CLASS_DEFAULT);
550 ASSERT_EQ(servInfo, std::string(TEST_SERVICE_NAME));
551 ASSERT_EQ(servStatus, OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
552
553 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
554 ASSERT_TRUE(sampleService != nullptr);
555
556 status = servmgr->UnregisterServiceStatusListener(listener);
557 ASSERT_EQ(status, HDF_SUCCESS);
558
559 callbacked = false;
560 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
561 ASSERT_EQ(ret, HDF_SUCCESS);
562
563 OsalMSleep(SLEEP_TIME);
564 ASSERT_FALSE(callbacked);
565
566 ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
567 ASSERT_EQ(ret, HDF_SUCCESS);
568 }
569
570 /**
571 * @tc.number: SUB_Driver_Manager_Memory_0100
572 * @tc.name: smq test normal read/write
573 * @tc.size: Medium
574 * @tc.level: level 1
575 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_Memory_0100, Function | MediumTest | Level1)576 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_Memory_0100, Function | MediumTest | Level1)
577 {
578 HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__);
579 auto servmgr = IServiceManager::Get();
580 ASSERT_TRUE(servmgr != nullptr);
581
582 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
583 ASSERT_TRUE(sampleService != nullptr);
584
585 OHOS::MessageParcel data;
586 OHOS::MessageParcel reply;
587 OHOS::MessageOption option;
588 std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
589 std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::SYNCED_SMQ);
590 ASSERT_TRUE(smq->IsGood());
591 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
592 ASSERT_EQ(ret, true);
593 ret = smq->GetMeta()->Marshalling(data);
594 ASSERT_TRUE(ret);
595 data.WriteUint32(1);
596
597 int status = sampleService->SendRequest(SAMPLE_TRANS_SMQ, data, reply, option);
598 ASSERT_EQ(status, 0);
599
600 constexpr int SEND_TIMES = 20;
601 for (size_t i = 0; i < SEND_TIMES; i++) {
602 SampleSmqElement t = {0};
603 t.data32 = i;
604 t.data64 = i + 1;
605
606 HDF_LOGI("%{public}s:write smq message %{public}zu", __func__, i);
607 auto status = smq->Write(&t, 1, OHOS::MillisecToNanosec(SMQ_TEST_WAIT_TIME));
608 ASSERT_EQ(status, 0);
609 }
610 }
611
612 /**
613 * @tc.number: SUB_Driver_Manager_Memory_0200
614 * @tc.name: smq test with overflow wait
615 * @tc.size: Medium
616 * @tc.level: level 1
617 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_Memory_0200, Function | MediumTest | Level1)618 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_Memory_0200, Function | MediumTest | Level1)
619 {
620 auto servmgr = IServiceManager::Get();
621 ASSERT_TRUE(servmgr != nullptr);
622
623 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
624 ASSERT_TRUE(sampleService != nullptr);
625
626 OHOS::MessageParcel data;
627 OHOS::MessageParcel reply;
628 OHOS::MessageOption option;
629 std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
630 std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::SYNCED_SMQ);
631 ASSERT_TRUE(smq->IsGood());
632 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
633 ASSERT_EQ(ret, true);
634 constexpr uint32_t ELEMENT_SIZE = 2;
635 ret = smq->GetMeta()->Marshalling(data);
636 ASSERT_TRUE(ret);
637
638 data.WriteUint32(ELEMENT_SIZE);
639 int status = sampleService->SendRequest(SAMPLE_TRANS_SMQ, data, reply, option);
640 ASSERT_EQ(status, 0);
641
642 constexpr int SEND_TIMES = 20;
643 for (int i = 0; i < SEND_TIMES; i++) {
644 SampleSmqElement t[ELEMENT_SIZE] = {};
645 t[0].data32 = i;
646 t[0].data64 = i + 1;
647 t[1].data32 = i + 1;
648 t[1].data64 = i + 1;
649 HDF_LOGI("%{public}s:write smq message %{public}d", __func__, i);
650 auto status = smq->Write(&t[0], ELEMENT_SIZE, OHOS::MillisecToNanosec(SMQ_TEST_WAIT_TIME));
651 ASSERT_EQ(status, 0);
652 }
653 }
654
655 /**
656 * @tc.number: SUB_Driver_Manager_Memory_0300
657 * @tc.name: smq test UNSYNC_SMQ
658 * @tc.size: Medium
659 * @tc.level: level 1
660 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_Memory_0300, Function | MediumTest | Level1)661 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_Memory_0300, Function | MediumTest | Level1)
662 {
663 auto servmgr = IServiceManager::Get();
664 ASSERT_TRUE(servmgr != nullptr);
665
666 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
667 ASSERT_TRUE(sampleService != nullptr);
668
669 OHOS::MessageParcel data;
670 OHOS::MessageParcel reply;
671 OHOS::MessageOption option;
672
673 std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
674 std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::UNSYNC_SMQ);
675 ASSERT_TRUE(smq->IsGood());
676 bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
677 ASSERT_EQ(ret, true);
678 constexpr uint32_t ELEMENT_SIZE = 2;
679 ret = smq->GetMeta()->Marshalling(data);
680 ASSERT_TRUE(ret);
681 data.WriteUint32(ELEMENT_SIZE);
682 auto status = sampleService->SendRequest(SAMPLE_TRANS_SMQ, data, reply, option);
683 ASSERT_EQ(status, 0);
684
685 SampleSmqElement t[ELEMENT_SIZE] = {};
686 status = smq->Write(&t[0], ELEMENT_SIZE);
687 EXPECT_NE(status, 0);
688 constexpr int SEND_TIMES = 20;
689 for (int i = 0; i < SEND_TIMES; i++) {
690 t[0].data32 = i;
691 t[0].data64 = i + 1;
692 t[1].data32 = i + 1;
693 t[1].data64 = i + 1;
694 HDF_LOGI("%{public}s:write smq message %{public}d", __func__, i);
695 status = smq->WriteNonBlocking(&t[0], ELEMENT_SIZE);
696 ASSERT_EQ(status, 0);
697 }
698 }
699
700 /**
701 * @tc.number: SUB_Driver_Manager_HdiCC_0700
702 * @tc.name: Test service status listener get serviec callback on register
703 * @tc.size: Medium
704 * @tc.level: level 1
705 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0700, Function | MediumTest | Level1)706 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0700, Function | MediumTest | Level1)
707 {
708 auto servmgr = IServiceManager::Get();
709 ASSERT_TRUE(servmgr != nullptr);
710
711 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
712 ASSERT_NE(sampleService, nullptr);
713
714 bool callbacked = false;
715 bool sampleServiceStarted = false;
716 uint16_t servStatus = 0;
717 ::OHOS::sptr<IServStatListener> listener
718 = new ServStatListener(
719 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
720 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
721 callbacked = true;
722 if (status.serviceName == std::string(TEST_SERVICE_NAME)) {
723 sampleServiceStarted = true;
724 servStatus = status.status;
725 }
726 }));
727
728 int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
729 ASSERT_EQ(status, HDF_SUCCESS);
730 constexpr int WAIT_COUNT = 100;
731 int count = WAIT_COUNT;
732 while (!sampleServiceStarted && count > 0) {
733 OsalMSleep(1);
734 count--;
735 }
736 ASSERT_TRUE(callbacked);
737 ASSERT_TRUE(sampleServiceStarted);
738 ASSERT_EQ(servStatus, OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START);
739 status = servmgr->UnregisterServiceStatusListener(listener);
740 ASSERT_EQ(status, HDF_SUCCESS);
741 }
742
743 /**
744 * @tc.number: SUB_Driver_Manager_InterfaceQuery_0100
745 * @tc.name: Test get service set by interfacedesc
746 * @tc.size: Medium
747 * @tc.level: level 1
748 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_InterfaceQuery_0100, Function | MediumTest | Level1)749 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_InterfaceQuery_0100, Function | MediumTest | Level1)
750 {
751 auto servmgr = IServiceManager::Get();
752 ASSERT_TRUE(servmgr != nullptr);
753 std::vector<std::string> serviceNames;
754 int ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_N);
755 ASSERT_TRUE(ret == HDF_SUCCESS);
756 ASSERT_FALSE(serviceNames.empty());
757 ASSERT_TRUE(serviceNames.front().compare(TEST_SERVICE_NAME) == 0);
758 }
759 #endif
760
761 /**
762 * @tc.number: SUB_Driver_Manager_InterfaceQuery_0200
763 * @tc.name: Test get service set by interfacedesc
764 * @tc.size: Medium
765 * @tc.level: level 1
766 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_InterfaceQuery_0200, Function | MediumTest | Level1)767 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_InterfaceQuery_0200, Function | MediumTest | Level1)
768 {
769 auto servmgr = IServiceManager::Get();
770 ASSERT_TRUE(servmgr != nullptr);
771 std::vector<std::string> serviceNames;
772 int ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_INVALID);
773 ASSERT_TRUE(ret == HDF_SUCCESS);
774 ASSERT_TRUE(serviceNames.empty());
775 }
776
777 /**
778 * @tc.number: SUB_Driver_Manager_InterfaceQuery_0300
779 * @tc.name: Test get service set by interfacedesc
780 * @tc.size: Medium
781 * @tc.level: level 1
782 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_InterfaceQuery_0300, Function | MediumTest | Level1)783 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_InterfaceQuery_0300, Function | MediumTest | Level1)
784 {
785 auto servmgr = IServiceManager::Get();
786 ASSERT_TRUE(servmgr != nullptr);
787 std::vector<std::string> serviceNames;
788 int ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_VOID);
789 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM);
790 ASSERT_TRUE(serviceNames.empty());
791 }
792
793 /**
794 * @tc.number: SUB_Driver_Manager_InterfaceQuery_0400
795 * @tc.name: Test get service set by interfacedesc
796 * @tc.size: Medium
797 * @tc.level: level 1
798 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_InterfaceQuery_0400, Function | MediumTest | Level1)799 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_InterfaceQuery_0400, Function | MediumTest | Level1)
800 {
801 auto servmgr = IServiceManager::Get();
802 ASSERT_TRUE(servmgr != nullptr);
803 std::vector<std::string> serviceNames;
804 int ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_NULL);
805 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM);
806 ASSERT_TRUE(serviceNames.empty());
807 }
808
809 #ifdef SAMPLE_SHIELD
810 /**
811 * @tc.number: SUB_Driver_Manager_InterfaceQuery_0500
812 * @tc.name: Test get service set by interfacedesc
813 * @tc.size: Medium
814 * @tc.level: level 1
815 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_InterfaceQuery_0500, Function | MediumTest | Level1)816 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_InterfaceQuery_0500, Function | MediumTest | Level1)
817 {
818 auto devmgr = IDeviceManager::Get();
819 ASSERT_TRUE(devmgr != nullptr);
820 int ret = devmgr->LoadDevice(TEST1_SERVICE_NAME);
821 ASSERT_TRUE(ret == HDF_SUCCESS);
822 auto servmgr = IServiceManager::Get();
823 ASSERT_TRUE(servmgr != nullptr);
824 OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
825 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
826 ASSERT_TRUE(sampleService != nullptr);
827 auto sample1Service = servmgr->GetService(TEST1_SERVICE_NAME);
828 ASSERT_TRUE(sample1Service != nullptr);
829
830 std::vector<std::string> serviceNames;
831 ret = servmgr->ListServiceByInterfaceDesc(serviceNames, TEST_SERVICE_INTERFACE_DESC_N);
832 ASSERT_TRUE(ret == HDF_SUCCESS);
833 constexpr int sampleServiceCount = 2;
834 ASSERT_TRUE(serviceNames.size() == sampleServiceCount);
835 ASSERT_TRUE(serviceNames[0].compare(TEST_SERVICE_NAME) == 0);
836 ASSERT_TRUE(serviceNames[1].compare(TEST1_SERVICE_NAME) == 0);
837 ret = devmgr->UnloadDevice(TEST1_SERVICE_NAME);
838 ASSERT_EQ(ret, HDF_SUCCESS);
839 }
840 #endif
841
842 /**
843 * @tc.number: SUB_Driver_Manager_HdiCC_0800
844 * @tc.name: ListAllServiceTest
845 * @tc.size: Medium
846 * @tc.level: level 1
847 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0800, Function | MediumTest | Level1)848 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0800, Function | MediumTest | Level1)
849 {
850 auto servmgr = IServiceManager::Get();
851 ASSERT_TRUE(servmgr != nullptr);
852
853 std::vector<HdiServiceInfo> serviceInfos;
854 int ret = servmgr->ListAllService(serviceInfos);
855 ASSERT_TRUE(ret == HDF_SUCCESS);
856 ASSERT_TRUE(serviceInfos.size() != 0);
857 }
858
859 /**
860 * @tc.number: SUB_Driver_Manager_HdiCC_0900
861 * @tc.name: ListAllServiceTest
862 * @tc.size: Medium
863 * @tc.level: level 1
864 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0900, Function | MediumTest | Level1)865 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_0900, Function | MediumTest | Level1)
866 {
867 auto devmgr = IDeviceManager::Get();
868 ASSERT_TRUE(devmgr != nullptr);
869
870 std::vector<HdiDevHostInfo> deviceInfos;
871 int ret = devmgr->ListAllDevice(deviceInfos);
872 ASSERT_TRUE(ret == HDF_SUCCESS);
873 ASSERT_TRUE(deviceInfos.size() != 0);
874 }
875
876 #ifdef SAMPLE_SHIELD
877 /**
878 * @tc.number: SUB_Driver_Manager_HdiCC_1000
879 * @tc.name: EndSampleHostTest
880 * @tc.size: Medium
881 * @tc.level: level 1
882 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1000, Function | MediumTest | Level1)883 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1000, Function | MediumTest | Level1)
884 {
885 auto servmgr = IServiceManager::Get();
886 ASSERT_TRUE(servmgr != nullptr);
887
888 auto devmgr = IDeviceManager::Get();
889 ASSERT_TRUE(devmgr != nullptr);
890
891 int ret = devmgr->LoadDevice(TEST1_SERVICE_NAME);
892 ASSERT_TRUE(ret == HDF_SUCCESS);
893 auto sample1Service = servmgr->GetService(TEST1_SERVICE_NAME);
894 constexpr int waitCount = 1000;
895 constexpr int msleepTime = 10;
896 constexpr int waitHostStart = 100;
897 uint32_t cnt = 0;
898 while (sample1Service == nullptr && cnt < waitCount) {
899 OsalMSleep(msleepTime);
900 sample1Service = servmgr->GetService(TEST1_SERVICE_NAME);
901 cnt++;
902 }
903 ASSERT_TRUE(sample1Service != nullptr);
904 ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
905 ASSERT_TRUE(ret == HDF_SUCCESS);
906 cnt = 0;
907 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
908 while (sampleService == nullptr && cnt < waitCount) {
909 OsalMSleep(msleepTime);
910 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
911 cnt++;
912 }
913 ASSERT_TRUE(sampleService != nullptr);
914
915 ret = devmgr->UnloadDevice(TEST1_SERVICE_NAME);
916 ASSERT_TRUE(ret == HDF_SUCCESS);
917 sample1Service = servmgr->GetService(TEST1_SERVICE_NAME);
918 OsalMSleep(msleepTime);
919
920 OHOS::MessageParcel data;
921 OHOS::MessageParcel reply;
922 OHOS::MessageOption option;
923 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
924 ASSERT_EQ(ret, true);
925
926 ret = sampleService->SendRequest(SAMPLE_END_HOST, data, reply, option);
927 ASSERT_TRUE(ret == HDF_SUCCESS);
928 OsalMSleep(waitHostStart);
929
930 ret = devmgr->UnloadDevice(TEST1_SERVICE_NAME);
931 ASSERT_TRUE(ret == HDF_SUCCESS);
932 OsalMSleep(msleepTime);
933 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
934 ASSERT_TRUE(ret == HDF_SUCCESS);
935 }
936
937 /**
938 * @tc.number: SUB_Driver_Manager_HdiCC_1100
939 * @tc.name: InjectPmTest
940 * @tc.size: Medium
941 * @tc.level: level 1
942 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1100, Function | MediumTest | Level1)943 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1100, Function | MediumTest | Level1)
944 {
945 auto servmgr = IServiceManager::Get();
946 ASSERT_TRUE(servmgr != nullptr);
947
948 auto devmgr = IDeviceManager::Get();
949 ASSERT_TRUE(devmgr != nullptr);
950
951 int ret = devmgr->LoadDevice(TEST1_SERVICE_NAME);
952 ASSERT_TRUE(ret == HDF_SUCCESS);
953 auto sample1Service = servmgr->GetService(TEST1_SERVICE_NAME);
954 constexpr int waitCount = 1000;
955 constexpr int waitHostStart = 100;
956 constexpr int msleepTime = 10;
957 uint32_t cnt = 0;
958 while (sample1Service == nullptr && cnt < waitCount) {
959 OsalMSleep(msleepTime);
960 sample1Service = servmgr->GetService(TEST1_SERVICE_NAME);
961 cnt++;
962 }
963 ASSERT_TRUE(sample1Service != nullptr);
964 ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
965 ASSERT_TRUE(ret == HDF_SUCCESS);
966 auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
967 cnt = 0;
968 while (sampleService == nullptr && cnt < waitCount) {
969 OsalMSleep(msleepTime);
970 sampleService = servmgr->GetService(TEST_SERVICE_NAME);
971 cnt++;
972 }
973 ASSERT_TRUE(sampleService != nullptr);
974
975 OHOS::MessageParcel data;
976 OHOS::MessageParcel reply;
977 OHOS::MessageOption option;
978 ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
979 ASSERT_EQ(ret, true);
980
981 ret = sampleService->SendRequest(SAMPLE_INJECT_PM, data, reply, option);
982 ASSERT_TRUE(ret == HDF_SUCCESS);
983 OsalMSleep(msleepTime);
984 ret = sampleService->SendRequest(SAMPLE_END_HOST, data, reply, option);
985 ASSERT_TRUE(ret == HDF_SUCCESS);
986 OsalMSleep(waitHostStart);
987
988 ret = devmgr->UnloadDevice(TEST1_SERVICE_NAME);
989 ASSERT_TRUE(ret == HDF_SUCCESS);
990 OsalMSleep(msleepTime);
991 ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
992 ASSERT_TRUE(ret == HDF_SUCCESS);
993 }
994 #endif
995
996 /**
997 * @tc.number: SUB_Driver_Manager_HdiCC_1200
998 * @tc.name: ListenerTest001
999 * @tc.size: Medium
1000 * @tc.level: level 1
1001 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1200, Function | MediumTest | Level1)1002 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1200, Function | MediumTest | Level1)
1003 {
1004 ::OHOS::sptr<ServStatListener> listener
1005 = new ServStatListener(
1006 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
1007 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
1008 }));
1009
1010 MessageParcel data;
1011 MessageParcel reply;
1012 MessageOption option;
1013
1014 // invalid code
1015 int32_t ret = listener->OnRemoteRequest(SERVIE_STATUS_LISTENER_MAX, data, reply, option);
1016 ASSERT_NE(ret, HDF_SUCCESS);
1017
1018 // empty data
1019 ret = listener->OnRemoteRequest(SERVIE_STATUS_LISTENER_NOTIFY, data, reply, option);
1020 ASSERT_NE(ret, HDF_SUCCESS);
1021 }
1022
1023 /**
1024 * @tc.number: SUB_Driver_Manager_HdiCC_1300
1025 * @tc.name: ListenerTest002
1026 * @tc.size: Medium
1027 * @tc.level: level 1
1028 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1300, Function | MediumTest | Level1)1029 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1300, Function | MediumTest | Level1)
1030 {
1031 ::OHOS::sptr<ServStatListener> listener
1032 = new ServStatListener(
1033 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
1034 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
1035 }));
1036
1037 MessageParcel data;
1038 MessageParcel reply;
1039 MessageOption option;
1040
1041 bool ret = data.WriteInterfaceToken(IServStatListener::GetDescriptor());
1042 ASSERT_TRUE(ret);
1043 int32_t reqRet = listener->OnRemoteRequest(SERVIE_STATUS_LISTENER_NOTIFY, data, reply, option);
1044 ASSERT_NE(reqRet, HDF_SUCCESS);
1045 }
1046
1047 /**
1048 * @tc.number: SUB_Driver_Manager_HdiCC_1400
1049 * @tc.name: ListenerTest003
1050 * @tc.size: Medium
1051 * @tc.level: level 1
1052 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1400, Function | MediumTest | Level1)1053 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1400, Function | MediumTest | Level1)
1054 {
1055 ::OHOS::sptr<ServStatListener> listener
1056 = new ServStatListener(
1057 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
1058 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
1059 }));
1060
1061 MessageParcel data;
1062 MessageParcel reply;
1063 MessageOption option;
1064
1065 bool ret = data.WriteInterfaceToken(IServStatListener::GetDescriptor());
1066 ASSERT_TRUE(ret);
1067 ret = data.WriteCString("");
1068 ASSERT_TRUE(ret);
1069
1070 int32_t reqRet = listener->OnRemoteRequest(SERVIE_STATUS_LISTENER_NOTIFY, data, reply, option);
1071 ASSERT_NE(reqRet, HDF_SUCCESS);
1072 }
1073
1074 /**
1075 * @tc.number: SUB_Driver_Manager_HdiCC_1500
1076 * @tc.name: ListenerTest004
1077 * @tc.size: Medium
1078 * @tc.level: level 1
1079 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1500, Function | MediumTest | Level1)1080 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1500, Function | MediumTest | Level1)
1081 {
1082 ::OHOS::sptr<ServStatListener> listener
1083 = new ServStatListener(
1084 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
1085 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
1086 }));
1087
1088 MessageParcel data;
1089 MessageParcel reply;
1090 MessageOption option;
1091
1092 bool ret = data.WriteInterfaceToken(IServStatListener::GetDescriptor());
1093 ASSERT_TRUE(ret);
1094 ret = data.WriteCString("test_service");
1095 ASSERT_TRUE(ret);
1096
1097 int32_t reqRet = listener->OnRemoteRequest(SERVIE_STATUS_LISTENER_NOTIFY, data, reply, option);
1098 ASSERT_NE(reqRet, HDF_SUCCESS);
1099 }
1100
1101 /**
1102 * @tc.number: SUB_Driver_Manager_HdiCC_1600
1103 * @tc.name: ListenerTest005
1104 * @tc.size: Medium
1105 * @tc.level: level 1
1106 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1600, Function | MediumTest | Level1)1107 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1600, Function | MediumTest | Level1)
1108 {
1109 ::OHOS::sptr<ServStatListener> listener
1110 = new ServStatListener(
1111 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
1112 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
1113 }));
1114
1115 MessageParcel data;
1116 MessageParcel reply;
1117 MessageOption option;
1118
1119 bool ret = data.WriteInterfaceToken(IServStatListener::GetDescriptor());
1120 ASSERT_TRUE(ret);
1121 ret = data.WriteCString("test_service");
1122 ASSERT_TRUE(ret);
1123 // write deviceClass
1124 ret = data.WriteUint16(DeviceClass::DEVICE_CLASS_DEFAULT);
1125 ASSERT_TRUE(ret);
1126
1127 int32_t reqRet = listener->OnRemoteRequest(SERVIE_STATUS_LISTENER_NOTIFY, data, reply, option);
1128 ASSERT_NE(reqRet, HDF_SUCCESS);
1129 }
1130
1131 /**
1132 * @tc.number: SUB_Driver_Manager_HdiCC_1700
1133 * @tc.name: ListenerTest006
1134 * @tc.size: Medium
1135 * @tc.level: level 1
1136 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1700, Function | MediumTest | Level1)1137 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1700, Function | MediumTest | Level1)
1138 {
1139 ::OHOS::sptr<ServStatListener> listener
1140 = new ServStatListener(
1141 ServStatListener::StatusCallback([&](const ServiceStatus &status) {
1142 HDF_LOGI("service status callback, service is %{public}s", status.serviceName.data());
1143 }));
1144
1145 MessageParcel data;
1146 MessageParcel reply;
1147 MessageOption option;
1148
1149 bool ret = data.WriteInterfaceToken(IServStatListener::GetDescriptor());
1150 ASSERT_TRUE(ret);
1151 ret = data.WriteCString("test_service");
1152 ASSERT_TRUE(ret);
1153 // write deviceClass
1154 ret = data.WriteUint16(DeviceClass::DEVICE_CLASS_DEFAULT);
1155 ASSERT_TRUE(ret);
1156 // write status
1157 ret = data.WriteUint16(ServiceStatusType::SERVIE_STATUS_START);
1158 ASSERT_TRUE(ret);
1159
1160 int32_t reqRet = listener->OnRemoteRequest(SERVIE_STATUS_LISTENER_NOTIFY, data, reply, option);
1161 ASSERT_EQ(reqRet, HDF_SUCCESS);
1162 }
1163
1164 /**
1165 * @tc.number: SUB_Driver_Manager_HdiCC_1800
1166 * @tc.name: InvalidCodeTest001
1167 * @tc.size: Medium
1168 * @tc.level: level 1
1169 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1800, Function | MediumTest | Level1)1170 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1800, Function | MediumTest | Level1)
1171 {
1172 auto servmgr = OHOS::HDI::ServiceManager::V1_0::IServiceManager::Get();
1173 ASSERT_NE(servmgr, nullptr);
1174
1175 sptr<IRemoteObject> remote = servmgr->GetService("hdf_device_manager");
1176 ASSERT_NE(remote, nullptr);
1177
1178 MessageParcel data;
1179 MessageParcel reply;
1180 MessageOption option;
1181
1182 ASSERT_TRUE(data.WriteInterfaceToken(IDeviceManager::GetDescriptor()));
1183 int ret = remote->SendRequest(INVALID_CODE, data, reply, option);
1184 EXPECT_EQ(ret, ERROR_CODE_WITH_INVALID_CODE);
1185 }
1186
1187 /**
1188 * @tc.number: SUB_Driver_Manager_HdiCC_1900
1189 * @tc.name: InvalidCodeTest002
1190 * @tc.size: Medium
1191 * @tc.level: level 1
1192 */
HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1900, Function | MediumTest | Level1)1193 HWTEST_F(HdfServiceMangerHdiTest, SUB_Driver_Manager_HdiCC_1900, Function | MediumTest | Level1)
1194 {
1195 auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
1196 ASSERT_NE(saManager, nullptr);
1197 sptr<IRemoteObject> remote = saManager->GetSystemAbility(DEVICE_SERVICE_MANAGER_SA_ID);
1198 ASSERT_NE(remote, nullptr);
1199
1200 MessageParcel data;
1201 MessageParcel reply;
1202 MessageOption option;
1203
1204 ASSERT_TRUE(data.WriteInterfaceToken(OHOS::HDI::ServiceManager::V1_0::IServiceManager::GetDescriptor()));
1205 int ret = remote->SendRequest(INVALID_CODE, data, reply, option);
1206 ASSERT_EQ(ret, ERROR_CODE_WITH_INVALID_CODE);
1207 }
1208 } // namespace OHOS
1209