openharmony/ability_dmsfwk
1
0
Fork 0
mirror of https://gitee.com/openharmony/ability_dmsfwk synced 2024-11-27 00:20:44 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

!400 TDD补充测试用例

Browse Source 
Merge pull request !400 from 杜智海/master
This commit is contained in:
openharmony_ci 2022-10-18 13:39:58 +00:00 committed by Gitee
commit 8cc03c12c0
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
6 changed files with 468 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
interfaces/kits/napi/continuation_manager/js_continuation_manager.cpp
View File

@ -320,7 +320,7 @@ NativeValue* JsContinuationManager::OnRegisterDeviceSelectionCallback(NativeEngi
std::lock_guard<std::mutex> jsCbMapLock(jsCbMapMutex_);
if (IsCallbackRegistered(token, cbType)) {
errCode = REPEATED_REGISTRATION;
return "UnregisterDeviceSelectionCallback Callback has registered";
return "registerDeviceSelectionCallback Callback has registered";
}
std::unique_ptr<NativeReference> callbackRef;
callbackRef.reset(engine.CreateReference(jsListenerObj, 1));

8
services/base/src/dtbschedmgr_device_info_storage.cpp
View File

@ -147,6 +147,10 @@ bool DtbschedmgrDeviceInfoStorage::WaitForDnetworkReady()
void DtbschedmgrDeviceInfoStorage::RegisterUuidNetworkIdMap(const std::string& networkId)
{
std::string uuid = DnetworkAdapter::GetInstance()->GetUuidByNetworkId(networkId);
if (uuid.empty()) {
HILOGE("GetUuidByNetworkId return an empty uuid!");
return;
}
{
std::lock_guard<std::mutex> autoLock(uuidNetworkIdLock_);
uuidNetworkIdMap_[uuid] = networkId;
@ -156,6 +160,10 @@ void DtbschedmgrDeviceInfoStorage::RegisterUuidNetworkIdMap(const std::string& n
void DtbschedmgrDeviceInfoStorage::UnregisterUuidNetworkIdMap(const std::string& networkId)
{
std::string uuid = DnetworkAdapter::GetInstance()->GetUuidByNetworkId(networkId);
if (uuid.empty()) {
HILOGE("GetUuidByNetworkId return an empty uuid");
return;
}
{
std::lock_guard<std::mutex> autoLock(uuidNetworkIdLock_);
uuidNetworkIdMap_.erase(uuid);

15
services/base/test/BUILD.gn
View File

@ -20,9 +20,7 @@ module_output_path = "dmsfwk/distributed_base_svr_test"
distributed_service = "//foundation/ability/dmsfwk/services"
base_configs = [
"${distributed_service}/dtbabilitymgr:distributed_ability_manager_config",
]
base_configs = [ "${distributed_service}/base:distributed_sched_config" ]
config("test_config") {
visibility = [ ":*" ]
@ -49,14 +47,19 @@ base_public_deps = [
ohos_unittest("dmsbasetest") {
module_out_path = module_output_path
sources = [ "unittest/dms_network_adapter_test.cpp" ]
sources = [
"${distributed_service}/base/src/adapter/dnetwork_adapter.cpp",
"${distributed_service}/base/src/deviceManager/dms_device_info.cpp",
"${distributed_service}/base/src/distributed_device_node_listener.cpp",
"${distributed_service}/base/src/dtbschedmgr_device_info_storage.cpp",
"unittest/dms_network_adapter_test.cpp",
"unittest/dtbschedmgr_device_info_storage_test.cpp",
]
configs = [
":test_config",
"//foundation/ability/dmsfwk/services/dtbschedmgr/test/resource:coverage_flags",
]
configs += base_configs
deps =
[ "${distributed_service}/dtbabilitymgr:distributed_ability_manager_svr" ]
external_deps = base_external_deps
public_deps = base_public_deps
part_name = "dmsfwk"

412
services/base/test/unittest/dtbschedmgr_device_info_storage_test.cpp Normal file
View File

@ -0,0 +1,412 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dtbschedmgr_device_info_storage_test.h"
#include "dtbschedmgr_log.h"
#include "test_log.h"
#include <cstddef>
namespace OHOS {
namespace DistributedSchedule {
using namespace std;
using namespace testing;
using namespace testing::ext;
class MockDmsNotifier : public DmsNotifier {
public:
MockDmsNotifier() = default;
~MockDmsNotifier() = default;
void DeviceOnlineNotify(const std::string& deviceId) override;
void DeviceOfflineNotify(const std::string& deviceId) override;
void ProcessNotifierDied(const sptr<IRemoteObject>& notifier) override;
void ScheduleStartDeviceManager(const sptr<IRemoteObject>& appProxy, int32_t token,
const std::shared_ptr<ContinuationExtraParams>& continuationExtraParams = nullptr) override;
int32_t OnDeviceConnect(int32_t token, const std::vector<ContinuationResult>& continuationResults) override;
int32_t OnDeviceDisconnect(int32_t token, const std::vector<std::string>& deviceIds) override;
int32_t OnDeviceCancel() override;
};
void MockDmsNotifier::DeviceOnlineNotify(const std::string& deviceId)
{
}
void MockDmsNotifier::DeviceOfflineNotify(const std::string& deviceId)
{
}
void MockDmsNotifier::ProcessNotifierDied(const sptr<IRemoteObject>& notifier)
{
}
void MockDmsNotifier::ScheduleStartDeviceManager(const sptr<IRemoteObject>& appProxy, int32_t token,
const std::shared_ptr<ContinuationExtraParams>& continuationExtraParams)
{
}
int32_t MockDmsNotifier::OnDeviceConnect(int32_t token, const std::vector<ContinuationResult>& continuationResults)
{
return 0;
}
int32_t MockDmsNotifier::OnDeviceDisconnect(int32_t token, const std::vector<std::string>& deviceIds)
{
return 0;
}
int32_t MockDmsNotifier::OnDeviceCancel()
{
return 0;
}
void DtbschedmgrDeviceInfoStorageTest::SetUpTestCase()
{
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest::SetUpTestCase" << std::endl;
}
void DtbschedmgrDeviceInfoStorageTest::TearDownTestCase()
{
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest::TearDownTestCase" << std::endl;
}
void DtbschedmgrDeviceInfoStorageTest::SetUp()
{
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest::SetUp" << std::endl;
}
void DtbschedmgrDeviceInfoStorageTest::TearDown()
{
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest::TearDown" << std::endl;
}
/**
* @tc.name: InitTest_001
* @tc.desc: test Init
* @tc.type: FUNC
*/
HWTEST_F(DtbschedmgrDeviceInfoStorageTest, InitTest_001, TestSize.Level3)
{
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest InitTest_001 start" << std::endl;
/**
* @tc.steps: step1. test Init with listener when initHandler_ is nullptr;
*/
sptr<DmsNotifier> listener = nullptr;
DtbschedmgrDeviceInfoStorage::GetInstance().initHandler_ = nullptr;
bool result = DtbschedmgrDeviceInfoStorage::GetInstance().Init(listener);
EXPECT_TRUE(result);
/**
* @tc.steps: step2. test Init when initHandler_ is not nullptr;
*/
result = DtbschedmgrDeviceInfoStorage::GetInstance().Init();
EXPECT_TRUE(result);
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest InitTest_001 end" << std::endl;
}
/**
* @tc.name: ConnectSoftbusTest_001
* @tc.desc: test ConnectSoftbus
* @tc.type: FUNC
*/
HWTEST_F(DtbschedmgrDeviceInfoStorageTest, ConnectSoftbusTest_001, TestSize.Level3)
{
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest ConnectSoftbusTest_001 start" << std::endl;
/**
* @tc.steps: step1. test ConnectSoftbus;
*/
bool result = DtbschedmgrDeviceInfoStorage::GetInstance().ConnectSoftbus();
EXPECT_TRUE(result);
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest ConnectSoftbusTest_001 end" << std::endl;
}
/**
* @tc.name: InitNetworkIdManagerTest_001
* @tc.desc: test InitNetworkIdManager
* @tc.type: FUNC
*/
HWTEST_F(DtbschedmgrDeviceInfoStorageTest, InitNetworkIdManagerTest_001, TestSize.Level3)
{
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest InitNetworkIdManagerTest_001 start" << std::endl;
std::shared_ptr<DnetworkAdapter> dnetworkAdapter = DnetworkAdapter::GetInstance();
DtbschedmgrDeviceInfoStorage::GetInstance().networkIdMgrHandler_ = nullptr;
/**
* @tc.steps: step1. test InitNetworkIdManager when networkIdMgrHandler_ is nullptr;
*/
bool result = DtbschedmgrDeviceInfoStorage::GetInstance().InitNetworkIdManager(dnetworkAdapter);
EXPECT_TRUE(result);
/**
* @tc.steps: step2. test InitNetworkIdManager when networkIdMgrHandler_ is not nullptr;
*/
auto runner = AppExecFwk::EventRunner::Create("DmsNetworkIdManager");
DtbschedmgrDeviceInfoStorage::GetInstance().networkIdMgrHandler_ =
std::make_shared<AppExecFwk::EventHandler>(runner);
result = DtbschedmgrDeviceInfoStorage::GetInstance().InitNetworkIdManager(dnetworkAdapter);
EXPECT_TRUE(result);
/**
* @tc.steps: step3. test Stop when deviceNodeListener_ is nullptr;
*/
DtbschedmgrDeviceInfoStorage::GetInstance().deviceNodeListener_ = nullptr;
DtbschedmgrDeviceInfoStorage::GetInstance().Stop();
/**
* @tc.steps: step4. test Stop when deviceNodeListener_ is not nullptr;
*/
DtbschedmgrDeviceInfoStorage::GetInstance().deviceNodeListener_ = std::make_shared<DistributedDeviceNodeListener>();
DtbschedmgrDeviceInfoStorage::GetInstance().Stop();
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest InitNetworkIdManagerTest_001 end" << std::endl;
}
/**
* @tc.name: WaitForDnetworkReadyTest_001
* @tc.desc: test WaitForDnetworkReady
* @tc.type: FUNC
*/
HWTEST_F(DtbschedmgrDeviceInfoStorageTest, WaitForDnetworkReadyTest_001, TestSize.Level3)
{
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest WaitForDnetworkReadyTest_001 start" << std::endl;
/**
* @tc.steps: step1. test WaitForDnetworkReady;
*/
bool result = DtbschedmgrDeviceInfoStorage::GetInstance().WaitForDnetworkReady();
EXPECT_TRUE(result);
/**
* @tc.steps: step2. test RegisterUuidNetworkIdMap;
*/
std::string networkId = "";
DtbschedmgrDeviceInfoStorage::GetInstance().RegisterUuidNetworkIdMap(networkId);
/**
* @tc.steps: step3. test UnregisterUuidNetworkIdMap;
*/
DtbschedmgrDeviceInfoStorage::GetInstance().UnregisterUuidNetworkIdMap(networkId);
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest WaitForDnetworkReadyTest_001 end" << std::endl;
}
/**
* @tc.name: GetDeviceIdSetTest_001
* @tc.desc: test GetDeviceIdSet
* @tc.type: FUNC
*/
HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetDeviceIdSetTest_001, TestSize.Level3)
{
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetDeviceIdSetTest_001 start" << std::endl;
/**
* @tc.steps: step1. test GetDeviceIdSet;
*/
set<std::string> deviceIdSet;
DtbschedmgrDeviceInfoStorage::GetInstance().GetDeviceIdSet(deviceIdSet);
EXPECT_TRUE(deviceIdSet.empty());
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetDeviceIdSetTest_001 end" << std::endl;
}
/**
* @tc.name: GetLocalDeviceFromDnetTest_001
* @tc.desc: test GetLocalDeviceFromDnet
* @tc.type: FUNC
*/
HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetLocalDeviceFromDnetTest_001, TestSize.Level3)
{
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetLocalDeviceFromDnetTest_001 start" << std::endl;
std::string deviceId;
/**
* @tc.steps: step1. test GetLocalDeviceFromDnet;
*/
bool result = DtbschedmgrDeviceInfoStorage::GetInstance().GetLocalDeviceId(deviceId);
EXPECT_TRUE(result);
/**
* @tc.steps: step2. test DeviceOnlineNotify when devInfo is nullptr;
*/
std::shared_ptr<DmsDeviceInfo> devInfo = nullptr;
DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOnlineNotify(devInfo);
/**
* @tc.steps: step3. test DeviceOnlineNotify when networkIdMgrHandler_ is nullptr;
*/
deviceId = "invalid deviceId for DeviceOnlineNotify";
std::string deviceName = "invalid deviceName for DeviceOnlineNotify";
int32_t deviceType = 0;
devInfo = make_shared<DmsDeviceInfo>(deviceName, deviceType, deviceId);
DtbschedmgrDeviceInfoStorage::GetInstance().networkIdMgrHandler_ = nullptr;
DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOnlineNotify(devInfo);
/**
* @tc.steps: step4. test DeviceOnlineNotify when listener_ is nullptr;
*/
auto runner = AppExecFwk::EventRunner::Create("DmsNetworkIdManager");
DtbschedmgrDeviceInfoStorage::GetInstance().networkIdMgrHandler_ =
std::make_shared<AppExecFwk::EventHandler>(runner);
DtbschedmgrDeviceInfoStorage::GetInstance().listener_ = nullptr;
DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOnlineNotify(devInfo);
/**
* @tc.steps: step5. test DeviceOnlineNotify when listener_ is not nullptr;
*/
DtbschedmgrDeviceInfoStorage::GetInstance().listener_ = new MockDmsNotifier();
DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOnlineNotify(devInfo);
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetLocalDeviceFromDnetTest_001 end" << std::endl;
}
/**
* @tc.name: ClearAllDevicesTest_001
* @tc.desc: test ClearAllDevices
* @tc.type: FUNC
*/
HWTEST_F(DtbschedmgrDeviceInfoStorageTest, ClearAllDevicesTest_001, TestSize.Level3)
{
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest ClearAllDevicesTest_001 start" << std::endl;
/**
* @tc.steps: step1. test ClearAllDevices;
*/
DtbschedmgrDeviceInfoStorage::GetInstance().ClearAllDevices();
{
lock_guard<mutex> autoLock(DtbschedmgrDeviceInfoStorage::GetInstance().deviceLock_);
EXPECT_TRUE(DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_.empty());
}
/**
* @tc.steps: step2. test DeviceOfflineNotify when deviceId is empty;
*/
std::string deviceId;
DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOfflineNotify(deviceId);
/**
* @tc.steps: step3. test DeviceOfflineNotify when networkIdMgrHandler_ is nullptr;
*/
deviceId = "invalid deviceId for DeviceOnlineNotify";
DtbschedmgrDeviceInfoStorage::GetInstance().networkIdMgrHandler_ = nullptr;
DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOfflineNotify(deviceId);
/**
* @tc.steps: step4. test DeviceOfflineNotify when listener_ is nullptr;
*/
auto runner = AppExecFwk::EventRunner::Create("DmsNetworkIdManager");
DtbschedmgrDeviceInfoStorage::GetInstance().networkIdMgrHandler_ =
std::make_shared<AppExecFwk::EventHandler>(runner);
DtbschedmgrDeviceInfoStorage::GetInstance().listener_ = nullptr;
DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOfflineNotify(deviceId);
/**
* @tc.steps: step5. test DeviceOfflineNotify when listener_ is not nullptr;
*/
DtbschedmgrDeviceInfoStorage::GetInstance().listener_ = new MockDmsNotifier();
DtbschedmgrDeviceInfoStorage::GetInstance().DeviceOfflineNotify(deviceId);
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest ClearAllDevicesTest_001 end" << std::endl;
}
/**
* @tc.name: GetDeviceInfoByIdTest_001
* @tc.desc: test GetDeviceInfoById
* @tc.type: FUNC
*/
HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetDeviceInfoByIdTest_001, TestSize.Level3)
{
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetDeviceInfoByIdTest_001 start" << std::endl;
/**
* @tc.steps: step1. test GetDeviceInfoById when deviceId is not in map;
*/
std::string deviceId = "invalid deviceId for GetDeviceInfoById";
{
lock_guard<mutex> autoLock(DtbschedmgrDeviceInfoStorage::GetInstance().deviceLock_);
DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_.clear();
}
std::shared_ptr<DmsDeviceInfo> dmsDeviceInfo =
DtbschedmgrDeviceInfoStorage::GetInstance().GetDeviceInfoById(deviceId);
EXPECT_EQ(dmsDeviceInfo, nullptr);
/**
* @tc.steps: step2. test GetDeviceInfoById when deviceId is in map;
*/
{
lock_guard<mutex> autoLock(DtbschedmgrDeviceInfoStorage::GetInstance().deviceLock_);
std::string deviceName = "invalid deviceName for GetDeviceInfoById";
int32_t deviceType = 0;
DtbschedmgrDeviceInfoStorage::GetInstance().remoteDevices_[deviceId] =
make_shared<DmsDeviceInfo>(deviceName, deviceType, deviceId);
}
dmsDeviceInfo = DtbschedmgrDeviceInfoStorage::GetInstance().GetDeviceInfoById(deviceId);
EXPECT_NE(dmsDeviceInfo, nullptr);
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetDeviceInfoByIdTest_001 end" << std::endl;
}
/**
* @tc.name: GetUuidByNetworkIdTest_001
* @tc.desc: test GetUuidByNetworkId
* @tc.type: FUNC
*/
HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetUuidByNetworkIdTest_001, TestSize.Level3)
{
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetUuidByNetworkIdTest_001 start" << std::endl;
/**
* @tc.steps: step1. test GetUuidByNetworkId when networkId is empty;
*/
std::string networkId;
std::string result = DtbschedmgrDeviceInfoStorage::GetInstance().GetUuidByNetworkId(networkId);
EXPECT_TRUE(result.empty());
/**
* @tc.steps: step2. test GetUuidByNetworkId when networkId is not in map;
*/
networkId = "invalid networkId for GetUuidByNetworkId";
result = DtbschedmgrDeviceInfoStorage::GetInstance().GetUuidByNetworkId(networkId);
EXPECT_TRUE(result.empty());
/**
* @tc.steps: step3. test GetUuidByNetworkId when networkId is in map;
*/
std::string uuid = "invalid uuid for GetUuidByNetworkId";
{
lock_guard<mutex> autoLock(DtbschedmgrDeviceInfoStorage::GetInstance().uuidNetworkIdLock_);
DtbschedmgrDeviceInfoStorage::GetInstance().uuidNetworkIdMap_[uuid] = networkId;
}
result = DtbschedmgrDeviceInfoStorage::GetInstance().GetUuidByNetworkId(networkId);
EXPECT_EQ(result, uuid);
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetUuidByNetworkIdTest_001 end" << std::endl;
}
/**
* @tc.name: GetNetworkIdByUuidTest_001
* @tc.desc: test GetNetworkIdByUuid
* @tc.type: FUNC
*/
HWTEST_F(DtbschedmgrDeviceInfoStorageTest, GetNetworkIdByUuidTest_001, TestSize.Level3)
{
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetNetworkIdByUuidTest_001 start" << std::endl;
/**
* @tc.steps: step1. test GetNetworkIdByUuid when uuid is null;
*/
std::string uuid;
std::string result = DtbschedmgrDeviceInfoStorage::GetInstance().GetNetworkIdByUuid(uuid);
EXPECT_TRUE(result.empty());
/**
* @tc.steps: step2. test GetNetworkIdByUuid when uuid is invalid;
*/
uuid = "invalid uuid for GetNetworkIdByUuid";
result = DtbschedmgrDeviceInfoStorage::GetInstance().GetNetworkIdByUuid(uuid);
EXPECT_TRUE(result.empty());
/**
* @tc.steps: step3. test GetNetworkIdByUuid;
*/
std::string networkId = "invalid networkId for GetNetworkIdByUuid";
{
std::lock_guard<std::mutex> autoLock(DtbschedmgrDeviceInfoStorage::GetInstance().uuidNetworkIdLock_);
DtbschedmgrDeviceInfoStorage::GetInstance().uuidNetworkIdMap_[uuid] = networkId;
}
result = DtbschedmgrDeviceInfoStorage::GetInstance().GetNetworkIdByUuid(uuid);
EXPECT_EQ(result, networkId);
/**
* @tc.steps: step4. test OnDeviceInfoChanged;
*/
std::string deviceId = "invalid deviceId for OnDeviceInfoChanged";
DtbschedmgrDeviceInfoStorage::GetInstance().OnDeviceInfoChanged(deviceId);
/**
* @tc.steps: step5. test OnRemoteDied;
*/
wptr<IRemoteObject> remote = nullptr;
sptr<DnetServiceDeathRecipient> dnetServiceDeathRecipient = new DnetServiceDeathRecipient();
dnetServiceDeathRecipient->OnRemoteDied(remote);
DTEST_LOG << "DtbschedmgrDeviceInfoStorageTest GetNetworkIdByUuidTest_001 end" << std::endl;
}
} // namespace DistributedSchedule
} // namespace OHOS

36
services/base/test/unittest/dtbschedmgr_device_info_storage_test.h Normal file
View File

@ -0,0 +1,36 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef OHOS_DMSFWK_BASE_DTBSCHEDMGR_DEVICE_INFO_STORAGE_TEST_H
#define OHOS_DMSFWK_BASE_DTBSCHEDMGR_DEVICE_INFO_STORAGE_TEST_H
#include "gtest/gtest.h"
#define private public
#include "dtbschedmgr_device_info_storage.h"
#undef private
namespace OHOS {
namespace DistributedSchedule {
class DtbschedmgrDeviceInfoStorageTest : public testing::Test {
public:
static void SetUpTestCase();
static void TearDownTestCase();
void SetUp();
void TearDown();
};
} // namespace DistributedSchedule
} // namespace OHOS
#endif // OHOS_DMSFWK_BASE_DTBSCHEDMGR_DEVICE_INFO_STORAGE_TEST_H

3
services/dtbschedmgr/BUILD.gn
View File

@ -23,8 +23,9 @@ group("unittest") {
config("distributed_sched_config") {
visibility = [ ":*" ]
include_dirs = [ "include" ]
defines = []
if (dmsfwk_mission_manager) {
defines = [ "SUPPORT_DISTRIBUTED_MISSION_MANAGER" ]
defines += [ "SUPPORT_DISTRIBUTED_MISSION_MANAGER" ]
}
if (dmsfwk_report_memmgr || dmsfwk_report_memmgr_plugins) {
defines += [ "SUPPORT_DISTRIBUTEDCOMPONENT_TO_MEMMGR" ]