openharmony/xts_hats
1
0
Fork 0
mirror of https://gitee.com/openharmony/xts_hats synced 2025-02-22 11:21:42 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

manage test

Browse Source 
Signed-off-by: liuhonggang123 <honggang.liu@huawei.com>
Change-Id: I70534de342d04e8f157c6c3355434e231219ea16
This commit is contained in:
liuhonggang123 2022-03-16 10:52:30 +08:00
parent 2b8d4fa75e
commit 04e0760e95
2 changed files with 174 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
hdf/manager/managerHdiTest/service_manager_hdi_c_test.cpp
View File

@ -22,18 +22,20 @@
#include <hdf_service_status.h>
#include <osal_time.h>
#include <servmgr_hdi.h>
#include <string>
#include <shared_mem.h>
#include <string>
#include <sys/mman.h>
#include "sample_hdi.h"
#define HDF_LOG_TAG service_manager_test
using namespace testing::ext;
constexpr const char *TEST_SERVICE_NAME = "sample_driver_service";
constexpr int PAYLOAD_NUM = 1234;
static constexpr const char *TEST_SERVICE_NAME = "sample_driver_service";
static constexpr const char *TEST_SERVICE_INTERFACE_DESC = "hdf.test.sampele_service";
static constexpr int PAYLOAD_NUM = 1234;
static constexpr int WAIT_LOAD_UNLOAD_TIME = 300;
class HdfServiceMangerHdiCTest : public testing::Test {
public:
static void SetUpTestCase()
@ -82,12 +84,17 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest002, Function | MediumTest | Level
HDIServiceManagerRelease(servmgr);
ASSERT_TRUE(sampleService != nullptr);
bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
ASSERT_TRUE(data != nullptr);
ASSERT_TRUE(reply != nullptr);
ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
ASSERT_EQ(ret, true);
bool ret = HdfSbufWriteString(data, "sample_service test call");
ret = HdfSbufWriteString(data, "sample_service test call");
ASSERT_EQ(ret, true);
int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_SERVICE_PING, data, reply);
@ -125,6 +132,8 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest003, Function | MediumTest | Level
struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
HDIServiceManagerRelease(servmgr);
ASSERT_TRUE(sampleService != nullptr);
bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
struct HdfRemoteService *callback = HdfRemoteServiceObtain(nullptr, &g_callbackDispatcher);
ASSERT_NE(callback, nullptr);
@ -132,7 +141,8 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest003, Function | MediumTest | Level
struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
ASSERT_TRUE(data != nullptr);
ASSERT_TRUE(reply != nullptr);
ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
ASSERT_EQ(ret, true);
int32_t payload = PAYLOAD_NUM;
HdfSbufWriteInt32(data, payload);
HdfSbufWriteRemoteService(data, callback);
@ -159,18 +169,22 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest004, Function | MediumTest | Level
struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
HDIServiceManagerRelease(servmgr);
ASSERT_TRUE(sampleService != nullptr);
bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
ASSERT_TRUE(data != nullptr);
ASSERT_TRUE(reply != nullptr);
ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
ASSERT_EQ(ret, true);
HdfSbufWriteInt32(data, PAYLOAD_NUM);
HdfSbufWriteInt32(data, PAYLOAD_NUM);
int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_SERVICE_SUM, data, reply);
ASSERT_EQ(status, 0);
int32_t result;
bool ret = HdfSbufReadInt32(reply, &result);
ret = HdfSbufReadInt32(reply, &result);
ASSERT_TRUE(ret);
int32_t expRes = PAYLOAD_NUM + PAYLOAD_NUM;
@ -194,14 +208,17 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest005, Function | MediumTest | Level
struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
HDIServiceManagerRelease(servmgr);
ASSERT_TRUE(sampleService != nullptr);
bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
ASSERT_TRUE(data != nullptr);
ASSERT_TRUE(reply != nullptr);
struct DataBlock dataBlock = { 1, 2, "dataBolck", 3 };
bool ret = DataBlockBlockMarshalling(&dataBlock, data);
ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
ASSERT_EQ(ret, true);
struct DataBlock dataBlock = {1, 2, "dataBolck", 3};
ret = DataBlockBlockMarshalling(&dataBlock, data);
ASSERT_TRUE(ret);
int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_STRUCT_TRANS, data, reply);
@ -234,6 +251,8 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest006, Function | MediumTest | Level
struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
HDIServiceManagerRelease(servmgr);
ASSERT_TRUE(sampleService != nullptr);
bool ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
@ -245,8 +264,9 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest006, Function | MediumTest | Level
for (int i = 0; i < buffersize; i++) {
dataBuffer[i] = i;
}
bool ret = HdfSbufWriteUnpadBuffer(data, dataBuffer, sizeof(dataBuffer));
ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
ASSERT_EQ(ret, true);
ret = HdfSbufWriteUnpadBuffer(data, dataBuffer, sizeof(dataBuffer));
ASSERT_TRUE(ret);
int status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_BUFFER_TRANS, data, reply);
@ -277,21 +297,25 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest007, Function | MediumTest | Level
struct HDIServiceManager *servmgr = HDIServiceManagerGet();
ASSERT_TRUE(servmgr != nullptr);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService == nullptr);
int ret = devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
ASSERT_EQ(ret, HDF_SUCCESS);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService != nullptr);
ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
ASSERT_TRUE(data != nullptr);
ASSERT_TRUE(reply != nullptr);
ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
ASSERT_EQ(ret, true);
const char *newServName = "sample_driver_service2";
ret = HdfSbufWriteString(data, newServName);
ASSERT_TRUE(ret);
@ -301,9 +325,13 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest007, Function | MediumTest | Level
struct HdfRemoteService *sampleService2 = servmgr->GetService(servmgr, newServName);
ASSERT_TRUE(sampleService != nullptr);
ret = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
HdfSbufFlush(data);
HdfSbufFlush(reply);
ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
ASSERT_EQ(ret, true);
HdfSbufWriteInt32(data, PAYLOAD_NUM);
HdfSbufWriteInt32(data, PAYLOAD_NUM);
@ -318,6 +346,8 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest007, Function | MediumTest | Level
HdfRemoteServiceRecycle(sampleService2);
HdfSbufFlush(data);
ret = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
ASSERT_EQ(ret, true);
ret = HdfSbufWriteString(data, newServName);
ASSERT_TRUE(ret);
@ -331,6 +361,7 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest007, Function | MediumTest | Level
ASSERT_EQ(ret, HDF_SUCCESS);
HdfRemoteServiceRecycle(sampleService);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService == nullptr);
@ -339,12 +370,13 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest007, Function | MediumTest | Level
}
struct ServiceStatusData {
ServiceStatusData() : devClass(0), servStatus(0), callbacked(false) {}
ServiceStatusData() : devClass(0), servStatus(0), callbacked(false), waitStatus(SERVIE_STATUS_START) {}
~ServiceStatusData() = default;
std::string servInfo;
uint16_t devClass;
uint16_t servStatus;
bool callbacked;
uint16_t waitStatus;
};
static void TestOnServiceStatusReceived(struct ServiceStatusListener *listener, struct ServiceStatus *servstat)
@ -353,8 +385,8 @@ static void TestOnServiceStatusReceived(struct ServiceStatusListener *listener,
if (ssd == nullptr) {
return;
}
if (strcmp(servstat->serviceName, TEST_SERVICE_NAME) == 0) {
ssd->servInfo = servstat->info != nullptr ? servstat->info : "";
if (strcmp(servstat->serviceName, TEST_SERVICE_NAME) == 0 && (servstat->status == ssd->waitStatus)) {
ssd->servInfo = ((servstat->info != nullptr) ? (servstat->info) : (""));
ssd->devClass = servstat->deviceClass;
ssd->servStatus = servstat->status;
ssd->callbacked = true;
@ -377,11 +409,12 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest008, Function | MediumTest | Level
struct HDIServiceManager *servmgr = HDIServiceManagerGet();
ASSERT_TRUE(servmgr != nullptr);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService == nullptr);
struct ServiceStatusData ssd;
ssd.waitStatus = SERVIE_STATUS_START;
struct ServiceStatusListener *listener = HdiServiceStatusListenerNewInstance();
listener->callback = TestOnServiceStatusReceived;
listener->priv = (void *)&ssd;
@ -391,11 +424,11 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest008, Function | MediumTest | Level
int ret = devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
ASSERT_EQ(ret, HDF_SUCCESS);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService != nullptr);
constexpr int WAIT_COUNT = 10;
constexpr int WAIT_COUNT = 300;
int count = WAIT_COUNT;
while (!ssd.callbacked && count > 0) {
OsalMSleep(1);
@ -408,6 +441,7 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest008, Function | MediumTest | Level
ASSERT_EQ(ssd.servStatus, SERVIE_STATUS_START);
ssd.callbacked = false;
ssd.waitStatus = SERVIE_STATUS_STOP;
ret = devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
ASSERT_EQ(ret, HDF_SUCCESS);
@ -438,7 +472,7 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest009, Function | MediumTest | Level
struct HDIDeviceManager *devmgr = HDIDeviceManagerGet();
ASSERT_TRUE(devmgr != nullptr);
devmgr->UnloadDevice(devmgr, TEST_SERVICE_NAME);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
struct HDIServiceManager *servmgr = HDIServiceManagerGet();
ASSERT_TRUE(servmgr != nullptr);
@ -447,9 +481,11 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest009, Function | MediumTest | Level
int ret = devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
ASSERT_EQ(ret, HDF_SUCCESS);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService != nullptr);
bool res = HdfRemoteServiceSetInterfaceDesc(sampleService, TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(res, true);
struct ServiceStatusData ssd;
struct ServiceStatusListener *listener = HdiServiceStatusListenerNewInstance();
@ -466,15 +502,17 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest009, Function | MediumTest | Level
struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
ASSERT_TRUE(data != nullptr);
ASSERT_TRUE(reply != nullptr);
ret = HdfSbufWriteString(data, info.data());
ASSERT_TRUE(ret);
res = HdfRemoteServiceWriteInterfaceToken(sampleService, data);
ASSERT_EQ(res, true);
res = HdfSbufWriteString(data, info.data());
ASSERT_TRUE(res);
ssd.callbacked = false;
ssd.waitStatus = SERVIE_STATUS_CHANGE;
status = sampleService->dispatcher->Dispatch(sampleService, SAMPLE_UPDATE_SERVIE, data, reply);
ASSERT_EQ(status, HDF_SUCCESS);
constexpr int WAIT_COUNT = 10;
constexpr int WAIT_COUNT = 100;
int count = WAIT_COUNT;
while (!ssd.callbacked && count > 0) {
OsalMSleep(1);
@ -508,11 +546,12 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest010, Function | MediumTest | Level
struct HDIServiceManager *servmgr = HDIServiceManagerGet();
ASSERT_TRUE(servmgr != nullptr);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
struct HdfRemoteService *sampleService = servmgr->GetService(servmgr, TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService == nullptr);
struct ServiceStatusData ssd;
ssd.waitStatus = SERVIE_STATUS_START;
struct ServiceStatusListener *listener = HdiServiceStatusListenerNewInstance();
listener->callback = TestOnServiceStatusReceived;
listener->priv = (void *)&ssd;
@ -523,7 +562,7 @@ HWTEST_F(HdfServiceMangerHdiCTest, ServMgrTest010, Function | MediumTest | Level
int ret = devmgr->LoadDevice(devmgr, TEST_SERVICE_NAME);
ASSERT_EQ(ret, HDF_SUCCESS);
constexpr int WAIT_COUNT = 10;
constexpr int WAIT_COUNT = 300;
int count = WAIT_COUNT;
while (!ssd.callbacked && count > 0) {
OsalMSleep(1);

177
hdf/manager/managerServiceTest/service_manager_hdi_test.cpp
View File

@ -22,8 +22,9 @@
#include <iostream>
#include <ipc_object_stub.h>
#include <iservmgr_hdi.h>
#include <osal_time.h>
#include <string>
#include "osal_time.h"
#include "sample_hdi.h"
#define HDF_LOG_TAG service_manager_test_cpp
@ -39,10 +40,12 @@ using OHOS::HDI::ServiceManager::V1_0::IServiceManager;
using OHOS::HDI::ServiceManager::V1_0::IServStatListener;
using OHOS::HDI::ServiceManager::V1_0::ServiceStatus;
using OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub;
constexpr const char *TEST_SERVICE_NAME = "sample_driver_service";
constexpr int PAYLOAD_NUM = 1234;
constexpr int SMQ_TEST_QUEUE_SIZE = 10;
constexpr int SMQ_TEST_WAIT_TIME = 100;
static constexpr const char *TEST_SERVICE_NAME = "sample_driver_service";
static constexpr const char16_t *TEST_SERVICE_INTERFACE_DESC = u"hdf.test.sampele_service";
static constexpr int PAYLOAD_NUM = 1234;
static constexpr int SMQ_TEST_QUEUE_SIZE = 10;
static constexpr int SMQ_TEST_WAIT_TIME = 100;
static constexpr int WAIT_LOAD_UNLOAD_TIME = 300;
class HdfServiceMangerHdiTest : public testing::Test {
public:
@ -62,6 +65,9 @@ public:
devmgr->UnloadDevice(TEST_SERVICE_NAME);
}
}
void TestServiceListenerStop(const sptr<IDeviceManager>& devmgr, const sptr<IServiceManager>& servmgr);
void TestSampleService(sptr<IRemoteObject>& sampleService, const sptr<IDeviceManager>& devmgr,
const sptr<IServiceManager>& servmgr);
void SetUp() {};
void TearDown() {};
};
@ -70,8 +76,8 @@ class IPCObjectStubTest : public OHOS::IPCObjectStub {
public:
explicit IPCObjectStubTest() : OHOS::IPCObjectStub(u"") {};
virtual ~IPCObjectStubTest() = default;
int OnRemoteRequest(uint32_t code, OHOS::MessageParcel &data,
OHOS::MessageParcel &reply, OHOS::MessageOption &option) override
int OnRemoteRequest(
uint32_t code, OHOS::MessageParcel &data, OHOS::MessageParcel &reply, OHOS::MessageOption &option) override
{
HDF_LOGI("IPCObjectStubTest::OnRemoteRequest called, code = %{public}d", code);
payload = data.ReadInt32();
@ -113,6 +119,8 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest002, Function | MediumTest | Level1
OHOS::MessageParcel data;
OHOS::MessageParcel reply;
bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
data.WriteCString("sample_service test call");
OHOS::MessageOption option;
@ -138,6 +146,8 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest003, Function | MediumTest | Level1
OHOS::MessageParcel data;
OHOS::MessageParcel reply;
int32_t payload = PAYLOAD_NUM;
bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
data.WriteInt32(payload);
data.WriteRemoteObject(callback);
@ -163,6 +173,8 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest004, Function | MediumTest | Level1
OHOS::MessageParcel data;
OHOS::MessageParcel reply;
bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
data.WriteInt32(PAYLOAD_NUM);
data.WriteInt32(PAYLOAD_NUM);
@ -196,8 +208,9 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest005, Function | MediumTest | Level1
for (int i = 0; i < buffersize; i++) {
dataBuffer[i] = i;
}
bool ret = data.WriteUnpadBuffer(dataBuffer, sizeof(dataBuffer));
bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
ret = data.WriteUnpadBuffer(dataBuffer, sizeof(dataBuffer));
ASSERT_TRUE(ret);
OHOS::MessageOption option;
@ -226,20 +239,21 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest006, Function | MediumTest | Level1
auto servmgr = IServiceManager::Get();
ASSERT_TRUE(servmgr != nullptr);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService == nullptr);
int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
ASSERT_EQ(ret, HDF_SUCCESS);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
sampleService = servmgr->GetService(TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService != nullptr);
OHOS::MessageParcel data;
OHOS::MessageParcel reply;
OHOS::MessageOption option;
ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
const char *newServName = "sample_driver_service2";
ret = data.WriteCString(newServName);
ASSERT_TRUE(ret);
@ -252,6 +266,8 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest006, Function | MediumTest | Level1
data.FlushBuffer();
reply.FlushBuffer();
ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
data.WriteInt32(PAYLOAD_NUM);
data.WriteInt32(PAYLOAD_NUM);
@ -265,6 +281,8 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest006, Function | MediumTest | Level1
data.FlushBuffer();
reply.FlushBuffer();
ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
data.WriteCString(newServName);
status = sampleService->SendRequest(SAMPLE_UNREGISTER_DEVICE, data, reply, option);
@ -275,7 +293,7 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest006, Function | MediumTest | Level1
ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
ASSERT_EQ(ret, HDF_SUCCESS);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
sampleService = servmgr->GetService(TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService == nullptr);
}
@ -283,9 +301,7 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest006, Function | MediumTest | Level1
class ServStatListener : public OHOS::HDI::ServiceManager::V1_0::ServStatListenerStub {
public:
using StatusCallback = std::function<void(const ServiceStatus &)>;
explicit ServStatListener(StatusCallback callback) : callback_(std::move(callback))
{
}
explicit ServStatListener(StatusCallback callback) : callback_(std::move(callback)) {}
~ServStatListener() = default;
void OnReceive(const ServiceStatus &status) override
{
@ -296,31 +312,18 @@ private:
StatusCallback callback_;
};
/**
* @tc.number: SUB_DriverSystem_ManagerService_0070
* @tc.name: Test service start status listener
* @tc.size: Medium
* @tc.level: level 1
*/
HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest007, Function | MediumTest | Level1)
/*
* Test service start status listener
*/
void HdfServiceMangerHdiTest::TestServiceListenerStop(const sptr<IDeviceManager>& devmgr,
const sptr<IServiceManager>& servmgr)
{
auto devmgr = IDeviceManager::Get();
ASSERT_TRUE(devmgr != nullptr);
devmgr->UnloadDevice(TEST_SERVICE_NAME);
auto servmgr = IServiceManager::Get();
ASSERT_TRUE(servmgr != nullptr);
auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService == nullptr);
std::string servInfo;
uint16_t devClass;
uint16_t servStatus;
bool callbacked = false;
::OHOS::sptr<IServStatListener> listener
= new ServStatListener(
ServStatListener::StatusCallback([&](const ServiceStatus &status) {
= new ServStatListener(ServStatListener::StatusCallback([&](const ServiceStatus &status) {
HDF_LOGI("service status callback");
if (status.serviceName == std::string(TEST_SERVICE_NAME)) {
servInfo = status.info;
@ -335,7 +338,8 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest007, Function | MediumTest | Level1
int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
ASSERT_EQ(ret, HDF_SUCCESS);
int count = 10;
constexpr int WAIT_COUNT = 300;
int count = WAIT_COUNT;
while (!callbacked && count > 0) {
OsalMSleep(1);
count--;
@ -349,7 +353,7 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest007, Function | MediumTest | Level1
ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
ASSERT_EQ(ret, HDF_SUCCESS);
count = 10;
count = WAIT_COUNT;
while (!callbacked && count > 0) {
OsalMSleep(1);
count--;
@ -377,16 +381,19 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest008, Function | MediumTest | Level1
auto servmgr = IServiceManager::Get();
ASSERT_TRUE(servmgr != nullptr);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService == nullptr);
int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
ASSERT_EQ(ret, HDF_SUCCESS);
sampleService = servmgr->GetService(TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService != nullptr);
TestServiceListenerStop(devmgr, servmgr);
}
/*
* Test service status listener update service info
*/
void HdfServiceMangerHdiTest::TestSampleService(sptr<IRemoteObject>& sampleService,
const sptr<IDeviceManager>& devmgr, const sptr<IServiceManager>& servmgr)
{
std::string servInfo;
uint16_t devClass;
uint16_t servStatus;
@ -394,29 +401,32 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest008, Function | MediumTest | Level1
::OHOS::sptr<IServStatListener> listener
= new ServStatListener(
ServStatListener::StatusCallback([&](const ServiceStatus &status) {
if (status.serviceName == std::string(TEST_SERVICE_NAME)) {
if (status.serviceName == std::string(TEST_SERVICE_NAME) &&
status.status == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_CHANGE) {
HDF_LOGI("sample service status callback");
servInfo = status.info;
devClass = status.deviceClass;
servStatus = status.status;
callbacked = true;
}
}));
constexpr int FIRST_WAIT = 20;
OsalMSleep(FIRST_WAIT); // skip callback on register
int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
ASSERT_EQ(status, HDF_SUCCESS);
constexpr int FIRST_WAIT = 20;
OsalMSleep(FIRST_WAIT); // skip callback on register
OHOS::MessageParcel data;
OHOS::MessageParcel reply;
OHOS::MessageOption option;
bool res = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(res, true);
std::string info = "foo";
data.WriteCString(info.data());
callbacked = false;
status = sampleService->SendRequest(SAMPLE_UPDATE_SERVIE, data, reply, option);
ASSERT_EQ(status, HDF_SUCCESS);
int count = 10;
constexpr int WAIT_COUNT = 300;
int count = WAIT_COUNT;
while (!callbacked && count > 0) {
OsalMSleep(1);
count--;
@ -424,15 +434,39 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest008, Function | MediumTest | Level1
ASSERT_TRUE(callbacked);
ASSERT_EQ(devClass, DEVICE_CLASS_DEFAULT);
ASSERT_EQ(servInfo, info);
ASSERT_EQ(servStatus, OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_CHANGE);
ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
int ret = devmgr->UnloadDevice(TEST_SERVICE_NAME);
ASSERT_EQ(ret, HDF_SUCCESS);
status = servmgr->UnregisterServiceStatusListener(listener);
ASSERT_EQ(status, HDF_SUCCESS);
}
/**
* @tc.number: SUB_DriverSystem_ManagerService_00900
* @tc.name: Test service loadDevice
* @tc.size: Medium
* @tc.level: level 1
*/
HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest0090, Function | MediumTest | Level1)
{
auto devmgr = IDeviceManager::Get();
ASSERT_TRUE(devmgr != nullptr);
devmgr->UnloadDevice(TEST_SERVICE_NAME);
auto servmgr = IServiceManager::Get();
ASSERT_TRUE(servmgr != nullptr);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService == nullptr);
int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
ASSERT_EQ(ret, HDF_SUCCESS);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
sampleService = servmgr->GetService(TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService != nullptr);
TestSampleService(sampleService, devmgr, servmgr);
}
/**
* @tc.number: SUB_DriverSystem_ManagerService_0090
* @tc.name: Test service status listener unregister
@ -447,7 +481,7 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest009, Function | MediumTest | Level1
auto servmgr = IServiceManager::Get();
ASSERT_TRUE(servmgr != nullptr);
OsalMSleep(WAIT_LOAD_UNLOAD_TIME);
auto sampleService = servmgr->GetService(TEST_SERVICE_NAME);
ASSERT_TRUE(sampleService == nullptr);
@ -459,7 +493,8 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest009, Function | MediumTest | Level1
= new ServStatListener(
ServStatListener::StatusCallback([&](const ServiceStatus &status) {
HDF_LOGI("service status callback");
if (status.serviceName == std::string(TEST_SERVICE_NAME)) {
if (status.serviceName == std::string(TEST_SERVICE_NAME) &&
status.status == OHOS::HDI::ServiceManager::V1_0::SERVIE_STATUS_START) {
servInfo = status.info;
devClass = status.deviceClass;
servStatus = status.status;
@ -473,7 +508,8 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest009, Function | MediumTest | Level1
int ret = devmgr->LoadDevice(TEST_SERVICE_NAME);
ASSERT_EQ(ret, HDF_SUCCESS);
int count = 10;
constexpr int WAIT_COUNT = 300;
int count = WAIT_COUNT;
while (!callbacked && count > 0) {
OsalMSleep(1);
count--;
@ -518,11 +554,12 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest010, Function | MediumTest | Level1
OHOS::MessageParcel data;
OHOS::MessageParcel reply;
OHOS::MessageOption option;
std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq
= std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::SYNCED_SMQ);
std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::SYNCED_SMQ);
ASSERT_TRUE(smq->IsGood());
auto ret = smq->GetMeta()->Marshalling(data);
bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
ret = smq->GetMeta()->Marshalling(data);
ASSERT_TRUE(ret);
data.WriteUint32(1);
@ -558,13 +595,13 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest011, Function | MediumTest | Level1
OHOS::MessageParcel data;
OHOS::MessageParcel reply;
OHOS::MessageOption option;
std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq
= std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::SYNCED_SMQ);
std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::SYNCED_SMQ);
ASSERT_TRUE(smq->IsGood());
bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
constexpr uint32_t ELEMENT_SIZE = 2;
auto ret = smq->GetMeta()->Marshalling(data);
ret = smq->GetMeta()->Marshalling(data);
ASSERT_TRUE(ret);
data.WriteUint32(ELEMENT_SIZE);
@ -602,13 +639,13 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest012, Function | MediumTest | Level1
OHOS::MessageParcel reply;
OHOS::MessageOption option;
std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq
= std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::UNSYNC_SMQ);
std::unique_ptr<SharedMemQueue<SampleSmqElement>> smq =
std::make_unique<SharedMemQueue<SampleSmqElement>>(SMQ_TEST_QUEUE_SIZE, SmqType::UNSYNC_SMQ);
ASSERT_TRUE(smq->IsGood());
bool ret = data.WriteInterfaceToken(TEST_SERVICE_INTERFACE_DESC);
ASSERT_EQ(ret, true);
constexpr uint32_t ELEMENT_SIZE = 2;
auto ret = smq->GetMeta()->Marshalling(data);
ret = smq->GetMeta()->Marshalling(data);
ASSERT_TRUE(ret);
data.WriteUint32(ELEMENT_SIZE);
auto status = sampleService->SendRequest(SAMPLE_TRANS_SMQ, data, reply, option);
@ -659,7 +696,7 @@ HWTEST_F(HdfServiceMangerHdiTest, ServMgrTest013, Function | MediumTest | Level1
int status = servmgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_DEFAULT);
ASSERT_EQ(status, HDF_SUCCESS);
constexpr int WAIT_COUNT = 10;
constexpr int WAIT_COUNT = 100;
int count = WAIT_COUNT;
while (!sampleServiceStarted && count > 0) {
OsalMSleep(1);