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