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 "resource_manager_test.h"
17 
18 #include <cerrno>
19 #include <sys/stat.h>
20 #include <sys/types.h>
21 #include <vector>
22 
23 #include "constants.h"
24 #include "capability_info.h"
25 #include "capability_info_manager.h"
26 #include "local_capability_info_manager.h"
27 #include "meta_capability_info.h"
28 #include "meta_info_manager.h"
29 #include "dh_context.h"
30 #include "distributed_hardware_errno.h"
31 #include "distributed_hardware_log.h"
32 #include "cJSON.h"
33 
34 using namespace testing::ext;
35 using namespace std;
36 
37 namespace OHOS {
38 namespace DistributedHardware {
39 #undef DH_LOG_TAG
40 #define DH_LOG_TAG "ResourceManagerTest"
41 
42 namespace {
43 const string DATABASE_DIR = "/data/service/el1/public/database/dtbhardware_manager_service/";
44 const string DEV_ID_0 = "bb536a637105409e904d4da83790a4a7";
45 const string DEV_ID_1 = "bb536a637105409e904d4da83790a4a8";
46 const string TEST_DEV_NAME = "Dev1";
47 const string DH_ID_0 = "Camera_0";
48 const string DH_ID_1 = "Mic_0";
49 const string DH_ID_2 = "Gps_0";
50 const string DH_ID_3 = "Display_0";
51 const string DH_ID_4 = "Input_0";
52 const string DH_ATTR_0 = "attr0";
53 const string DH_ATTR_1 = "attr1";
54 const string DH_SUBTYPE_0 = "camera";
55 const string DH_SUBTYPE_1 = "mic";
56 const string DH_SUBTYPE_2 = "gps";
57 const string DH_SUBTYPE_3 = "screen";
58 const string DH_SUBTYPE_4 = "input";
59 constexpr uint16_t TEST_DEV_TYPE_PAD = 0x11;
60 constexpr uint32_t TEST_DH_TYPE_CAMERA = 0x01;
61 constexpr uint32_t TEST_DH_TYPE_MIC = 0x02;
62 constexpr uint32_t TEST_DH_TYPE_GPS = 0x10;
63 constexpr uint32_t TEST_DH_TYPE_DISPLAY = 0x08;
64 constexpr uint32_t TEST_DH_TYPE_BUTTON = 0x20;
65 constexpr uint32_t TEST_SIZE_0 = 0;
66 constexpr uint32_t TEST_SIZE_2 = 2;
67 constexpr uint32_t TEST_SIZE_5 = 5;
68 constexpr uint32_t TEST_SIZE_10 = 10;
69 const std::string EMPTY_PREFIX = "";
70 
71 const shared_ptr<CapabilityInfo> CAP_INFO_0 =
72     make_shared<CapabilityInfo>(DH_ID_0, DEV_ID_0, TEST_DEV_NAME, TEST_DEV_TYPE_PAD, DHType::CAMERA, DH_ATTR_0,
73     DH_SUBTYPE_0);
74 const shared_ptr<CapabilityInfo> CAP_INFO_1 =
75     make_shared<CapabilityInfo>(DH_ID_1, DEV_ID_0, TEST_DEV_NAME, TEST_DEV_TYPE_PAD, DHType::AUDIO, DH_ATTR_0,
76     DH_SUBTYPE_1);
77 const shared_ptr<CapabilityInfo> CAP_INFO_2 =
78     make_shared<CapabilityInfo>(DH_ID_2, DEV_ID_0, TEST_DEV_NAME, TEST_DEV_TYPE_PAD, DHType::GPS, DH_ATTR_0,
79     DH_SUBTYPE_2);
80 const shared_ptr<CapabilityInfo> CAP_INFO_3 =
81     make_shared<CapabilityInfo>(DH_ID_3, DEV_ID_0, TEST_DEV_NAME, TEST_DEV_TYPE_PAD, DHType::SCREEN, DH_ATTR_0,
82     DH_SUBTYPE_3);
83 const shared_ptr<CapabilityInfo> CAP_INFO_4 =
84     make_shared<CapabilityInfo>(DH_ID_4, DEV_ID_0, TEST_DEV_NAME, TEST_DEV_TYPE_PAD, DHType::INPUT, DH_ATTR_0,
85     DH_SUBTYPE_4);
86 
87 const shared_ptr<CapabilityInfo> CAP_INFO_5 =
88     make_shared<CapabilityInfo>(DH_ID_0, DEV_ID_1, TEST_DEV_NAME, TEST_DEV_TYPE_PAD, DHType::CAMERA, DH_ATTR_1,
89     DH_SUBTYPE_0);
90 const shared_ptr<CapabilityInfo> CAP_INFO_6 =
91     make_shared<CapabilityInfo>(DH_ID_1, DEV_ID_1, TEST_DEV_NAME, TEST_DEV_TYPE_PAD, DHType::AUDIO, DH_ATTR_1,
92     DH_SUBTYPE_1);
93 const shared_ptr<CapabilityInfo> CAP_INFO_7 =
94     make_shared<CapabilityInfo>(DH_ID_2, DEV_ID_1, TEST_DEV_NAME, TEST_DEV_TYPE_PAD, DHType::GPS, DH_ATTR_1,
95     DH_SUBTYPE_2);
96 const shared_ptr<CapabilityInfo> CAP_INFO_8 =
97     make_shared<CapabilityInfo>(DH_ID_3, DEV_ID_1, TEST_DEV_NAME, TEST_DEV_TYPE_PAD, DHType::SCREEN, DH_ATTR_1,
98     DH_SUBTYPE_3);
99 const shared_ptr<CapabilityInfo> CAP_INFO_9 =
100     make_shared<CapabilityInfo>(DH_ID_4, DEV_ID_1, TEST_DEV_NAME, TEST_DEV_TYPE_PAD, DHType::INPUT, DH_ATTR_1,
101     DH_SUBTYPE_4);
102 }
103 
SetUpTestCase(void)104 void ResourceManagerTest::SetUpTestCase(void)
105 {
106     auto ret = mkdir(DATABASE_DIR.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
107     if (ret != 0) {
108         DHLOGE("mkdir failed, path: %{public}s, errno : %{public}d", DATABASE_DIR.c_str(), errno);
109     }
110 }
111 
TearDownTestCase(void)112 void ResourceManagerTest::TearDownTestCase(void)
113 {
114     auto ret = remove(DATABASE_DIR.c_str());
115     if (ret != 0) {
116         DHLOGE("remove dir failed, path: %{public}s, errno : %{public}d", DATABASE_DIR.c_str(), errno);
117     }
118 }
119 
SetUp()120 void ResourceManagerTest::SetUp()
121 {
122     vector<shared_ptr<CapabilityInfo>> resInfos { CAP_INFO_0, CAP_INFO_1, CAP_INFO_2, CAP_INFO_3, CAP_INFO_4,
123         CAP_INFO_5, CAP_INFO_6, CAP_INFO_7, CAP_INFO_8, CAP_INFO_9 };
124     CapabilityInfoManager::GetInstance()->AddCapability(resInfos);
125 }
126 
TearDown()127 void ResourceManagerTest::TearDown()
128 {
129     CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_0->GetKey());
130     CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_1->GetKey());
131     CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_2->GetKey());
132     CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_3->GetKey());
133     CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_4->GetKey());
134     CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_5->GetKey());
135     CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_6->GetKey());
136     CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_7->GetKey());
137     CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_8->GetKey());
138     CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_9->GetKey());
139 }
140 
141 /**
142  * @tc.name: resource_manager_test_001
143  * @tc.desc: Verify the CapabilityInfoManager UnInit function.
144  * @tc.type: FUNC
145  * @tc.require: AR000GHSJE
146  */
147 HWTEST_F(ResourceManagerTest, resource_manager_test_001, TestSize.Level0)
148 {
149     EXPECT_EQ(CapabilityInfoManager::GetInstance()->Init(), DH_FWK_SUCCESS);
150     EXPECT_EQ(CapabilityInfoManager::GetInstance()->UnInit(), DH_FWK_SUCCESS);
151 }
152 
153 /**
154  * @tc.name: resource_manager_test_002
155  * @tc.desc: Verify the CapabilityInfoManager Init function.
156  * @tc.type: FUNC
157  * @tc.require: AR000GHSCV
158  */
159 HWTEST_F(ResourceManagerTest, resource_manager_test_002, TestSize.Level0)
160 {
161     EXPECT_EQ(CapabilityInfoManager::GetInstance()->Init(), DH_FWK_SUCCESS);
162 }
163 
164 /**
165  * @tc.name: resource_manager_test_003
166  * @tc.desc: Verify the CapabilityInfoManager SyncDeviceInfoFromDB function.
167  * @tc.type: FUNC
168  * @tc.require: AR000GHSJE
169  */
170 HWTEST_F(ResourceManagerTest, resource_manager_test_003, TestSize.Level0)
171 {
172     CapabilityInfoManager::GetInstance()->globalCapInfoMap_.clear();
173     EXPECT_EQ(CapabilityInfoManager::GetInstance()->SyncDeviceInfoFromDB(DEV_ID_0), DH_FWK_SUCCESS);
174     EXPECT_EQ(CapabilityInfoManager::GetInstance()->globalCapInfoMap_.size(), TEST_SIZE_5);
175     EXPECT_EQ(CapabilityInfoManager::GetInstance()->SyncDeviceInfoFromDB(DEV_ID_1), DH_FWK_SUCCESS);
176     EXPECT_EQ(CapabilityInfoManager::GetInstance()->globalCapInfoMap_.size(), TEST_SIZE_10);
177 }
178 
179 /**
180  * @tc.name: resource_manager_test_004
181  * @tc.desc: Verify the CapabilityInfoManager SyncRemoteCapabilityInfos function.
182  * @tc.type: FUNC
183  * @tc.require: AR000GHSJE
184  */
185 HWTEST_F(ResourceManagerTest, resource_manager_test_004, TestSize.Level0)
186 {
187     CapabilityInfoManager::GetInstance()->globalCapInfoMap_.clear();
188     EXPECT_EQ(CapabilityInfoManager::GetInstance()->SyncRemoteCapabilityInfos(), DH_FWK_SUCCESS);
189 }
190 
191 /**
192  * @tc.name: resource_manager_test_005
193  * @tc.desc: Verify the CapabilityInfoManager AddCapability function.
194  * @tc.type: FUNC
195  * @tc.require: AR000GHSCV
196  */
197 HWTEST_F(ResourceManagerTest, resource_manager_test_005, TestSize.Level0)
198 {
199     vector<shared_ptr<CapabilityInfo>> resInfos { CAP_INFO_0, CAP_INFO_1, CAP_INFO_2, CAP_INFO_3, CAP_INFO_4,
200         CAP_INFO_5, CAP_INFO_6, CAP_INFO_7, CAP_INFO_8, CAP_INFO_9 };
201     EXPECT_EQ(CapabilityInfoManager::GetInstance()->AddCapability(resInfos), DH_FWK_SUCCESS);
202     EXPECT_EQ(CapabilityInfoManager::GetInstance()->globalCapInfoMap_.size(), TEST_SIZE_10);
203 }
204 
205 /**
206  * @tc.name: resource_manager_test_006
207  * @tc.desc: Verify the CapabilityInfoManager AddCapabilityInMem function.
208  * @tc.type: FUNC
209  * @tc.require: AR000GHSCV
210  */
211 HWTEST_F(ResourceManagerTest, resource_manager_test_006, TestSize.Level0)
212 {
213     vector<shared_ptr<CapabilityInfo>> resInfos { CAP_INFO_0, CAP_INFO_1, CAP_INFO_2, CAP_INFO_3, CAP_INFO_4,
214         CAP_INFO_5, CAP_INFO_6, CAP_INFO_7, CAP_INFO_8, CAP_INFO_9 };
215     EXPECT_EQ(CapabilityInfoManager::GetInstance()->AddCapabilityInMem(resInfos), DH_FWK_SUCCESS);
216     EXPECT_EQ(CapabilityInfoManager::GetInstance()->globalCapInfoMap_.size(), TEST_SIZE_10);
217 }
218 
219 
220 /**
221  * @tc.name: resource_manager_test_007
222  * @tc.desc: Verify the CapabilityInfoManager RemoveCapabilityInfoByKey function.
223  * @tc.type: FUNC
224  * @tc.require: AR000GHSJE
225  */
226 HWTEST_F(ResourceManagerTest, resource_manager_test_007, TestSize.Level0)
227 {
228     EXPECT_EQ(CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_0->GetKey()), DH_FWK_SUCCESS);
229     EXPECT_EQ(CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_1->GetKey()), DH_FWK_SUCCESS);
230     EXPECT_EQ(CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_2->GetKey()), DH_FWK_SUCCESS);
231     EXPECT_EQ(CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_3->GetKey()), DH_FWK_SUCCESS);
232     EXPECT_EQ(CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_4->GetKey()), DH_FWK_SUCCESS);
233     EXPECT_EQ(CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_5->GetKey()), DH_FWK_SUCCESS);
234     EXPECT_EQ(CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_6->GetKey()), DH_FWK_SUCCESS);
235     EXPECT_EQ(CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_7->GetKey()), DH_FWK_SUCCESS);
236     EXPECT_EQ(CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_8->GetKey()), DH_FWK_SUCCESS);
237     EXPECT_EQ(CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(CAP_INFO_9->GetKey()), DH_FWK_SUCCESS);
238     EXPECT_EQ(CapabilityInfoManager::GetInstance()->globalCapInfoMap_.size(), TEST_SIZE_0);
239 }
240 
241 /**
242  * @tc.name: resource_manager_test_008
243  * @tc.desc: Verify the CapabilityInfoManager QueryCapabilityByFilters function.
244  * @tc.type: FUNC
245  * @tc.require: AR000GHSJE
246  */
247 HWTEST_F(ResourceManagerTest, resource_manager_test_008, TestSize.Level0)
248 {
249     map<CapabilityInfoFilter, string> queryMap0 { { CapabilityInfoFilter::FILTER_DEVICE_ID, DEV_ID_0 } };
250     map<CapabilityInfoFilter, string> queryMap1 { { CapabilityInfoFilter::FILTER_DEVICE_ID, DEV_ID_1 } };
251     map<CapabilityInfoFilter, string> queryMap2 { { CapabilityInfoFilter::FILTER_DEVICE_NAME, TEST_DEV_NAME } };
252     map<CapabilityInfoFilter, string> queryMap3 { { CapabilityInfoFilter::FILTER_DH_ID, DH_ID_0 } };
253     map<CapabilityInfoFilter, string> queryMap4 { { CapabilityInfoFilter::FILTER_DH_ID, DH_ID_1 } };
254     map<CapabilityInfoFilter, string> queryMap5 { { CapabilityInfoFilter::FILTER_DH_ID, DH_ID_2 } };
255     map<CapabilityInfoFilter, string> queryMap6 { { CapabilityInfoFilter::FILTER_DH_ID, DH_ID_3 } };
256     map<CapabilityInfoFilter, string> queryMap7 { { CapabilityInfoFilter::FILTER_DH_ID, DH_ID_4 } };
257     map<CapabilityInfoFilter, string> queryMap8 { { CapabilityInfoFilter::FILTER_DEVICE_TYPE,
258         to_string(TEST_DEV_TYPE_PAD) } };
259     map<CapabilityInfoFilter, string> queryMap9 { { CapabilityInfoFilter::FILTER_DH_TYPE,
260         to_string(TEST_DH_TYPE_CAMERA) } };
261     map<CapabilityInfoFilter, string> queryMap10 { { CapabilityInfoFilter::FILTER_DH_TYPE,
262         to_string(TEST_DH_TYPE_MIC) } };
263     map<CapabilityInfoFilter, string> queryMap11 { { CapabilityInfoFilter::FILTER_DH_TYPE,
264         to_string(TEST_DH_TYPE_GPS) } };
265     map<CapabilityInfoFilter, string> queryMap12 { { CapabilityInfoFilter::FILTER_DH_TYPE,
266         to_string(TEST_DH_TYPE_DISPLAY) } };
267     map<CapabilityInfoFilter, string> queryMap13 { { CapabilityInfoFilter::FILTER_DH_TYPE,
268         to_string(TEST_DH_TYPE_BUTTON) } };
269     EXPECT_EQ(CapabilityInfoManager::GetInstance()->QueryCapabilityByFilters(queryMap0).size(), TEST_SIZE_5);
270     EXPECT_EQ(CapabilityInfoManager::GetInstance()->QueryCapabilityByFilters(queryMap1).size(), TEST_SIZE_5);
271     EXPECT_EQ(CapabilityInfoManager::GetInstance()->QueryCapabilityByFilters(queryMap2).size(), TEST_SIZE_10);
272     EXPECT_EQ(CapabilityInfoManager::GetInstance()->QueryCapabilityByFilters(queryMap3).size(), TEST_SIZE_2);
273     EXPECT_EQ(CapabilityInfoManager::GetInstance()->QueryCapabilityByFilters(queryMap4).size(), TEST_SIZE_2);
274     EXPECT_EQ(CapabilityInfoManager::GetInstance()->QueryCapabilityByFilters(queryMap5).size(), TEST_SIZE_2);
275     EXPECT_EQ(CapabilityInfoManager::GetInstance()->QueryCapabilityByFilters(queryMap6).size(), TEST_SIZE_2);
276     EXPECT_EQ(CapabilityInfoManager::GetInstance()->QueryCapabilityByFilters(queryMap7).size(), TEST_SIZE_2);
277     EXPECT_EQ(CapabilityInfoManager::GetInstance()->QueryCapabilityByFilters(queryMap8).size(), TEST_SIZE_10);
278     EXPECT_EQ(CapabilityInfoManager::GetInstance()->QueryCapabilityByFilters(queryMap9).size(), TEST_SIZE_2);
279     EXPECT_EQ(CapabilityInfoManager::GetInstance()->QueryCapabilityByFilters(queryMap10).size(), TEST_SIZE_2);
280     EXPECT_EQ(CapabilityInfoManager::GetInstance()->QueryCapabilityByFilters(queryMap11).size(), TEST_SIZE_2);
281     EXPECT_EQ(CapabilityInfoManager::GetInstance()->QueryCapabilityByFilters(queryMap12).size(), TEST_SIZE_2);
282     EXPECT_EQ(CapabilityInfoManager::GetInstance()->QueryCapabilityByFilters(queryMap13).size(), TEST_SIZE_2);
283 }
284 
285 /**
286  * @tc.name: resource_manager_test_009
287  * @tc.desc: Verify the HasCapability function.
288  * @tc.type: FUNC
289  * @tc.require: AR000GHSCV
290  */
291 HWTEST_F(ResourceManagerTest, resource_manager_test_009, TestSize.Level0)
292 {
293     EXPECT_EQ(CapabilityInfoManager::GetInstance()->HasCapability(DEV_ID_0, DH_ID_0), true);
294     EXPECT_EQ(CapabilityInfoManager::GetInstance()->HasCapability(DEV_ID_0, DH_ID_1), true);
295     EXPECT_EQ(CapabilityInfoManager::GetInstance()->HasCapability(DEV_ID_0, DH_ID_2), true);
296     EXPECT_EQ(CapabilityInfoManager::GetInstance()->HasCapability(DEV_ID_0, DH_ID_3), true);
297     EXPECT_EQ(CapabilityInfoManager::GetInstance()->HasCapability(DEV_ID_0, DH_ID_4), true);
298     EXPECT_EQ(CapabilityInfoManager::GetInstance()->HasCapability(DEV_ID_1, DH_ID_0), true);
299     EXPECT_EQ(CapabilityInfoManager::GetInstance()->HasCapability(DEV_ID_1, DH_ID_1), true);
300     EXPECT_EQ(CapabilityInfoManager::GetInstance()->HasCapability(DEV_ID_1, DH_ID_2), true);
301     EXPECT_EQ(CapabilityInfoManager::GetInstance()->HasCapability(DEV_ID_1, DH_ID_3), true);
302     EXPECT_EQ(CapabilityInfoManager::GetInstance()->HasCapability(DEV_ID_1, DH_ID_4), true);
303 }
304 
305 /**
306  * @tc.name: resource_manager_test_010
307  * @tc.desc: Verify the GetCapabilitiesByDeviceId function.
308  * @tc.type: FUNC
309  * @tc.require: AR000GHSJE
310  */
311 HWTEST_F(ResourceManagerTest, resource_manager_test_010, TestSize.Level0)
312 {
313     vector<shared_ptr<CapabilityInfo>> capInfos;
314     CapabilityInfoManager::GetInstance()->GetCapabilitiesByDeviceId("", capInfos);
315     EXPECT_EQ(capInfos.empty(), true);
316     CapabilityInfoManager::GetInstance()->GetCapabilitiesByDeviceId(DEV_ID_0, capInfos);
317     EXPECT_EQ(capInfos.size(), TEST_SIZE_5);
318     CapabilityInfoManager::GetInstance()->GetCapabilitiesByDeviceId(DEV_ID_1, capInfos);
319     EXPECT_EQ(capInfos.size(), TEST_SIZE_10);
320 }
321 
322 /**
323  * @tc.name: resource_manager_test_011
324  * @tc.desc: Verify the GetCapability function.
325  * @tc.type: FUNC
326  * @tc.require: AR000GHSJE
327  */
328 HWTEST_F(ResourceManagerTest, resource_manager_test_011, TestSize.Level0)
329 {
330     shared_ptr<CapabilityInfo> capInfo;
331     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetCapability(DEV_ID_0, DH_ID_0, capInfo), DH_FWK_SUCCESS);
332     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetCapability(DEV_ID_0, DH_ID_1, capInfo), DH_FWK_SUCCESS);
333     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetCapability(DEV_ID_0, DH_ID_2, capInfo), DH_FWK_SUCCESS);
334     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetCapability(DEV_ID_0, DH_ID_3, capInfo), DH_FWK_SUCCESS);
335     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetCapability(DEV_ID_0, DH_ID_4, capInfo), DH_FWK_SUCCESS);
336     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetCapability(DEV_ID_1, DH_ID_0, capInfo), DH_FWK_SUCCESS);
337     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetCapability(DEV_ID_1, DH_ID_1, capInfo), DH_FWK_SUCCESS);
338     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetCapability(DEV_ID_1, DH_ID_2, capInfo), DH_FWK_SUCCESS);
339     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetCapability(DEV_ID_1, DH_ID_3, capInfo), DH_FWK_SUCCESS);
340     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetCapability(DEV_ID_1, DH_ID_4, capInfo), DH_FWK_SUCCESS);
341 }
342 
343 /**
344  * @tc.name: resource_manager_test_012
345  * @tc.desc: Verify the GetDataByKey function.
346  * @tc.type: FUNC
347  * @tc.require: AR000GHSJE
348  */
349 HWTEST_F(ResourceManagerTest, resource_manager_test_012, TestSize.Level0)
350 {
351     shared_ptr<CapabilityInfo> capInfo;
352     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKey(CAP_INFO_0->GetKey(), capInfo), DH_FWK_SUCCESS);
353     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKey(CAP_INFO_1->GetKey(), capInfo), DH_FWK_SUCCESS);
354     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKey(CAP_INFO_2->GetKey(), capInfo), DH_FWK_SUCCESS);
355     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKey(CAP_INFO_3->GetKey(), capInfo), DH_FWK_SUCCESS);
356     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKey(CAP_INFO_4->GetKey(), capInfo), DH_FWK_SUCCESS);
357     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKey(CAP_INFO_5->GetKey(), capInfo), DH_FWK_SUCCESS);
358     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKey(CAP_INFO_6->GetKey(), capInfo), DH_FWK_SUCCESS);
359     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKey(CAP_INFO_7->GetKey(), capInfo), DH_FWK_SUCCESS);
360     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKey(CAP_INFO_8->GetKey(), capInfo), DH_FWK_SUCCESS);
361     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKey(CAP_INFO_9->GetKey(), capInfo), DH_FWK_SUCCESS);
362 }
363 
364 /**
365  * @tc.name: resource_manager_test_013
366  * @tc.desc: Verify the GetDataByKeyPrefix function.
367  * @tc.type: FUNC
368  * @tc.require: AR000GHSJE
369  */
370 HWTEST_F(ResourceManagerTest, resource_manager_test_013, TestSize.Level0)
371 {
372     CapabilityInfoMap capMap;
373     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKeyPrefix(CAP_INFO_0->GetDeviceId(), capMap),
374         DH_FWK_SUCCESS);
375     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKeyPrefix(CAP_INFO_1->GetDeviceId(), capMap),
376         DH_FWK_SUCCESS);
377     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKeyPrefix(CAP_INFO_2->GetDeviceId(), capMap),
378         DH_FWK_SUCCESS);
379     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKeyPrefix(CAP_INFO_3->GetDeviceId(), capMap),
380         DH_FWK_SUCCESS);
381     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKeyPrefix(CAP_INFO_4->GetDeviceId(), capMap),
382         DH_FWK_SUCCESS);
383     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKeyPrefix(CAP_INFO_5->GetDeviceId(), capMap),
384         DH_FWK_SUCCESS);
385     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKeyPrefix(CAP_INFO_6->GetDeviceId(), capMap),
386         DH_FWK_SUCCESS);
387     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKeyPrefix(CAP_INFO_7->GetDeviceId(), capMap),
388         DH_FWK_SUCCESS);
389     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKeyPrefix(CAP_INFO_8->GetDeviceId(), capMap),
390         DH_FWK_SUCCESS);
391     EXPECT_EQ(CapabilityInfoManager::GetInstance()->GetDataByKeyPrefix(CAP_INFO_9->GetDeviceId(), capMap),
392         DH_FWK_SUCCESS);
393     EXPECT_EQ(capMap.size(), TEST_SIZE_10);
394 }
395 
396 /**
397  * @tc.name: resource_manager_test_014
398  * @tc.desc: Verify the RemoveCapabilityInfoInDB function.
399  * @tc.type: FUNC
400  * @tc.require: AR000GHSJE
401  */
402 HWTEST_F(ResourceManagerTest, resource_manager_test_014, TestSize.Level0)
403 {
404     std::string deviceIdEmpty = "";
405     int32_t ret = CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoInDB(deviceIdEmpty);
406     EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
407 }
408 
409 /**
410  * @tc.name: resource_manager_test_015
411  * @tc.desc: Verify the GetCapabilityByValue function.
412  * @tc.type: FUNC
413  * @tc.require: AR000GHSJE
414  */
415 HWTEST_F(ResourceManagerTest, resource_manager_test_015, TestSize.Level0)
416 {
417     std::string value = "";
418     std::shared_ptr<CapabilityInfo> capPtr = nullptr;
419     int32_t ret = GetCapabilityByValue<CapabilityInfo>(value, capPtr);
420     EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
421 
422     value = "invalid JSON string";
423     capPtr = nullptr;
424     ret = GetCapabilityByValue<CapabilityInfo>(value, capPtr);
425     EXPECT_EQ(ERR_DH_FWK_JSON_PARSE_FAILED, ret);
426 }
427 
428 /**
429  * @tc.name: resource_manager_test_016
430  * @tc.desc: Verify the GetCapabilityKey function.
431  * @tc.type: FUNC
432  * @tc.require: AR000GHSJE
433  */
434 HWTEST_F(ResourceManagerTest, resource_manager_test_016, TestSize.Level0)
435 {
436     std::string deviceId = "deviceIdtest";
437     std::string dhId = "dhIdtest";
438     std::string str = GetCapabilityKey(deviceId, dhId);
439     EXPECT_EQ("deviceIdtest###dhIdtest", str);
440 }
441 
442 /**
443  * @tc.name: resource_manager_test_017
444  * @tc.desc: Verify the IsCapKeyMatchDeviceId function.
445  * @tc.type: FUNC
446  * @tc.require: AR000GHSJE
447  */
448 HWTEST_F(ResourceManagerTest, resource_manager_test_017, TestSize.Level0)
449 {
450     std::string key = "keytest";
451     bool ret = IsCapKeyMatchDeviceId(key, DEV_ID_0);
452     EXPECT_EQ(false, ret);
453 }
454 
455 /**
456  * @tc.name: resource_manager_test_018
457  * @tc.desc: Verify the IsCapKeyMatchDeviceId function.
458  * @tc.type: FUNC
459  * @tc.require: AR000GHSJE
460  */
461 HWTEST_F(ResourceManagerTest, resource_manager_test_018, TestSize.Level0)
462 {
463     std::string key = "bb536a637105409e904d4da83790a4a7###keytest";
464     bool ret = IsCapKeyMatchDeviceId(key, DEV_ID_0);
465     EXPECT_EQ(true, ret);
466 }
467 
468 /**
469  * @tc.name: resource_manager_test_019
470  * @tc.desc: Verify the FromJsonString function.
471  * @tc.type: FUNC
472  * @tc.require: AR000GHSJE
473  */
474 HWTEST_F(ResourceManagerTest, resource_manager_test_019, TestSize.Level0)
475 {
476     CapabilityInfo capaInfo;
477     std::string jsonStr = "";
478     int32_t ret = capaInfo.FromJsonString(jsonStr);
479     EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
480 
481     jsonStr = "invalid JSON string";
482     ret = capaInfo.FromJsonString(jsonStr);
483     EXPECT_EQ(ERR_DH_FWK_JSON_PARSE_FAILED, ret);
484 }
485 
486 /**
487  * @tc.name: resource_manager_test_020
488  * @tc.desc: Verify the Compare function.
489  * @tc.type: FUNC
490  * @tc.require: AR000GHSJE
491  */
492 HWTEST_F(ResourceManagerTest, resource_manager_test_020, TestSize.Level0)
493 {
494     CapabilityInfo capaInfo(DH_ID_0, DEV_ID_0, TEST_DEV_NAME, TEST_DEV_TYPE_PAD, DHType::CAMERA,
495         DH_ATTR_0, DH_SUBTYPE_0);
496     bool ret = CAP_INFO_1->Compare(capaInfo);
497     EXPECT_EQ(false, ret);
498 }
499 
500 /**
501  * @tc.name: OnChange_001
502  * @tc.desc: Verify the OnChange function
503  * @tc.type: FUNC
504  * @tc.require: AR000GHSJE
505  */
506 HWTEST_F(ResourceManagerTest, OnChange_001, TestSize.Level0)
507 {
508     DistributedKv::Entry insert, update, del;
509     insert.key = "strBase";
510     update.key = "strBase";
511     del.key = "strBase";
512     insert.value = "strBase";
513     update.value = "strBase";
514     del.value = "strBase";
515     std::vector<DistributedKv::Entry> inserts, updates, deleteds;
516     inserts.push_back(insert);
517     updates.push_back(update);
518     deleteds.push_back(del);
519 
520     DistributedKv::ChangeNotification changeIn(std::move(inserts), std::move(updates), std::move(deleteds), "", true);
521 
522     CapabilityInfoManager::GetInstance()->OnChange(changeIn);
523     EXPECT_NE(nullptr, CapabilityInfoManager::GetInstance()->dbAdapterPtr_);
524 }
525 
526 /**
527  * @tc.name: OnChange_002
528  * @tc.desc: Verify the OnChange function
529  * @tc.type: FUNC
530  * @tc.require: AR000GHSJE
531  */
532 HWTEST_F(ResourceManagerTest, OnChange_002, TestSize.Level0)
533 {
534     DistributedKv::DataOrigin origin;
535     origin.id = {};
536     origin.store = "";
537     CapabilityInfoManager::Keys keys;
538     keys[CapabilityInfoManager::OP_INSERT] = {"strBase"};
539     keys[CapabilityInfoManager::OP_UPDATE] = {"strBase"};
540     keys[CapabilityInfoManager::OP_DELETE] = {"strBase"};
541     CapabilityInfoManager::GetInstance()->OnChange(origin, std::move(keys));
542     EXPECT_NE(nullptr, CapabilityInfoManager::GetInstance()->dbAdapterPtr_);
543 }
544 
545 /**
546  * @tc.name: HandleCapabilityAddChange_001
547  * @tc.desc: Verify the HandleCapabilityAddChange function
548  * @tc.type: FUNC
549  * @tc.require: AR000GHSJM
550  */
551 HWTEST_F(ResourceManagerTest, HandleCapabilityAddChange_001, TestSize.Level0)
552 {
553     std::vector<DistributedKv::Entry> insertRecords;
554     DistributedKv::Entry entry;
555     entry.key = "strBase";
556     entry.value = "strBase";
557     insertRecords.push_back(entry);
558     CapabilityInfoManager::GetInstance()->HandleCapabilityAddChange(insertRecords);
559     EXPECT_NE(nullptr, CapabilityInfoManager::GetInstance()->dbAdapterPtr_);
560 }
561 
562 /**
563  * @tc.name: HandleCapabilityUpdateChange_001
564  * @tc.desc: Verify the HandleCapabilityUpdateChange function
565  * @tc.type: FUNC
566  * @tc.require: AR000GHSJM
567  */
568 HWTEST_F(ResourceManagerTest, HandleCapabilityUpdateChange_001, TestSize.Level0)
569 {
570     std::vector<DistributedKv::Entry> updateRecords;
571     DistributedKv::Entry entry;
572     entry.key = "strBase";
573     entry.value = "strBase";
574     updateRecords.push_back(entry);
575     CapabilityInfoManager::GetInstance()->HandleCapabilityUpdateChange(updateRecords);
576     EXPECT_NE(nullptr, CapabilityInfoManager::GetInstance()->dbAdapterPtr_);
577 }
578 
579 /**
580  * @tc.name: IsCapabilityMatchFilter_001
581  * @tc.desc: Verify the IsCapabilityMatchFilter function
582  * @tc.type: FUNC
583  * @tc.require: AR000GHSJM
584  */
585 HWTEST_F(ResourceManagerTest, IsCapabilityMatchFilter_001, TestSize.Level0)
586 {
587     std::shared_ptr<CapabilityInfo> cap = nullptr;
588     CapabilityInfoFilter filter = CapabilityInfoFilter::FILTER_DH_ID;
589     std::string value;
590     bool ret = CapabilityInfoManager::GetInstance()->IsCapabilityMatchFilter(cap, filter, value);
591     EXPECT_EQ(false, ret);
592 }
593 
594 /**
595  * @tc.name: IsCapabilityMatchFilter_002
596  * @tc.desc: Verify the IsCapabilityMatchFilter function
597  * @tc.type: FUNC
598  * @tc.require: AR000GHSJM
599  */
600 HWTEST_F(ResourceManagerTest, IsCapabilityMatchFilter_002, TestSize.Level0)
601 {
602     std::shared_ptr<CapabilityInfo> cap = std::make_shared<CapabilityInfo>("", "", "", 0, DHType::UNKNOWN, "", "");
603     CapabilityInfoFilter filter = CapabilityInfoFilter::FILTER_DH_ID;
604     std::string value;
605     bool ret = CapabilityInfoManager::GetInstance()->IsCapabilityMatchFilter(cap, filter, value);
606     EXPECT_EQ(true, ret);
607 }
608 
609 /**
610  * @tc.name: IsCapabilityMatchFilter_003
611  * @tc.desc: Verify the IsCapabilityMatchFilter function
612  * @tc.type: FUNC
613  * @tc.require: AR000GHSJM
614  */
615 HWTEST_F(ResourceManagerTest, IsCapabilityMatchFilter_003, TestSize.Level0)
616 {
617     std::shared_ptr<CapabilityInfo> cap = std::make_shared<CapabilityInfo>("", "", "", 0, DHType::UNKNOWN, "", "");
618     CapabilityInfoFilter filter = CapabilityInfoFilter::FILTER_DEVICE_ID;
619     std::string value;
620     bool ret = CapabilityInfoManager::GetInstance()->IsCapabilityMatchFilter(cap, filter, value);
621     EXPECT_EQ(true, ret);
622 }
623 
624 /**
625  * @tc.name: IsCapabilityMatchFilter_004
626  * @tc.desc: Verify the IsCapabilityMatchFilter function
627  * @tc.type: FUNC
628  * @tc.require: AR000GHSJM
629  */
630 HWTEST_F(ResourceManagerTest, IsCapabilityMatchFilter_004, TestSize.Level0)
631 {
632     std::shared_ptr<CapabilityInfo> cap = std::make_shared<CapabilityInfo>("", "", "", 0, DHType::UNKNOWN, "", "");
633     CapabilityInfoFilter filter = CapabilityInfoFilter::FILTER_DEVICE_NAME;
634     std::string value;
635     bool ret = CapabilityInfoManager::GetInstance()->IsCapabilityMatchFilter(cap, filter, value);
636     EXPECT_EQ(true, ret);
637 }
638 
639 /**
640  * @tc.name: IsCapabilityMatchFilter_005
641  * @tc.desc: Verify the IsCapabilityMatchFilter function
642  * @tc.type: FUNC
643  * @tc.require: AR000GHSJM
644  */
645 HWTEST_F(ResourceManagerTest, IsCapabilityMatchFilter_005, TestSize.Level0)
646 {
647     std::shared_ptr<CapabilityInfo> cap = std::make_shared<CapabilityInfo>("", "", "", 0, DHType::UNKNOWN, "", "");
648     CapabilityInfoFilter filter = CapabilityInfoFilter::FILTER_DEVICE_TYPE;
649     uint16_t devType = 123;
650     std::string value = std::to_string(devType);
651     bool ret = CapabilityInfoManager::GetInstance()->IsCapabilityMatchFilter(cap, filter, value);
652     EXPECT_EQ(false, ret);
653 }
654 
655 /**
656  * @tc.name: IsCapabilityMatchFilter_006
657  * @tc.desc: Verify the IsCapabilityMatchFilter function
658  * @tc.type: FUNC
659  * @tc.require: AR000GHSJM
660  */
661 HWTEST_F(ResourceManagerTest, IsCapabilityMatchFilter_006, TestSize.Level0)
662 {
663     std::shared_ptr<CapabilityInfo> cap = std::make_shared<CapabilityInfo>("", "", "", 0, DHType::UNKNOWN, "", "");
664     CapabilityInfoFilter filter = CapabilityInfoFilter::FILTER_DH_TYPE;
665     DHType dhType = DHType::AUDIO;
666     std::string value = std::to_string(static_cast<uint32_t>(dhType));
667     bool ret = CapabilityInfoManager::GetInstance()->IsCapabilityMatchFilter(cap, filter, value);
668     EXPECT_EQ(false, ret);
669 }
670 
671 /**
672  * @tc.name: IsCapabilityMatchFilter_007
673  * @tc.desc: Verify the IsCapabilityMatchFilter function
674  * @tc.type: FUNC
675  * @tc.require: AR000GHSJM
676  */
677 HWTEST_F(ResourceManagerTest, IsCapabilityMatchFilter_007, TestSize.Level0)
678 {
679     std::shared_ptr<CapabilityInfo> cap = std::make_shared<CapabilityInfo>("", "", "", 0, DHType::UNKNOWN, "", "");
680     CapabilityInfoFilter filter = CapabilityInfoFilter::FILTER_DH_ATTRS;
681     std::string value;
682     bool ret = CapabilityInfoManager::GetInstance()->IsCapabilityMatchFilter(cap, filter, value);
683     EXPECT_EQ(true, ret);
684 }
685 
686 /**
687  * @tc.name: IsCapabilityMatchFilter_008
688  * @tc.desc: Verify the IsCapabilityMatchFilter function
689  * @tc.type: FUNC
690  * @tc.require: AR000GHSJM
691  */
692 HWTEST_F(ResourceManagerTest, IsCapabilityMatchFilter_008, TestSize.Level0)
693 {
694     std::shared_ptr<CapabilityInfo> cap = std::make_shared<CapabilityInfo>("", "", "", 0, DHType::UNKNOWN, "", "");
695     uint32_t invalid = 6;
696     CapabilityInfoFilter filter = static_cast<CapabilityInfoFilter>(invalid);
697     std::string value;
698     bool ret = CapabilityInfoManager::GetInstance()->IsCapabilityMatchFilter(cap, filter, value);
699     EXPECT_EQ(false, ret);
700 }
701 
702 /**
703  * @tc.name: GetCapabilitiesByDeviceId_001
704  * @tc.desc: Verify the GetCapabilitiesByDeviceId function
705  * @tc.type: FUNC
706  * @tc.require: AR000GHSJM
707  */
708 HWTEST_F(ResourceManagerTest, GetCapabilitiesByDeviceId_001, TestSize.Level0)
709 {
710     std::string deviceId;
711     std::vector<std::shared_ptr<CapabilityInfo>> resInfos;
712     CapabilityInfoManager::GetInstance()->GetCapabilitiesByDeviceId(deviceId, resInfos);
713     EXPECT_NE(nullptr, CapabilityInfoManager::GetInstance()->dbAdapterPtr_);
714 }
715 
716 /**
717  * @tc.name: HasCapability_001
718  * @tc.desc: Verify the HasCapability function
719  * @tc.type: FUNC
720  * @tc.require: AR000GHSJM
721  */
722 HWTEST_F(ResourceManagerTest, HasCapability_001, TestSize.Level0)
723 {
724     std::string deviceId;
725     std::string dhId;
726     bool ret = CapabilityInfoManager::GetInstance()->HasCapability(deviceId, dhId);
727     EXPECT_EQ(false, ret);
728 }
729 
730 /**
731  * @tc.name: SyncRemoteCapabilityInfos_001
732  * @tc.desc: Verify the CapabilityInfoManager SyncRemoteCapabilityInfos function.
733  * @tc.type: FUNC
734  * @tc.require: AR000GHSJE
735  */
736 HWTEST_F(ResourceManagerTest, SyncRemoteCapabilityInfos_001, TestSize.Level0)
737 {
738     CapabilityInfoManager::GetInstance()->globalCapInfoMap_.clear();
739     CapabilityInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
740     int32_t ret = CapabilityInfoManager::GetInstance()->SyncRemoteCapabilityInfos();
741     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
742 }
743 
744 /**
745  * @tc.name: RemoveCapabilityInfoInDB_001
746  * @tc.desc: Verify the RemoveCapabilityInfoInDB function.
747  * @tc.type: FUNC
748  * @tc.require: AR000GHSJE
749  */
750 HWTEST_F(ResourceManagerTest, RemoveCapabilityInfoInDB_001, TestSize.Level0)
751 {
752     std::string deviceIdEmpty;
753     uint32_t MAX_ID_LEN = 257;
754     deviceIdEmpty.resize(MAX_ID_LEN);
755     int32_t ret = CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoInDB(deviceIdEmpty);
756     EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
757 }
758 
759 /**
760  * @tc.name: RemoveCapabilityInfoInDB_002
761  * @tc.desc: Verify the RemoveCapabilityInfoInDB function.
762  * @tc.type: FUNC
763  * @tc.require: AR000GHSJE
764  */
765 HWTEST_F(ResourceManagerTest, RemoveCapabilityInfoInDB_002, TestSize.Level0)
766 {
767     std::string deviceIdEmpty = "deviceIdEmpty";
768     CapabilityInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
769     int32_t ret = CapabilityInfoManager::GetInstance()->RemoveCapabilityInfoInDB(deviceIdEmpty);
770     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
771 }
772 
773 /**
774  * @tc.name: HandleCapabilityDeleteChange_001
775  * @tc.desc: Verify the HandleCapabilityDeleteChange function.
776  * @tc.type: FUNC
777  * @tc.require: AR000GHSJE
778  */
779 HWTEST_F(ResourceManagerTest, HandleCapabilityDeleteChange_001, TestSize.Level0)
780 {
781     std::vector<DistributedKv::Entry> deleteRecords;
782     DistributedKv::Entry entry;
783     entry.key = "strBase";
784     entry.value = "strBase";
785     deleteRecords.push_back(entry);
786     CapabilityInfoManager::GetInstance()->HandleCapabilityDeleteChange(deleteRecords);
787     EXPECT_EQ(nullptr, CapabilityInfoManager::GetInstance()->dbAdapterPtr_);
788 }
789 
790 /**
791  * @tc.name: GetDataByKey_001
792  * @tc.desc: Verify the GetDataByKey function.
793  * @tc.type: FUNC
794  * @tc.require: AR000GHSJE
795  */
796 HWTEST_F(ResourceManagerTest, GetDataByKey_001, TestSize.Level0)
797 {
798     std::string key = "000";
799     std::shared_ptr<CapabilityInfo> capInfoPtr;
800     CapabilityInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
801     int32_t ret = CapabilityInfoManager::GetInstance()->GetDataByKey(key, capInfoPtr);
802     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
803 
804     key = "";
805     CapabilityInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
806     ret = CapabilityInfoManager::GetInstance()->GetDataByKey(key, capInfoPtr);
807     EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
808 }
809 
810 /**
811  * @tc.name: GetDataByKeyPrefix_001
812  * @tc.desc: Verify the GetDataByKeyPrefix function.
813  * @tc.type: FUNC
814  * @tc.require: AR000GHSJE
815  */
816 HWTEST_F(ResourceManagerTest, GetDataByKeyPrefix_001, TestSize.Level0)
817 {
818     std::string keyPrefix = "000";
819     CapabilityInfoMap capabilityMap;
820     CapabilityInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
821     int32_t ret = CapabilityInfoManager::GetInstance()->GetDataByKeyPrefix(keyPrefix, capabilityMap);
822     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
823 
824     keyPrefix = "";
825     CapabilityInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
826     ret = CapabilityInfoManager::GetInstance()->GetDataByKeyPrefix(keyPrefix, capabilityMap);
827     EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
828 }
829 
830 /**
831  * @tc.name: DumpCapabilityInfos_001
832  * @tc.desc: Verify the DumpCapabilityInfos function.
833  * @tc.type: FUNC
834  * @tc.require: AR000GHSJE
835  */
836 HWTEST_F(ResourceManagerTest, DumpCapabilityInfos_001, TestSize.Level0)
837 {
838     std::vector<CapabilityInfo> capInfos;
839     std::string dhId;
840     std::string devId;
841     std::string devName;
842     uint16_t devType = 0;
843     DHType dhType = DHType::GPS;
844     std::string dhAttrs;
845     std::string dhSubtype;
846     CapabilityInfo info(dhId, devId, devName, devType, dhType, dhAttrs, dhSubtype);
847     capInfos.push_back(info);
848     CapabilityInfoManager::GetInstance()->DumpCapabilityInfos(capInfos);
849     EXPECT_EQ(nullptr, CapabilityInfoManager::GetInstance()->dbAdapterPtr_);
850 }
851 
852 /**
853  * @tc.name: FromJson_001
854  * @tc.desc: Verify the FromJson function.
855  * @tc.type: FUNC
856  * @tc.require: AR000GHSJE
857  */
858 HWTEST_F(ResourceManagerTest, FromJson_001, TestSize.Level0)
859 {
860     std::string dhId;
861     std::string devId;
862     std::string devName;
863     uint16_t devType = 0;
864     DHType dhType = DHType::GPS;
865     std::string dhAttrs;
866     std::string dhSubtype;
867     CapabilityInfo info(dhId, devId, devName, devType, dhType, dhAttrs, dhSubtype);
868 
869     cJSON* json = cJSON_CreateObject();
870     if (json == nullptr) {
871         return;
872     }
873     const char* DH_ID = "dh_id";
874     const char* DEV_ID = "dev_id";
875     const char* DEV_NAME = "dev_name";
876     const char* DEV_TYPE = "dev_type";
877     const char* DH_TYPE = "dh_type";
878     const char* DH_ATTRS = "dh_attrs";
879     const char* DH_SUBTYPE = "dh_subtype";
880 
881     cJSON_AddStringToObject(json, DH_ID, "dh_id");
882     cJSON_AddStringToObject(json, DEV_ID, "dev_id");
883     cJSON_AddStringToObject(json, DEV_NAME, "dev_name");
884     cJSON_AddNumberToObject(json, DEV_TYPE, devType);
885     cJSON_AddStringToObject(json, DH_TYPE, "dh_type");
886     cJSON_AddStringToObject(json, DH_ATTRS, "dh_attrs");
887     cJSON_AddStringToObject(json, DH_SUBTYPE, "dh_subtype");
888 
889     char* cjson = cJSON_PrintUnformatted(json);
890     if (cjson == nullptr) {
891         cJSON_Delete(json);
892         return;
893     }
894     std::string jsonStr(cjson);
895     cJSON_free(cjson);
896     cJSON_Delete(json);
897     EXPECT_EQ(DH_FWK_SUCCESS, info.FromJsonString(jsonStr));
898 }
899 
900 /**
901  * @tc.name: GetEntriesByKeys_001
902  * @tc.desc: Verify the GetEntriesByKeys function.
903  * @tc.type: FUNC
904  * @tc.require: AR000GHSJE
905  */
906 HWTEST_F(ResourceManagerTest, GetEntriesByKeys_001, TestSize.Level0)
907 {
908     std::vector<std::string> keys {};
909     auto entries = CapabilityInfoManager::GetInstance()->GetEntriesByKeys(keys);
910     EXPECT_EQ(0, entries.size());
911 }
912 
913 HWTEST_F(ResourceManagerTest, Init_001, TestSize.Level0)
914 {
915     auto ret = LocalCapabilityInfoManager::GetInstance()->Init();
916     EXPECT_EQ(DH_FWK_SUCCESS, ret);
917 }
918 
919 HWTEST_F(ResourceManagerTest, UnInit_001, TestSize.Level0)
920 {
921     LocalCapabilityInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
922     auto ret = LocalCapabilityInfoManager::GetInstance()->UnInit();
923     EXPECT_EQ(ERR_DH_FWK_RESOURCE_UNINIT_DB_FAILED, ret);
924 }
925 
926 HWTEST_F(ResourceManagerTest, UnInit_002, TestSize.Level0)
927 {
928     LocalCapabilityInfoManager::GetInstance()->Init();
929     auto ret = LocalCapabilityInfoManager::GetInstance()->UnInit();
930     EXPECT_EQ(DH_FWK_SUCCESS, ret);
931 }
932 
933 HWTEST_F(ResourceManagerTest, SyncDeviceInfoFromDB_001, TestSize.Level0)
934 {
935     std::string deviceId = "deviceId_test";
936     LocalCapabilityInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
937     auto ret = LocalCapabilityInfoManager::GetInstance()->SyncDeviceInfoFromDB(deviceId);
938     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
939 
940     LocalCapabilityInfoManager::GetInstance()->Init();
941     ret = LocalCapabilityInfoManager::GetInstance()->SyncDeviceInfoFromDB(deviceId);
942     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_OPERATION_FAIL, ret);
943 }
944 
945 HWTEST_F(ResourceManagerTest, RemoveCapabilityInfoByKey_001, TestSize.Level0)
946 {
947     std::string key = "deviceId_test";
948     LocalCapabilityInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
949     auto ret = LocalCapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(key);
950     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
951 
952     LocalCapabilityInfoManager::GetInstance()->Init();
953     ret = LocalCapabilityInfoManager::GetInstance()->RemoveCapabilityInfoByKey(key);
954     EXPECT_EQ(DH_FWK_SUCCESS, ret);
955 }
956 
957 HWTEST_F(ResourceManagerTest, GetCapability_001, TestSize.Level0)
958 {
959     std::string deviceId = "deviceId_test";
960     std::string dhId = "dhId_test";
961     std::shared_ptr<CapabilityInfo> capPtr;
962     LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_.clear();
963     auto ret = LocalCapabilityInfoManager::GetInstance()->GetCapability(deviceId, dhId, capPtr);
964     EXPECT_EQ(ERR_DH_FWK_RESOURCE_CAPABILITY_MAP_NOT_FOUND, ret);
965 
966     std::shared_ptr<CapabilityInfo> capbilityInfo = std::make_shared<CapabilityInfo>(
967         dhId, deviceId, "devName_test", 14, DHType::AUDIO, "attrs", "subtype");
968     std::string key = deviceId + "###" + dhId;
969     LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capbilityInfo;
970     ret = LocalCapabilityInfoManager::GetInstance()->GetCapability(deviceId, dhId, capPtr);
971     LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_.clear();
972     EXPECT_EQ(DH_FWK_SUCCESS, ret);
973 }
974 
975 HWTEST_F(ResourceManagerTest, GetDataByKey_002, TestSize.Level0)
976 {
977     std::string key = "key_test";
978     std::shared_ptr<CapabilityInfo> capPtr;
979     LocalCapabilityInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
980     auto ret = LocalCapabilityInfoManager::GetInstance()->GetDataByKey(key, capPtr);
981     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
982 
983     LocalCapabilityInfoManager::GetInstance()->Init();
984     ret = LocalCapabilityInfoManager::GetInstance()->GetDataByKey(key, capPtr);
985     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_OPERATION_FAIL, ret);
986 }
987 
988 HWTEST_F(ResourceManagerTest, GetDataByDHType_001, TestSize.Level0)
989 {
990     CapabilityInfoMap capabilityMap;
991     std::string deviceId = "deviceId_test";
992     std::shared_ptr<CapabilityInfo> capbilityInfo = std::make_shared<CapabilityInfo>(
993         "dhId_test", deviceId, "devName_test", 14, DHType::AUDIO, "attrs", "subtype");
994     std::string key = deviceId + "###" + "dhId_test";
995     LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_[key] = capbilityInfo;
996     auto ret = LocalCapabilityInfoManager::GetInstance()->GetDataByDHType(DHType::CAMERA, capabilityMap);
997     EXPECT_EQ(DH_FWK_SUCCESS, ret);
998 
999     ret = LocalCapabilityInfoManager::GetInstance()->GetDataByDHType(DHType::AUDIO, capabilityMap);
1000     LocalCapabilityInfoManager::GetInstance()->globalCapInfoMap_.clear();
1001     EXPECT_EQ(DH_FWK_SUCCESS, ret);
1002 }
1003 
1004 HWTEST_F(ResourceManagerTest, GetDataByKeyPrefix_002, TestSize.Level0)
1005 {
1006     std::string keyPrefix = "keyPrefix_test";
1007     CapabilityInfoMap capabilityMap;
1008     LocalCapabilityInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
1009     auto ret = LocalCapabilityInfoManager::GetInstance()->GetDataByKeyPrefix(keyPrefix, capabilityMap);
1010     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
1011 
1012     LocalCapabilityInfoManager::GetInstance()->Init();
1013     ret = LocalCapabilityInfoManager::GetInstance()->GetDataByKeyPrefix(keyPrefix, capabilityMap);
1014     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_OPERATION_FAIL, ret);
1015 }
1016 
1017 HWTEST_F(ResourceManagerTest, UnInit_003, TestSize.Level0)
1018 {
1019     MetaInfoManager::GetInstance()->Init();
1020     auto ret = MetaInfoManager::GetInstance()->UnInit();
1021     EXPECT_EQ(DH_FWK_SUCCESS, ret);
1022 }
1023 
1024 HWTEST_F(ResourceManagerTest, AddMetaCapInfos_001, TestSize.Level0)
1025 {
1026     std::string deviceId = "deviceId_test";
1027     std::string udidHash = "udidHash_test";
1028     std::string dhId = "dhId_test";
1029     MetaInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
1030     std::shared_ptr<MetaCapabilityInfo> dhMetaCapInfo = std::make_shared<MetaCapabilityInfo>(
1031         dhId, deviceId, "devName_test", 14, DHType::CAMERA, "attrs_test", "subtype", udidHash, "1.0");
1032     std::vector<std::shared_ptr<MetaCapabilityInfo>> metaCapInfos;
1033     metaCapInfos.push_back(dhMetaCapInfo);
1034     auto ret = MetaInfoManager::GetInstance()->AddMetaCapInfos(metaCapInfos);
1035     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
1036 }
1037 
1038 HWTEST_F(ResourceManagerTest, SyncMetaInfoFromDB_001, TestSize.Level0)
1039 {
1040     std::string deviceId = "deviceId_test";
1041     MetaInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
1042     auto ret = MetaInfoManager::GetInstance()->SyncMetaInfoFromDB(deviceId);
1043     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
1044 
1045     MetaInfoManager::GetInstance()->Init();
1046     ret = MetaInfoManager::GetInstance()->SyncMetaInfoFromDB(deviceId);
1047     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_OPERATION_FAIL, ret);
1048 }
1049 
1050 HWTEST_F(ResourceManagerTest, GetDataByKeyPrefix_003, TestSize.Level0)
1051 {
1052     std::string keyPrefix = "keyPrefix_test";
1053     MetaCapInfoMap metaCapMap;
1054     MetaInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
1055     auto ret = MetaInfoManager::GetInstance()->GetDataByKeyPrefix(keyPrefix, metaCapMap);
1056     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
1057 
1058     MetaInfoManager::GetInstance()->Init();
1059     ret = MetaInfoManager::GetInstance()->GetDataByKeyPrefix(keyPrefix, metaCapMap);
1060     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_OPERATION_FAIL, ret);
1061 }
1062 
1063 HWTEST_F(ResourceManagerTest, RemoveMetaInfoByKey_001, TestSize.Level0)
1064 {
1065     std::string key = "key_test";
1066     MetaInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
1067     auto ret = MetaInfoManager::GetInstance()->RemoveMetaInfoByKey(key);
1068     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
1069 
1070     MetaInfoManager::GetInstance()->Init();
1071     ret = MetaInfoManager::GetInstance()->RemoveMetaInfoByKey(key);
1072     EXPECT_EQ(DH_FWK_SUCCESS, ret);
1073 }
1074 
1075 HWTEST_F(ResourceManagerTest, GetMetaCapInfo_001, TestSize.Level0)
1076 {
1077     std::string deviceId = "deviceId_test";
1078     std::string udidHash = "udidHash_test";
1079     std::string dhId = "dhId_test";
1080     std::shared_ptr<MetaCapabilityInfo> metaCapPtr;
1081     MetaInfoManager::GetInstance()->globalMetaInfoMap_.clear();
1082     auto ret = MetaInfoManager::GetInstance()->GetMetaCapInfo(deviceId, dhId, metaCapPtr);
1083     EXPECT_EQ(ERR_DH_FWK_RESOURCE_CAPABILITY_MAP_NOT_FOUND, ret);
1084 
1085     std::shared_ptr<MetaCapabilityInfo> dhMetaCapInfo = std::make_shared<MetaCapabilityInfo>(
1086         dhId, deviceId, "devName_test", 14, DHType::CAMERA, "attrs_test", "subtype", udidHash, "1.0");
1087     std::string key = udidHash + "###" + dhId;
1088     MetaInfoManager::GetInstance()->globalMetaInfoMap_[key] = dhMetaCapInfo;
1089     ret = MetaInfoManager::GetInstance()->GetMetaCapInfo(udidHash, dhId, metaCapPtr);
1090     MetaInfoManager::GetInstance()->globalMetaInfoMap_.clear();
1091     EXPECT_EQ(DH_FWK_SUCCESS, ret);
1092 
1093     MetaInfoManager::GetInstance()->globalMetaInfoMap_[key] = dhMetaCapInfo;
1094     std::vector<std::shared_ptr<MetaCapabilityInfo>> metaCapInfos;
1095     MetaInfoManager::GetInstance()->GetMetaCapInfosByUdidHash(udidHash, metaCapInfos);
1096     MetaInfoManager::GetInstance()->globalMetaInfoMap_.clear();
1097 
1098     MetaInfoManager::GetInstance()->globalMetaInfoMap_[key] = dhMetaCapInfo;
1099     MetaInfoManager::GetInstance()->GetMetaCapInfosByUdidHash(udidHash, metaCapInfos);
1100     MetaInfoManager::GetInstance()->globalMetaInfoMap_.clear();
1101 }
1102 
1103 HWTEST_F(ResourceManagerTest, GetMetaCapByValue_001, TestSize.Level0)
1104 {
1105     std::string value = "";
1106     std::shared_ptr<MetaCapabilityInfo> metaCapPtr = nullptr;
1107     auto ret = MetaInfoManager::GetInstance()->GetMetaCapByValue(value, metaCapPtr);
1108     EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
1109 
1110     std::string deviceId = "deviceId_test";
1111     std::string udidHash = "udidHash_test";
1112     std::string dhId = "dhId_test";
1113     metaCapPtr = std::make_shared<MetaCapabilityInfo>(
1114         dhId, deviceId, "devName_test", 14, DHType::CAMERA, "attrs_test", "subtype", udidHash, "1.0");
1115     ret = MetaInfoManager::GetInstance()->GetMetaCapByValue(value, metaCapPtr);
1116     EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
1117 
1118     value = "invalid JSON string";
1119     ret = MetaInfoManager::GetInstance()->GetMetaCapByValue(value, metaCapPtr);
1120     EXPECT_EQ(ERR_DH_FWK_JSON_PARSE_FAILED, ret);
1121 }
1122 
1123 HWTEST_F(ResourceManagerTest, GetEntriesByKeys_002, TestSize.Level0)
1124 {
1125     std::vector<std::string> keys;
1126     auto ret = MetaInfoManager::GetInstance()->GetEntriesByKeys(keys);
1127     EXPECT_EQ(0, ret.size());
1128 
1129     MetaInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
1130     keys.push_back("key_test");
1131     ret = MetaInfoManager::GetInstance()->GetEntriesByKeys(keys);
1132     EXPECT_EQ(0, ret.size());
1133 
1134     MetaInfoManager::GetInstance()->Init();
1135     ret = MetaInfoManager::GetInstance()->GetEntriesByKeys(keys);
1136     EXPECT_EQ(0, ret.size());
1137 }
1138 
1139 HWTEST_F(ResourceManagerTest, FromJson_002, TestSize.Level0)
1140 {
1141     MetaCapabilityInfo metaCapInfo;
1142     std::string dhId = "dhId_test";
1143     std::string dveId = "devId_test";
1144     std::string devName = "devName_test";
1145     uint16_t devType = 14;
1146     DHType dhType = DHType::AUDIO;
1147     std::string dhAttrs = "dhAttrs_test";
1148     std::string dhSubtype = "dhSubtype_test";
1149     std::string sinkVersion = "sinkVersion_test";
1150     cJSON *jsonObj = cJSON_CreateObject();
1151     if (jsonObj == nullptr) {
1152         return;
1153     }
1154     cJSON_AddStringToObject(jsonObj, DH_ID.c_str(), dhId.c_str());
1155     cJSON_AddStringToObject(jsonObj, DEV_ID.c_str(), dveId.c_str());
1156     cJSON_AddStringToObject(jsonObj, DEV_NAME.c_str(), devName.c_str());
1157     cJSON_AddNumberToObject(jsonObj, DEV_TYPE.c_str(), (double)devType);
1158     cJSON_AddNumberToObject(jsonObj, DH_TYPE.c_str(), (double)dhType);
1159     cJSON_AddStringToObject(jsonObj, DH_ATTRS.c_str(), dhAttrs.c_str());
1160     cJSON_AddStringToObject(jsonObj, DH_SUBTYPE.c_str(), sinkVersion.c_str());
1161     cJSON_AddStringToObject(jsonObj, SINK_VER.c_str(), sinkVersion.c_str());
1162     FromJson(jsonObj, metaCapInfo);
1163     EXPECT_EQ(0, MetaInfoManager::GetInstance()->globalMetaInfoMap_.size());
1164 }
1165 
1166 HWTEST_F(ResourceManagerTest, GetMetaDataByDHType_001, TestSize.Level0)
1167 {
1168     MetaInfoManager::GetInstance()->globalMetaInfoMap_.clear();
1169     std::string deviceId = "deviceId_test";
1170     std::string udidHash = "udidHash_test";
1171     std::string dhId = "dhId_test";
1172     MetaCapInfoMap metaInfoMap;
1173     std::shared_ptr<MetaCapabilityInfo> dhMetaCapInfo = std::make_shared<MetaCapabilityInfo>(
1174         dhId, deviceId, "devName_test", 14, DHType::CAMERA, "attrs_test", "subtype", udidHash, "1.0");
1175     std::string key = udidHash + "###" + dhId;
1176     MetaInfoManager::GetInstance()->globalMetaInfoMap_[key] = dhMetaCapInfo;
1177     auto ret = MetaInfoManager::GetInstance()->GetMetaDataByDHType(DHType::AUDIO, metaInfoMap);
1178     EXPECT_EQ(DH_FWK_SUCCESS, ret);
1179 }
1180 
1181 HWTEST_F(ResourceManagerTest, GetMetaDataByDHType_002, TestSize.Level0)
1182 {
1183     MetaInfoManager::GetInstance()->globalMetaInfoMap_.clear();
1184     std::string deviceId = "deviceId_test";
1185     std::string udidHash = "udidHash_test";
1186     std::string dhId = "dhId_test";
1187     MetaCapInfoMap metaInfoMap;
1188     std::shared_ptr<MetaCapabilityInfo> dhMetaCapInfo = std::make_shared<MetaCapabilityInfo>(
1189         dhId, deviceId, "devName_test", 14, DHType::AUDIO, "attrs_test", "subtype", udidHash, "1.0");
1190     std::string key = udidHash + "###" + dhId;
1191     MetaInfoManager::GetInstance()->globalMetaInfoMap_[key] = dhMetaCapInfo;
1192     auto ret = MetaInfoManager::GetInstance()->GetMetaDataByDHType(DHType::AUDIO, metaInfoMap);
1193     EXPECT_EQ(DH_FWK_SUCCESS, ret);
1194 }
1195 
1196 HWTEST_F(ResourceManagerTest, SyncDataByNetworkId_001, TestSize.Level0)
1197 {
1198     std::string networkId = "";
1199     auto ret = MetaInfoManager::GetInstance()->SyncDataByNetworkId(networkId);
1200     EXPECT_EQ(ERR_DH_FWK_PARA_INVALID, ret);
1201 
1202     networkId = "networkId_test";
1203     ret = MetaInfoManager::GetInstance()->SyncDataByNetworkId(networkId);
1204     EXPECT_EQ(DH_FWK_SUCCESS, ret);
1205 
1206 
1207     MetaInfoManager::GetInstance()->dbAdapterPtr_ = nullptr;
1208     ret = MetaInfoManager::GetInstance()->SyncDataByNetworkId(networkId);
1209     EXPECT_EQ(ERR_DH_FWK_RESOURCE_DB_ADAPTER_POINTER_NULL, ret);
1210 }
1211 } // namespace DistributedHardware
1212 } // namespace OHOS
1213